lpsolver 0.1.0 → 0.2.1

data/ext/lpsolver-highs/highs/ipm/hipo/auxiliary/Auxiliary.cpp

@@ -0,0 +1,301 @@
+#include "Auxiliary.h"
+
+#include <stack>
+
+namespace hipo {
+
+void inversePerm(const std::vector<Int>& perm, std::vector<Int>& iperm) {
+  // Given the permutation perm, produce the inverse permutation iperm.
+  // perm[i] : i-th entry to use in the new order.
+  // iperm[i]: where entry i is located in the new order.
+
+  for (Int i = 0; i < static_cast<Int>(perm.size()); ++i) {
+    iperm[perm[i]] = i;
+  }
+}
+
+void subtreeSize(const std::vector<Int>& parent, std::vector<Int>& sizes) {
+  // Compute sizes of subtrees of the tree given by parent
+
+  Int n = parent.size();
+  sizes.assign(n, 1);
+
+  for (Int i = 0; i < n; ++i) {
+    Int k = parent[i];
+    if (k != -1) sizes[k] += sizes[i];
+  }
+}
+
+void transpose(const std::vector<Int>& ptr, const std::vector<Int>& rows,
+               std::vector<Int>& ptrT, std::vector<Int>& rowsT) {
+  // Compute the transpose of the matrix and return it in rowsT and ptrT
+
+  Int n = ptr.size() - 1;
+
+  std::vector<Int> work(n);
+
+  // count the entries in each row into work
+  for (Int i = 0; i < ptr.back(); ++i) {
+    ++work[rows[i]];
+  }
+
+  // sum row sums to obtain pointers
+  counts2Ptr(ptrT, work);
+
+  for (Int j = 0; j < n; ++j) {
+    for (Int el = ptr[j]; el < ptr[j + 1]; ++el) {
+      Int i = rows[el];
+
+      // entry (i,j) becomes entry (j,i)
+      Int pos = work[i]++;
+      rowsT[pos] = j;
+    }
+  }
+}
+
+void transpose(const std::vector<Int>& ptr, const std::vector<Int>& rows,
+               const std::vector<double>& val, std::vector<Int>& ptrT,
+               std::vector<Int>& rowsT, std::vector<double>& valT) {
+  // Compute the transpose of the matrix and return it in rowsT, ptrT and valT
+
+  Int n = ptr.size() - 1;
+
+  std::vector<Int> work(n);
+
+  // count the entries in each row into work
+  for (Int i = 0; i < ptr.back(); ++i) {
+    ++work[rows[i]];
+  }
+
+  // sum row sums to obtain pointers
+  counts2Ptr(ptrT, work);
+
+  for (Int j = 0; j < n; ++j) {
+    for (Int el = ptr[j]; el < ptr[j + 1]; ++el) {
+      Int i = rows[el];
+
+      // entry (i,j) becomes entry (j,i)
+      Int pos = work[i]++;
+      rowsT[pos] = j;
+      valT[pos] = val[el];
+    }
+  }
+}
+
+void childrenLinkedList(const std::vector<Int>& parent, std::vector<Int>& head,
+                        std::vector<Int>& next) {
+  // Create linked lists of children in elimination tree.
+  // parent gives the dependencies of the tree,
+  // head[node] is the first child of node,
+  // next[head[node]] is the second child,
+  // next[next[head[node]]] is the third child...
+  // until -1 is reached.
+
+  Int n = parent.size();
+  head.assign(n, -1);
+  next.assign(n, -1);
+  for (Int node = n - 1; node >= 0; --node) {
+    if (parent[node] == -1) continue;
+    next[node] = head[parent[node]];
+    head[parent[node]] = node;
+  }
+}
+
+void reverseLinkedList(std::vector<Int>& head, std::vector<Int>& next) {
+  // Reverse the linked list of children of each node.
+  // If a node has children (a -> b -> c -> -1), the reverse list contains
+  // children (c -> b -> a -> -1).
+
+  const Int n = head.size();
+
+  for (Int node = 0; node < n; ++node) {
+    Int prev_node = -1;
+    Int curr_node = head[node];
+    Int next_node = -1;
+
+    while (curr_node != -1) {
+      next_node = next[curr_node];
+      next[curr_node] = prev_node;
+      prev_node = curr_node;
+      curr_node = next_node;
+    }
+
+    head[node] = prev_node;
+  }
+}
+
+void dfsPostorder(Int node, Int& start, std::vector<Int>& head,
+                  const std::vector<Int>& next, std::vector<Int>& order) {
+  // Perform depth first search starting from root node and order the nodes
+  // starting from the value start. head and next contain the linked list of
+  // children.
+
+  std::stack<Int> stack;
+  stack.push(node);
+
+  while (!stack.empty()) {
+    const Int current = stack.top();
+    const Int child = head[current];
+
+    if (child == -1) {
+      // no children left to order,
+      // remove from the stack and order
+      stack.pop();
+      order[start++] = current;
+    } else {
+      // at least one child left to order,
+      // add it to the stack and remove it from the list of children
+      stack.push(child);
+      head[current] = next[child];
+    }
+  }
+}
+
+void processEdge(Int j, Int i, const std::vector<Int>& first,
+                 std::vector<Int>& maxfirst, std::vector<Int>& delta,
+                 std::vector<Int>& prevleaf, std::vector<Int>& ancestor) {
+  // Process edge of skeleton matrix.
+  // Taken from Tim Davis "Direct Methods for Sparse Linear Systems".
+
+  // j not a leaf of ith row subtree
+  if (i <= j || first[j] <= maxfirst[i]) {
+    return;
+  }
+
+  // max first[j] so far
+  maxfirst[i] = first[j];
+
+  // previous leaf of ith row subtree
+  Int jprev = prevleaf[i];
+
+  // A(i,j) is in the skeleton matrix
+  delta[j]++;
+
+  if (jprev != -1) {
+    // find least common ancestor of jprev and j
+    Int q = jprev;
+    while (q != ancestor[q]) {
+      q = ancestor[q];
+    }
+
+    // path compression
+    Int sparent;
+    for (Int s = jprev; s != q; s = sparent) {
+      sparent = ancestor[s];
+      ancestor[s] = q;
+    }
+
+    // consider overlap
+    delta[q]--;
+  }
+
+  // previous leaf of ith subtree set to j
+  prevleaf[i] = j;
+}
+
+Int64 getDiagStart(Int n, Int k, Int nb, Int n_blocks,
+                   std::vector<Int64>& start, bool triang) {
+  // start position of diagonal blocks for blocked dense formats
+  start.assign(n_blocks, 0);
+  for (Int i = 1; i < n_blocks; ++i) {
+    start[i] = start[i - 1] + nb * (n - (i - 1) * nb);
+    if (triang) start[i] -= nb * (nb - 1) / 2;
+  }
+
+  Int jb = std::min(nb, k - (n_blocks - 1) * nb);
+  Int64 result = start.back() + (Int64)(n - (n_blocks - 1) * nb) * jb;
+  if (triang) result -= jb * (jb - 1) / 2;
+  return result;
+}
+
+Int maxDepthTree(const std::vector<Int>& parent) {
+  Int max_depth = 0;
+  Int n = parent.size();
+  std::vector<Int> depth(n, -1);
+  for (Int i = 0; i < n; ++i) {
+    Int node = i;
+    Int value = 1;
+    while (node != -1) {
+      if (value > depth[node]) {
+        depth[node] = value;
+      } else
+        break;
+
+      ++value;
+      node = parent[node];
+    }
+    if (parent[i] == -1) max_depth = std::max(max_depth, depth[i]);
+  }
+  return max_depth;
+}
+
+void fullFromLower(const std::vector<Int>& ptrL, const std::vector<Int>& rowsL,
+                   std::vector<Int>& ptrF, std::vector<Int>& rowsF) {
+  // Given a sparse matrix in lower triangular format, build the same matrix in
+  // full format, without diagonal entries.
+
+  std::vector<Int> rowsU(rowsL.size());
+  std::vector<Int> ptrU(ptrL.size());
+  transpose(ptrL, rowsL, ptrU, rowsU);
+
+  const Int n = ptrL.size() - 1;
+  std::vector<Int> work(n);
+  for (Int j = 0; j < n; ++j) {
+    for (Int el = ptrU[j]; el < ptrU[j + 1]; ++el) {
+      const Int i = rowsU[el];
+      if (i == j) continue;
+      ++work[j];
+      ++work[i];
+    }
+  }
+
+  ptrF.assign(n + 1, 0);
+  counts2Ptr(ptrF, work);
+  rowsF.assign(ptrF.back(), 0);
+  for (Int j = 0; j < n; ++j) {
+    for (Int el = ptrU[j]; el < ptrU[j + 1]; ++el) {
+      const Int i = rowsU[el];
+      if (i == j) continue;
+      rowsF[work[j]++] = i;
+      rowsF[work[i]++] = j;
+    }
+  }
+}
+
+double snFlops(double size, double clique_size) {
+  return (size + clique_size) * (size + clique_size) * size -
+         (size + clique_size) * size * (size + 1) +
+         size * (size + 1) * (2 * size + 1) / 6;
+}
+double snSpops(double clique_size) {
+  return clique_size * (clique_size + 1) / 2;
+}
+
+Clock::Clock() { start(); }
+void Clock::start() { t0 = std::chrono::high_resolution_clock::now(); }
+double Clock::stop() const {
+  auto t1 = std::chrono::high_resolution_clock::now();
+  std::chrono::duration<double> d = t1 - t0;
+  return d.count();
+}
+
+TaskGroupSpecial::~TaskGroupSpecial() {
+  // Using TaskGroup may throw an exception when tasks are cancelled. Not sure
+  // exactly why this happens, but for now this fix seems to work.
+
+  // No virtual destructor in TaskGroup. Do not call this class via pointer to
+  // the base!
+
+  cancel();
+
+  while (true) {
+    try {
+      taskWait();
+      break;
+    } catch (HighsTask::Interrupt) {
+      continue;
+    }
+  }
+}
+
+}  // namespace hipo

data/ext/lpsolver-highs/highs/ipm/hipo/auxiliary/Auxiliary.h

@@ -0,0 +1,104 @@
+#ifndef HIPO_AUXILIARY_H
+#define HIPO_AUXILIARY_H
+
+#include <chrono>
+#include <fstream>
+#include <iomanip>
+#include <string>
+#include <vector>
+
+#include "ipm/hipo/auxiliary/IntConfig.h"
+#include "parallel/HighsParallel.h"
+
+namespace hipo {
+
+void inversePerm(const std::vector<Int>& perm, std::vector<Int>& iperm);
+void subtreeSize(const std::vector<Int>& parent, std::vector<Int>& sizes);
+void transpose(const std::vector<Int>& ptr, const std::vector<Int>& rows,
+               std::vector<Int>& ptrT, std::vector<Int>& rowsT);
+void transpose(const std::vector<Int>& ptr, const std::vector<Int>& rows,
+               const std::vector<double>& val, std::vector<Int>& ptrT,
+               std::vector<Int>& rowsT, std::vector<double>& valT);
+void childrenLinkedList(const std::vector<Int>& parent, std::vector<Int>& head,
+                        std::vector<Int>& next);
+void reverseLinkedList(std::vector<Int>& head, std::vector<Int>& next);
+void dfsPostorder(Int node, Int& start, std::vector<Int>& head,
+                  const std::vector<Int>& next, std::vector<Int>& order);
+void processEdge(Int j, Int i, const std::vector<Int>& first,
+                 std::vector<Int>& maxfirst, std::vector<Int>& delta,
+                 std::vector<Int>& prevleaf, std::vector<Int>& ancestor);
+Int64 getDiagStart(Int n, Int k, Int nb, Int n_blocks,
+                   std::vector<Int64>& start, bool triang = false);
+Int maxDepthTree(const std::vector<Int>& parent);
+void fullFromLower(const std::vector<Int>& ptrL, const std::vector<Int>& rowsL,
+                   std::vector<Int>& ptrF, std::vector<Int>& rowsF);
+double snFlops(double size, double clique_size);
+double snSpops(double clique_size);
+
+template <typename T>
+void counts2Ptr(std::vector<T>& ptr, std::vector<T>& w) {
+  // Given the column counts in the vector w (of size n),
+  // compute the column pointers in the vector ptr (of size n+1),
+  // and copy the first n pointers back into w.
+
+  T temp_nz{};
+  T n = w.size();
+  for (T j = 0; j < n; ++j) {
+    ptr[j] = temp_nz;
+    temp_nz += w[j];
+    w[j] = ptr[j];
+  }
+  ptr[n] = temp_nz;
+}
+
+template <typename T>
+void permuteVector(std::vector<T>& v, const std::vector<Int>& perm) {
+  // Permute vector v according to permutation perm.
+  std::vector<T> temp_v(v);
+  for (Int i = 0; i < static_cast<Int>(v.size()); ++i) v[i] = temp_v[perm[i]];
+}
+
+template <typename T>
+void permuteVectorInverse(std::vector<T>& v, const std::vector<Int>& iperm) {
+  // Permute vector v according to inverse permutation iperm.
+  std::vector<T> temp_v(v);
+  for (Int i = 0; i < static_cast<Int>(v.size()); ++i) v[iperm[i]] = temp_v[i];
+}
+
+template <typename T>
+void printTest(const std::vector<T>& v, const std::string s) {
+  std::ofstream out_file;
+  char name[80];
+  snprintf(name, 80, "%s.txt", s.c_str());
+  out_file.open(name);
+  for (T i : v) {
+    out_file << std::setprecision(16) << i << '\n';
+  }
+  out_file.close();
+}
+
+template <typename T>
+void freeVector(std::vector<T>& v) {
+  // Give up memory allocated to v.
+  // (technically shrink_to_fit does not guarantee to deallocate)
+  v.clear();
+  v.shrink_to_fit();
+}
+
+class Clock {
+  std::chrono::high_resolution_clock::time_point t0;
+
+ public:
+  Clock();
+  void start();
+  double stop() const;
+};
+
+class TaskGroupSpecial : public highs::parallel::TaskGroup {
+ public:
+  ~TaskGroupSpecial();
+};
+
+}  // namespace hipo
+
+#endif

data/ext/lpsolver-highs/highs/ipm/hipo/auxiliary/IntConfig.h

@@ -0,0 +1,27 @@
+#ifndef HIPO_INT_CONFIG_H
+#define HIPO_INT_CONFIG_H
+
+#include "lp_data/HConst.h"
+#include "util/HighsInt.h"
+
+namespace hipo {
+
+// Generic integer type from HiGHS
+typedef HighsInt Int;
+
+// Integer type for factorisation
+typedef int64_t Int64;
+
+// The matrix (AS or NE) is formed using Int, so it must have fewer than
+// kHighsIInf nonzero entries.
+//
+// The factorisation uses a combination of Int and Int64. Int64 is used only
+// where needed, i.e. when dealing with nonzeros of the factor or when checking
+// overflows.
+// BLAS is 32-bit, so the vectors used by BLAS must be addressable with 32-bit
+// integers.
+//
+
+}  // namespace hipo
+
+#endif

data/ext/lpsolver-highs/highs/ipm/hipo/auxiliary/KrylovMethods.cpp

@@ -0,0 +1,193 @@
+#include "KrylovMethods.h"
+
+#include <cmath>
+#include <iostream>
+
+#include "VectorOperations.h"
+#include "ipm/hipo/auxiliary/Log.h"
+
+namespace hipo {
+
+static void applyRotation(double& x, double& y, double c, double s) {
+  double t = c * x + s * y;
+  y = -s * x + c * y;
+  x = t;
+}
+static void getRotation(double x, double y, double& c, double& s) {
+  if (y == 0.0) {
+    c = 1.0;
+    s = 0.0;
+  } else if (std::abs(y) > std::abs(x)) {
+    double t = x / y;
+    s = 1.0 / sqrt(1.0 + t * t);
+    c = t * s;
+  } else {
+    double t = y / x;
+    c = 1.0 / sqrt(1.0 + t * t);
+    s = t * c;
+  }
+}
+static void update(std::vector<double>& x, Int k, std::vector<double>& H, Int ldh,
+                   std::vector<double>& s, std::vector<std::vector<double>>& V) {
+  // Solve H * y = s
+  std::vector<double> y = s;
+  for (Int i = k; i >= 0; --i) {
+    y[i] /= H[i + ldh * i];
+    for (Int j = i - 1; j >= 0; --j) {
+      y[j] -= H[j + ldh * i] * y[i];
+    }
+  }
+  // x += V * y
+  for (Int j = 0; j <= k; ++j) vectorAdd(x, V[j], y[j]);
+}
+
+Int Gmres(const AbstractMatrix* M, const AbstractMatrix* P,
+          const std::vector<double>& b, std::vector<double>& x, double tol,
+          Int maxit) {
+  // Attempt to solve M * x = b using GMRES, with the preconditioner P.
+  // Return the number of iterations taken.
+  //
+  // Based on Netlib implementation and Kelley "Iterative Methods for Linear and
+  // Nonlinear Equations":
+  // https://www.netlib.org/templates/cpp/gmres.h
+  // https://www.netlib.org/templates/templates.pdf
+  // https://en.wikipedia.org/wiki/Generalized_minimal_residual_method#Example_code
+
+  // sizes
+  const Int n = x.size();
+  const Int m = maxit;
+
+  // vectors
+  std::vector<std::vector<double>> V;
+
+  // Hessenberg matrix
+  std::vector<double> H((m + 1) * m);
+  const Int ldh = m + 1;
+
+  // Givens rotations
+  std::vector<double> sn(m + 1);
+  std::vector<double> cs(m + 1);
+
+  // workspace
+  std::vector<double> w(n);
+
+  // preconditioned residual P^-1 * (b - M * x)
+  std::vector<double> r = x;
+  M->apply(r);
+  vectorAdd(r, b, 1.0, -1.0);
+  if (P) P->apply(r);
+  double beta = norm2(r);
+
+  // preconditioned rhs P^-1 * b
+  w = b;
+  if (P) P->apply(w);
+  double normb = norm2(w);
+
+  if (normb == 0.0) normb = 1.0;
+  if (beta <= tol) return 0;
+
+  V.push_back(r);
+  vectorScale(V[0], 1.0 / beta);
+
+  // s = beta * e1
+  std::vector<double> s(m + 1);
+  s[0] = beta;
+
+  // main loop
+  Int i;
+  for (i = 0; i < maxit; ++i) {
+    // Arnoldi
+    w = V[i];
+    M->apply(w);
+    if (P) P->apply(w);
+    V.push_back(w);
+    for (Int k = 0; k <= i; ++k) {
+      H[k + ldh * i] = dotProd(V.back(), V[k]);
+      vectorAdd(V.back(), V[k], -H[k + ldh * i]);
+    }
+    H[i + 1 + ldh * i] = norm2(V.back());
+
+    // re-orthogonalize
+    // if (norm2(V.back()) / norm2(w) < 1e-6) {
+    // printf("Re-orthogonalize============\n");
+    for (Int k = 0; k <= i; ++k) {
+      double temp = dotProd(V.back(), V[k]);
+      H[k + ldh * i] += temp;
+      vectorAdd(V.back(), V[k], -temp);
+    }
+    H[i + 1 + ldh * i] = norm2(V.back());
+    // }
+
+    // normalize
+    vectorScale(V.back(), 1.0 / H[i + 1 + ldh * i]);
+
+    // apply Givens rotations
+    for (Int k = 0; k < i; ++k)
+      applyRotation(H[k + ldh * i], H[k + 1 + ldh * i], cs[k], sn[k]);
+
+    // get latest rotation and apply it also to s
+    getRotation(H[i + ldh * i], H[i + 1 + ldh * i], cs[i], sn[i]);
+    applyRotation(H[i + ldh * i], H[i + 1 + ldh * i], cs[i], sn[i]);
+    applyRotation(s[i], s[i + 1], cs[i], sn[i]);
+
+    // check termination
+    if (std::abs(s[i + 1]) < tol) break;
+  }
+
+  // compute solution
+  update(x, i, H, ldh, s, V);
+
+  return i + 1;
+}
+
+Int Cg(const AbstractMatrix* M, const AbstractMatrix* P,
+       const std::vector<double>& b, std::vector<double>& x, double tol,
+       Int maxit) {
+  // Attempt to solve M * x = b using CG, with the preconditioner P.
+  // Return the number of iterations taken.
+
+  Int n = b.size();
+
+  std::vector<double> w(n);
+
+  std::vector<double> r = x;
+  M->apply(r);
+  vectorAdd(r, b, 1.0, -1.0);
+
+  std::vector<double> z = r;
+  if (P) P->apply(z);
+
+  std::vector<double> p(z);
+
+  double rho_old = dotProd(r, z);
+  double rho_new;
+  double norm_b = norm2(b);
+
+  Int iter = 0;
+  while (iter < maxit) {
+    w = p;
+    M->apply(w);
+    double alpha = rho_old / dotProd(p, w);
+    vectorAdd(x, p, alpha);
+    vectorAdd(r, w, -alpha);
+
+    z = r;
+    if (P) P->apply(z);
+    rho_new = dotProd(r, z);
+
+    if (norm2(r) < tol * norm_b) break;
+
+    vectorAdd(p, z, 1.0, rho_new / rho_old);
+    rho_old = rho_new;
+    ++iter;
+
+    if (isNanVector(x)) {
+      // log->printDevInfo("CG: x is nan at iter %d\n", (int)iter);
+      break;
+    }
+  }
+
+  return iter;
+}
+
+}  // namespace hipo

data/ext/lpsolver-highs/highs/ipm/hipo/auxiliary/KrylovMethods.h

@@ -0,0 +1,30 @@
+#ifndef HIPO_KRYLOV_METHODS_H
+#define HIPO_KRYLOV_METHODS_H
+
+#include <vector>
+
+#include "ipm/hipo/auxiliary/IntConfig.h"
+
+namespace hipo {
+
+// Abstract class for matrices inside of a Krylov method
+class AbstractMatrix {
+ public:
+  virtual void apply(std::vector<double>& x) const = 0;
+};
+
+// =================
+// Krylov solvers
+// =================
+
+Int Gmres(const AbstractMatrix* M, const AbstractMatrix* P,
+          const std::vector<double>& b, std::vector<double>& x, double tol,
+          Int maxit);
+
+Int Cg(const AbstractMatrix* M, const AbstractMatrix* P,
+       const std::vector<double>& b, std::vector<double>& x, double tol,
+       Int maxit);
+
+}  // namespace hipo
+
+#endif