lpsolver 0.1.0 → 0.2.0

data/ext/lpsolver-highs/build/include/highs/util/HighsSort.h

@@ -0,0 +1,131 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/**@file util/HighsSort.h
+ * @brief Sorting routines for HiGHS
+ */
+#ifndef UTIL_HIGHSSORT_H_
+#define UTIL_HIGHSSORT_H_
+
+#include <vector>
+
+#include "lp_data/HConst.h"
+
+using std::vector;
+
+void addToDecreasingHeap(HighsInt& n, HighsInt mx_n, vector<double>& heap_v,
+                         vector<HighsInt>& heap_ix, double v, HighsInt ix);
+void sortDecreasingHeap(const HighsInt n, vector<double>& heap_v,
+                        vector<HighsInt>& heap_ix);
+/**
+ * @brief Sort values[1..n] of an array by increasing value
+ */
+void maxheapsort(HighsInt* heap_v,  //!< HighsInt values to be sorted
+                 HighsInt n         //!< Number of values to be sorted
+);
+/**
+ * @brief Sort values[1..n] of an array by increasing value with corresponding
+ * indices
+ */
+void maxheapsort(
+    HighsInt* heap_v,  //!< Values to be sorted
+    HighsInt* heap_i,  //!< Indices corresponding to (sorted) values
+    HighsInt n         //!< Number of values to be sorted
+);
+/**
+ * @brief Sort values[1..n] of an array by increasing value with corresponding
+ * indices
+ */
+void maxheapsort(
+    double* heap_v,    //!< Values to be sorted
+    HighsInt* heap_i,  //!< Indices corresponding to (sorted) values
+    HighsInt n         //!< Number of values to be sorted
+);
+/**
+ * @brief Build a value heap for sorting values[1..n] of an array by increasing
+ * value
+ */
+void buildMaxheap(HighsInt* heap_v,  //!< HighsInt values to be sorted
+                  HighsInt n         //!< Number of values to be sorted
+);
+/**
+ * @brief Build a value-index heap for sorting values[1..n] of an array by
+ * increasing value
+ */
+void buildMaxheap(
+    HighsInt* heap_v,  //!< Values to be sorted
+    HighsInt* heap_i,  //!< Indices corresponding to (sorted) values
+    HighsInt n         //!< Number of values to be sorted
+);
+/**
+ * @brief Build a value-index heap for sorting values[1..n] of an array by
+ * increasing value
+ */
+void buildMaxheap(
+    double* heap_v,    //!< Values to be sorted
+    HighsInt* heap_i,  //!< Indices corresponding to (sorted) values
+    HighsInt n         //!< Number of values to be sorted
+);
+/**
+ * @brief Sort by increasing value a heap built with buildMaxheap
+ */
+void maxHeapsort(HighsInt* heap_v,  //!< HighsInt values to be sorted
+                 HighsInt n         //!< Number of values to be sorted
+);
+/**
+ * @brief Sort by increasing value a heap built with buildMaxheap
+ */
+void maxHeapsort(
+    HighsInt* heap_v,  //!< Values to be sorted
+    HighsInt* heap_i,  //!< Indices corresponding to (sorted) values
+    HighsInt n         //!< Number of values to be sorted
+);
+/**
+ * @brief Sort by increasing value a heap built with buildMaxheap
+ */
+void maxHeapsort(
+    double* heap_v,    //!< Values to be sorted
+    HighsInt* heap_i,  //!< Indices corresponding to (sorted) values
+    HighsInt n         //!< Number of values to be sorted
+);
+/**
+ * @brief Heapify function for sorting by increasing value
+ */
+void maxHeapify(HighsInt* heap_v, HighsInt i, HighsInt n);
+
+/**
+ * @brief Heapify function for sorting by increasing value
+ */
+void maxHeapify(HighsInt* heap_v, HighsInt* heap_i, HighsInt i, HighsInt n);
+
+/**%
+ * @brief Heapify function for sorting by increasing value
+ */
+void maxHeapify(double* heap_v, HighsInt* heap_i, HighsInt i, HighsInt n);
+
+/**
+ * @brief Check that a set of integers is in increasing order and in bounds
+ */
+bool increasingSetOk(const vector<HighsInt>& set,
+                     const HighsInt set_entry_lower,
+                     const HighsInt set_entry_upper, bool strict);
+
+/**
+ * @brief Check that a set of doubles is in increasing order and in bounds
+ */
+bool increasingSetOk(const vector<double>& set, const double set_entry_lower,
+                     const double set_entry_upper, bool strict);
+
+void sortSetData(const HighsInt num_entries, vector<HighsInt>& set,
+                 const double* data0, const double* data1, const double* data2,
+                 double* sorted_data0, double* sorted_data1,
+                 double* sorted_data2);
+
+void sortSetData(const HighsInt num_entries, vector<HighsInt>& set,
+                 const HighsVarType* data0, HighsVarType* sorted_data0);
+
+#endif /* UTIL_HIGHSSORT_H_ */

data/ext/lpsolver-highs/build/include/highs/util/HighsSparseMatrix.h

@@ -0,0 +1,151 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/**@file util/HighsSparseMatrix.h
+ * @brief
+ */
+#ifndef LP_DATA_HIGHS_SPARSE_MATRIX_H_
+#define LP_DATA_HIGHS_SPARSE_MATRIX_H_
+
+#include <vector>
+
+#include "lp_data/HConst.h"
+#include "lp_data/HStruct.h"  //For  HighsScale
+#include "lp_data/HighsStatus.h"
+#include "simplex/SimplexStruct.h"  //For SimplexScale until scaling is HighsScale
+#include "util/HVector.h"
+#include "util/HVectorBase.h"
+#include "util/HighsSparseVectorSum.h"
+#include "util/HighsUtils.h"
+
+const double kHyperPriceDensity = 0.1;
+const HighsInt kDebugReportOff = -2;
+const HighsInt kDebugReportAll = -1;
+
+class HighsSparseMatrix {
+ public:
+  HighsSparseMatrix() { clear(); }
+  MatrixFormat format_;
+  HighsInt num_col_;
+  HighsInt num_row_;
+  std::vector<HighsInt> start_;
+  std::vector<HighsInt> p_end_;
+  std::vector<HighsInt> index_;
+  std::vector<double> value_;
+
+  bool operator==(const HighsSparseMatrix& matrix) const;
+  bool equivalent(const HighsSparseMatrix& matrix) const;
+  void clear();
+  void exactResize();
+  bool formatOk() const { return (this->isColwise() || this->isRowwise()); };
+  bool isRowwise() const;
+  bool isColwise() const;
+  HighsInt numNz() const;
+  void range(double& min_value, double& max_value) const;
+  void setFormat(const MatrixFormat desired_format);
+  void ensureColwise();
+  void ensureRowwise();
+
+  void addVec(const HighsInt num_nz, const HighsInt* index, const double* value,
+              const double multiple = 1);
+  void addCols(const HighsSparseMatrix new_cols,
+               const int8_t* in_partition = NULL);
+  void addRows(const HighsSparseMatrix new_rows,
+               const int8_t* in_partition = NULL);
+  void getRow(const HighsInt iRow, HighsInt& num_nz, HighsInt* index,
+              double* value) const;
+  void getCol(const HighsInt iCol, HighsInt& num_nz, HighsInt* index,
+              double* value) const;
+  void deleteCols(const HighsIndexCollection& index_collection);
+  void deleteRows(const HighsIndexCollection& index_collection);
+  HighsStatus assessDimensions(const HighsLogOptions& log_options,
+                               const std::string matrix_name);
+  HighsStatus assessStart(const HighsLogOptions& log_options);
+  HighsStatus assessIndexBounds(const HighsLogOptions& log_options);
+
+  HighsStatus assess(const HighsLogOptions& log_options,
+                     const std::string matrix_name,
+                     const double small_matrix_value,
+                     const double large_matrix_value);
+  void assessSmallValues(const HighsLogOptions& log_options,
+                         const double small_matrix_value);
+  bool hasLargeValue(const double large_matrix_value);
+  void considerColScaling(const HighsInt max_scale_factor_exponent,
+                          double* col_scale);
+  void considerRowScaling(const HighsInt max_scale_factor_exponent,
+                          double* row_scale);
+  void scaleCol(const HighsInt col, const double colScale);
+  void scaleRow(const HighsInt row, const double rowScale);
+  void applyScale(const HighsScale& scale);
+  void applyRowScale(const HighsScale& scale);
+  void applyColScale(const HighsScale& scale);
+  void unapplyScale(const HighsScale& scale);
+  void createSlice(const HighsSparseMatrix& matrix, const HighsInt from_col,
+                   const HighsInt to_col);
+  void createColwise(const HighsSparseMatrix& matrix);
+  void createRowwise(const HighsSparseMatrix& matrix);
+  void alphaProductPlusY(const double alpha, const std::vector<double>& x,
+                         std::vector<double>& y,
+                         const bool transpose = false) const;
+  void product(vector<double>& result, const vector<double>& x) const;
+  void productTranspose(vector<double>& result, const vector<double>& x) const;
+  void productQuad(vector<double>& result, const vector<double>& x,
+                   const HighsInt debug_report = kDebugReportOff) const;
+  void productTransposeQuad(
+      vector<double>& result_value, const vector<double>& x,
+      const HighsInt debug_report = kDebugReportOff) const;
+  void productTransposeQuad(
+      vector<double>& result_value, vector<HighsInt>& result_index,
+      const HVector& x, const HighsInt debug_report = kDebugReportOff) const;
+  // Methods for PRICE, including the creation and updating of the
+  // partitioned row-wise matrix
+  void createRowwisePartitioned(const HighsSparseMatrix& matrix,
+                                const int8_t* in_partition = NULL);
+  bool debugPartitionOk(const int8_t* in_partition) const;
+  void priceByColumn(const bool quad_precision, HVector& result,
+                     const HVector& column,
+                     const HighsInt debug_report = kDebugReportOff) const;
+  void priceByRow(const bool quad_precision, HVector& result,
+                  const HVector& column,
+                  const HighsInt debug_report = kDebugReportOff) const;
+  void priceByRowWithSwitch(
+      const bool quad_precision, HVector& result, const HVector& column,
+      const double expected_density, const HighsInt from_index,
+      const double switch_density,
+      const HighsInt debug_report = kDebugReportOff) const;
+  void update(const HighsInt var_in, const HighsInt var_out,
+              const HighsSparseMatrix& matrix);
+  double computeDot(const HVector& column, const HighsInt use_col) const {
+    return computeDot(column.array, use_col);
+  }
+
+  double computeDot(const std::vector<double>& array,
+                    const HighsInt use_col) const;
+  void collectAj(HVector& column, const HighsInt use_col,
+                 const double multiplier) const;
+
+ private:
+  void priceByRowDenseResult(
+      std::vector<double>& result, const HVector& column,
+      const HighsInt from_index,
+      const HighsInt debug_report = kDebugReportOff) const;
+  void priceByRowDenseResult(
+      std::vector<HighsCDouble>& result, const HVector& column,
+      const HighsInt from_index,
+      const HighsInt debug_report = kDebugReportOff) const;
+  void debugReportRowPrice(const HighsInt iRow, const double multiplier,
+                           const HighsInt to_iEl,
+                           const vector<double>& result) const;
+  void debugReportRowPrice(const HighsInt iRow, const double multiplier,
+                           const HighsInt to_iEl,
+                           const vector<HighsCDouble>& result) const;
+  void debugReportRowPrice(const HighsInt iRow, const double multiplier,
+                           const HighsInt to_iEl,
+                           HighsSparseVectorSum& sum) const;
+};
+
+#endif

data/ext/lpsolver-highs/build/include/highs/util/HighsSparseVectorSum.h

@@ -0,0 +1,95 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+#ifndef HIGHS_SPARSE_VECTOR_SUM_H_
+#define HIGHS_SPARSE_VECTOR_SUM_H_
+
+#include <algorithm>
+#include <cassert>
+#include <limits>
+#include <vector>
+
+#include "util/HighsCDouble.h"
+#include "util/HighsInt.h"
+
+class HighsSparseVectorSum {
+ public:
+  std::vector<HighsCDouble> values;
+  std::vector<HighsInt> nonzeroinds;
+  HighsSparseVectorSum() = default;
+
+  HighsSparseVectorSum(HighsInt dimension) { setDimension(dimension); }
+
+  void setDimension(HighsInt dimension) {
+    values.resize(dimension);
+    nonzeroinds.reserve(dimension);
+  }
+
+  void add(HighsInt index, double value) {
+    assert(index >= 0 && index < (HighsInt)values.size());
+    if (values[index] != 0.0) {
+      values[index] += value;
+    } else {
+      values[index] = value;
+      nonzeroinds.push_back(index);
+    }
+
+    if (values[index] == 0.0)
+      values[index] = (std::numeric_limits<double>::min)();
+  }
+
+  void add(HighsInt index, HighsCDouble value) {
+    if (values[index] != 0.0) {
+      values[index] += value;
+    } else {
+      values[index] = value;
+      nonzeroinds.push_back(index);
+    }
+
+    if (values[index] == 0.0)
+      values[index] = (std::numeric_limits<double>::min)();
+  }
+
+  const std::vector<HighsInt>& getNonzeros() const { return nonzeroinds; }
+
+  double getValue(HighsInt index) const { return double(values[index]); }
+
+  void clear() {
+    if (10 * nonzeroinds.size() < 3 * values.size())
+      for (HighsInt i : nonzeroinds) values[i] = 0.0;
+    else
+      values.assign(values.size(), false);
+
+    nonzeroinds.clear();
+  }
+
+  template <typename Pred>
+  HighsInt partition(Pred&& pred) {
+    return std::partition(nonzeroinds.begin(), nonzeroinds.end(), pred) -
+           nonzeroinds.begin();
+  }
+
+  template <typename IsZero>
+  void cleanup(IsZero&& isZero) {
+    HighsInt numNz = static_cast<HighsInt>(nonzeroinds.size());
+
+    for (HighsInt i = numNz - 1; i >= 0; --i) {
+      HighsInt pos = nonzeroinds[i];
+      double val = double(values[pos]);
+
+      if (isZero(pos, val)) {
+        values[pos] = 0.0;
+        --numNz;
+        std::swap(nonzeroinds[numNz], nonzeroinds[i]);
+      }
+    }
+
+    nonzeroinds.resize(numNz);
+  }
+};
+
+#endif

data/ext/lpsolver-highs/build/include/highs/util/HighsSplay.h

@@ -0,0 +1,135 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+#ifndef HIGHS_SPLAY_H_
+#define HIGHS_SPLAY_H_
+
+#include <cassert>
+
+#include "util/HighsInt.h"
+
+/// top down splay operation to maintain a binary search tree. The search tree
+/// is assumed to be stored in an array/vector and therefore uses integers
+/// instead of pointers to link nodes. The splay operation on a given key will
+/// return the new root node index. The new root node will be the node with the
+/// given key, if it exists in the tree, and otherwise it is the node traversed
+/// last in a binary tree search for the key.
+///
+/// The GetLeft/GetRight lambdas receive an index of a node and must
+/// return references to an integer holding the left and the right child node
+/// indices. The GetKey lambda must return a type that is comparable
+/// to KeyT.
+template <typename KeyT, typename GetLeft, typename GetRight, typename GetKey>
+HighsInt highs_splay(const KeyT& key, HighsInt root, GetLeft&& get_left,
+                     GetRight&& get_right, GetKey&& get_key) {
+  if (root == -1) return -1;
+
+  HighsInt Nleft = -1;
+  HighsInt Nright = -1;
+  HighsInt* lright = &Nright;
+  HighsInt* rleft = &Nleft;
+
+  while (true) {
+    if (key < get_key(root)) {
+      HighsInt left = get_left(root);
+      if (left == -1) break;
+      if (key < get_key(left)) {
+        HighsInt y = left;
+        get_left(root) = get_right(y);
+        get_right(y) = root;
+        root = y;
+        if (get_left(root) == -1) break;
+      }
+
+      *rleft = root;
+      rleft = &get_left(root);
+      root = get_left(root);
+    } else if (key > get_key(root)) {
+      HighsInt right = get_right(root);
+      if (right == -1) break;
+      if (key > get_key(right)) {
+        HighsInt y = right;
+        get_right(root) = get_left(y);
+        get_left(y) = root;
+        root = y;
+        if (get_right(root) == -1) break;
+      }
+
+      *lright = root;
+      lright = &get_right(root);
+      root = get_right(root);
+    } else
+      break;
+  }
+
+  *lright = get_left(root);
+  *rleft = get_right(root);
+  get_left(root) = Nright;
+  get_right(root) = Nleft;
+
+  return root;
+}
+
+/// links a new node into the binary tree rooted at the given reference to the
+/// root node. Lambdas must behave as described in highs_splay above.
+/// Equal keys are put to the right subtree.
+template <typename GetLeft, typename GetRight, typename GetKey>
+void highs_splay_link(HighsInt linknode, HighsInt& root, GetLeft&& get_left,
+                      GetRight&& get_right, GetKey&& get_key) {
+  if (root == -1) {
+    get_left(linknode) = -1;
+    get_right(linknode) = -1;
+    root = linknode;
+    return;
+  }
+
+  root = highs_splay(get_key(linknode), root, get_left, get_right, get_key);
+
+  if (get_key(linknode) < get_key(root)) {
+    get_left(linknode) = get_left(root);
+    get_right(linknode) = root;
+    get_left(root) = -1;
+  } else {
+    assert(get_key(linknode) > get_key(root));
+    get_right(linknode) = get_right(root);
+    get_left(linknode) = root;
+    get_right(root) = -1;
+  }
+
+  root = linknode;
+}
+
+/// unlinks a new node into the binary tree rooted at the given reference to the
+/// root node. Lambdas must behave as described in highs_splay above.
+template <typename GetLeft, typename GetRight, typename GetKey>
+void highs_splay_unlink(HighsInt unlinknode, HighsInt& root, GetLeft&& get_left,
+                        GetRight&& get_right, GetKey&& get_key) {
+  assert(root != -1);
+  root = highs_splay(get_key(unlinknode), root, get_left, get_right, get_key);
+  assert(get_key(root) == get_key(unlinknode));
+
+  // in case keys can be equal it might happen that we did not splay the correct
+  // node to the top since equal keys are put to the right subtree, we recurse
+  // into that part of the tree
+  if (root != unlinknode) {
+    highs_splay_unlink(unlinknode, get_right(root), get_left, get_right,
+                       get_key);
+    return;
+  }
+
+  assert(root == unlinknode);
+
+  if (get_left(unlinknode) == -1) {
+    root = get_right(unlinknode);
+  } else {
+    root = highs_splay(get_key(unlinknode), get_left(unlinknode), get_left,
+                       get_right, get_key);
+    get_right(root) = get_right(unlinknode);
+  }
+}
+
+#endif