lpsolver 0.1.0 → 0.2.1

data/ext/lpsolver-highs/highs/mip/HighsNodeQueue.h

@@ -0,0 +1,312 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#ifndef HIGHS_NODE_QUEUE_H_
+#define HIGHS_NODE_QUEUE_H_
+
+#include <cassert>
+#include <cstddef>
+#include <functional>
+#include <memory>
+#include <queue>
+#include <set>
+#include <vector>
+
+#include "lp_data/HConst.h"
+#include "mip/HighsDomainChange.h"
+#include "util/HighsCDouble.h"
+#include "util/HighsRbTree.h"
+
+class HighsDomain;
+class HighsLpRelaxation;
+
+class HighsNodeQueue {
+ public:
+  template <int S>
+  struct ChunkWithSize {
+    ChunkWithSize* next;
+    typename std::aligned_storage<S, alignof(std::max_align_t)>::type storage;
+  };
+
+  using Chunk =
+      ChunkWithSize<4096 - offsetof(ChunkWithSize<sizeof(void*)>, storage)>;
+
+  struct AllocatorState {
+    void* freeListHead = nullptr;
+    char* currChunkStart = nullptr;
+    char* currChunkEnd = nullptr;
+    Chunk* chunkListHead = nullptr;
+
+    AllocatorState() = default;
+    AllocatorState(const AllocatorState&) = delete;
+    AllocatorState(AllocatorState&& other)
+        : freeListHead(other.freeListHead),
+          currChunkStart(other.currChunkStart),
+          currChunkEnd(other.currChunkEnd),
+          chunkListHead(other.chunkListHead) {
+      other.chunkListHead = nullptr;
+    }
+
+    AllocatorState& operator=(const AllocatorState&) = delete;
+
+    AllocatorState& operator=(AllocatorState&& other) {
+      freeListHead = other.freeListHead;
+      currChunkStart = other.currChunkStart;
+      currChunkEnd = other.currChunkEnd;
+      chunkListHead = other.chunkListHead;
+
+      other.chunkListHead = nullptr;
+      return *this;
+    }
+
+    ~AllocatorState() {
+      while (chunkListHead) {
+        Chunk* delChunk = chunkListHead;
+        chunkListHead = delChunk->next;
+        delete delChunk;
+      }
+    }
+  };
+
+  template <typename T>
+  class NodesetAllocator {
+    union FreelistNode {
+      FreelistNode* next;
+      typename std::aligned_storage<sizeof(T), alignof(T)>::type storage;
+    };
+
+   public:
+    AllocatorState* state;
+    using value_type = T;
+    using size_type = std::size_t;
+    using propagate_on_container_move_assignment = std::true_type;
+
+    NodesetAllocator(AllocatorState* state) : state(state) {}
+    NodesetAllocator(const NodesetAllocator& other) noexcept = default;
+    template <typename U>
+    NodesetAllocator(const NodesetAllocator<U>& other) noexcept
+        : state(other.state) {}
+    NodesetAllocator(NodesetAllocator&& other) noexcept = default;
+    NodesetAllocator& operator=(const NodesetAllocator&) noexcept = default;
+    NodesetAllocator& operator=(NodesetAllocator&& other) noexcept = default;
+    ~NodesetAllocator() noexcept = default;
+
+    T* allocate(size_type n) {
+      if (n == 1) {
+        T* ptr = reinterpret_cast<T*>(state->freeListHead);
+        if (ptr) {
+          state->freeListHead =
+              reinterpret_cast<FreelistNode*>(state->freeListHead)->next;
+        } else {
+          ptr = reinterpret_cast<T*>(state->currChunkStart);
+          if (!ptr || state->currChunkStart + sizeof(FreelistNode) >
+                          state->currChunkEnd) {
+            auto newChunk = new Chunk;
+            newChunk->next = state->chunkListHead;
+            state->chunkListHead = newChunk;
+            state->currChunkStart = reinterpret_cast<char*>(&newChunk->storage);
+            state->currChunkEnd =
+                state->currChunkStart + sizeof(newChunk->storage);
+            ptr = reinterpret_cast<T*>(state->currChunkStart);
+            state->currChunkStart += sizeof(FreelistNode);
+          } else {
+            state->currChunkStart += sizeof(FreelistNode);
+          }
+        }
+        return ptr;
+      }
+
+      return static_cast<T*>(::operator new(n * sizeof(T)));
+    }
+
+    void deallocate(T* ptr, size_type n) noexcept {
+      if (n == 1) {
+        FreelistNode* node = reinterpret_cast<FreelistNode*>(ptr);
+        node->next = reinterpret_cast<FreelistNode*>(state->freeListHead);
+        state->freeListHead = node;
+      } else {
+        ::operator delete(ptr);
+      }
+    }
+  };
+
+  using NodeSet = std::set<std::pair<double, int64_t>,
+                           std::less<std::pair<double, int64_t>>,
+                           NodesetAllocator<std::pair<double, int64_t>>>;
+
+  struct OpenNode {
+    std::vector<HighsDomainChange> domchgstack;
+    std::vector<HighsInt> branchings;
+    std::vector<NodeSet::iterator> domchglinks;
+    double lower_bound;
+    double estimate;
+    HighsInt depth;
+    highs::RbTreeLinks<int64_t> lowerLinks;
+    highs::RbTreeLinks<int64_t> hybridEstimLinks;
+
+    OpenNode()
+        : domchgstack(),
+          branchings(),
+          domchglinks(),
+          lower_bound(-kHighsInf),
+          estimate(-kHighsInf),
+          depth(0),
+          lowerLinks(),
+          hybridEstimLinks() {}
+
+    OpenNode(std::vector<HighsDomainChange>&& domchgstack,
+             std::vector<HighsInt>&& branchings, double lower_bound,
+             double estimate, HighsInt depth)
+        : domchgstack(domchgstack),
+          branchings(branchings),
+          lower_bound(lower_bound),
+          estimate(estimate),
+          depth(depth),
+          lowerLinks(),
+          hybridEstimLinks() {}
+
+    OpenNode& operator=(OpenNode&& other) = default;
+    OpenNode(OpenNode&&) = default;
+
+    OpenNode& operator=(const OpenNode& other) = delete;
+    OpenNode(const OpenNode&) = delete;
+  };
+
+  void checkGlobalBounds(HighsInt col, double lb, double ub, double feastol,
+                         HighsCDouble& treeweight);
+
+ private:
+  class NodeLowerRbTree;
+  class NodeHybridEstimRbTree;
+  class SuboptimalNodeRbTree;
+
+  std::unique_ptr<AllocatorState> allocatorState;
+  std::vector<OpenNode> nodes;
+  std::priority_queue<int64_t, std::vector<int64_t>, std::greater<int64_t>>
+      freeslots;
+
+  struct GlobalOperatorDelete {
+    template <typename T>
+    void operator()(T* x) const {
+      ::operator delete(x);
+    }
+  };
+  using NodeSetArray = std::unique_ptr<NodeSet, GlobalOperatorDelete>;
+  NodeSetArray colLowerNodesPtr;
+  NodeSetArray colUpperNodesPtr;
+  int64_t lowerRoot = -1;
+  int64_t lowerMin = -1;
+  int64_t hybridEstimRoot = -1;
+  int64_t hybridEstimMin = -1;
+  int64_t suboptimalRoot = -1;
+  int64_t suboptimalMin = -1;
+  int64_t numSuboptimal = 0;
+  double optimality_limit = kHighsInf;
+  HighsInt numCol = 0;
+
+  void link_estim(int64_t node);
+
+  void unlink_estim(int64_t node);
+
+  void link_lower(int64_t node);
+
+  void unlink_lower(int64_t node);
+
+  void link_suboptimal(int64_t node);
+
+  void unlink_suboptimal(int64_t node);
+
+  void link_domchgs(int64_t node);
+
+  void unlink_domchgs(int64_t node);
+
+  double link(int64_t node);
+
+  void unlink(int64_t node);
+
+ public:
+  void setOptimalityLimit(double optimality_limit) {
+    this->optimality_limit = optimality_limit;
+  }
+
+  double performBounding(double upper_limit);
+
+  void setNumCol(HighsInt numcol);
+
+  double emplaceNode(std::vector<HighsDomainChange>&& domchgs,
+                     std::vector<HighsInt>&& branchings, double lower_bound,
+                     double estimate, HighsInt depth);
+
+  OpenNode&& popBestNode();
+
+  OpenNode&& popBestBoundNode();
+
+  int64_t numNodesUp(HighsInt col) const {
+    return colLowerNodesPtr.get()[col].size();
+  }
+
+  int64_t numNodesDown(HighsInt col) const {
+    return colUpperNodesPtr.get()[col].size();
+  }
+
+  int64_t numNodesUp(HighsInt col, double val) const {
+    assert(numCol > col);
+    auto colLowerNodes = colLowerNodesPtr.get();
+    auto it = colLowerNodes[col].upper_bound(std::make_pair(val, kHighsIInf));
+    if (it == colLowerNodes[col].begin()) return colLowerNodes[col].size();
+    return std::distance(it, colLowerNodes[col].end());
+  }
+
+  int64_t numNodesDown(HighsInt col, double val) const {
+    assert(numCol > col);
+    auto colUpperNodes = colUpperNodesPtr.get();
+    auto it = colUpperNodes[col].lower_bound(std::make_pair(val, -1));
+    if (it == colUpperNodes[col].end()) return colUpperNodes[col].size();
+    return std::distance(colUpperNodes[col].begin(), it);
+  }
+
+  const NodeSet& getUpNodes(HighsInt col) const {
+    return colLowerNodesPtr.get()[col];
+  }
+
+  const NodeSet& getDownNodes(HighsInt col) const {
+    return colUpperNodesPtr.get()[col];
+  }
+
+  double pruneInfeasibleNodes(HighsDomain& globaldomain, double feastol);
+
+  double pruneNode(int64_t nodeId);
+
+  double getBestLowerBound() const;
+
+  HighsInt getBestBoundDomchgStackSize() const;
+
+  void clear();
+
+  int64_t numNodes() const { return nodes.size() - freeslots.size(); }
+
+  int64_t numActiveNodes() const {
+    return nodes.size() - freeslots.size() - numSuboptimal;
+  }
+
+  bool empty() const { return numActiveNodes() == 0; }
+};
+
+template <typename T, typename U>
+bool operator==(const HighsNodeQueue::NodesetAllocator<T>&,
+                const HighsNodeQueue::NodesetAllocator<U>&) {
+  return true;
+}
+
+template <typename T, typename U>
+bool operator!=(const HighsNodeQueue::NodesetAllocator<T>&,
+                const HighsNodeQueue::NodesetAllocator<U>&) {
+  return false;
+}
+
+#endif

data/ext/lpsolver-highs/highs/mip/HighsObjectiveFunction.cpp

@@ -0,0 +1,124 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include "mip/HighsObjectiveFunction.h"
+
+#include <numeric>
+
+#include "../extern/pdqsort/pdqsort.h"
+#include "lp_data/HighsLp.h"
+#include "mip/HighsCliqueTable.h"
+#include "mip/HighsDomain.h"
+#include "mip/HighsMipSolverData.h"
+#include "util/HighsIntegers.h"
+
+HighsObjectiveFunction::HighsObjectiveFunction(const HighsMipSolver& mipsolver)
+    : model(mipsolver.model_) {
+  objectiveNonzeros.reserve(model->num_col_);
+
+  for (HighsInt i = 0; i < model->num_col_; ++i) {
+    if (model->col_cost_[i] != 0.0) {
+      objectiveNonzeros.push_back(i);
+    }
+  }
+
+  colToPartition.resize(model->num_col_, -1);
+  cliquePartitionStart.resize(1);
+
+  if (objectiveNonzeros.empty()) {
+    numBinary = 0;
+    numIntegral = 0;
+    objIntScale = 1.0;
+    return;
+  }
+
+  numIntegral = std::partition(
+                    objectiveNonzeros.begin(), objectiveNonzeros.end(),
+                    [&](HighsInt i) { return !mipsolver.isColContinuous(i); }) -
+                objectiveNonzeros.begin();
+
+  if (numIntegral == 0)
+    numBinary = 0;
+  else
+    numBinary =
+        std::partition(objectiveNonzeros.begin(),
+                       objectiveNonzeros.begin() + numIntegral,
+                       [&](HighsInt i) {
+                         return mipsolver.model_->col_lower_[i] == 0.0 &&
+                                mipsolver.model_->col_upper_[i] == 1.0;
+                       }) -
+        objectiveNonzeros.begin();
+
+  objectiveVals.reserve(objectiveNonzeros.size());
+  for (HighsInt i : objectiveNonzeros)
+    objectiveVals.push_back(model->col_cost_[i]);
+
+  objIntScale = 0.0;
+}
+
+void HighsObjectiveFunction::setupCliquePartition(
+    const HighsDomain& globaldom, HighsCliqueTable& cliqueTable) {
+  // skip if not more than 1 binary column is present
+  if (numBinary <= 1) return;
+
+  std::vector<HighsCliqueTable::CliqueVar> clqvars;
+
+  auto binaryEnd = objectiveNonzeros.begin() + numBinary;
+
+  for (auto it = objectiveNonzeros.begin(); it != binaryEnd; ++it) {
+    HighsInt col = *it;
+    clqvars.emplace_back(col, model->col_cost_[col] < 0.0);
+  }
+
+  cliqueTable.cliquePartition(model->col_cost_, clqvars, cliquePartitionStart);
+  HighsInt numPartitions = cliquePartitionStart.size() - 1;
+  if (numPartitions == numBinary)
+    cliquePartitionStart.resize(1);
+  else {
+    HighsInt p = 0;
+    HighsInt k = 0;
+
+    for (HighsInt i = 0; i < numPartitions; ++i) {
+      if (cliquePartitionStart[i + 1] - cliquePartitionStart[i] == 1) continue;
+
+      cliquePartitionStart[p] = k;
+
+      for (HighsInt j = cliquePartitionStart[i];
+           j < cliquePartitionStart[i + 1]; ++j) {
+        colToPartition[clqvars[j].col] = k++;
+      }
+
+      ++p;
+    }
+
+    cliquePartitionStart[p] = k;
+    cliquePartitionStart.resize(p + 1);
+
+    pdqsort(objectiveNonzeros.begin(), objectiveNonzeros.begin() + numBinary,
+            [&](HighsInt i, HighsInt j) {
+              return std::make_pair((HighsUInt)colToPartition[i],
+                                    HighsHashHelpers::hash(i)) <
+                     std::make_pair((HighsUInt)colToPartition[j],
+                                    HighsHashHelpers::hash(j));
+            });
+
+    for (HighsInt i = 0; i < numBinary; ++i)
+      objectiveVals[i] = model->col_cost_[objectiveNonzeros[i]];
+  }
+}
+
+void HighsObjectiveFunction::checkIntegrality(double epsilon) {
+  if (numIntegral == (HighsInt)objectiveNonzeros.size()) {
+    if (numIntegral) {
+      objIntScale =
+          HighsIntegers::integralScale(objectiveVals, epsilon, epsilon);
+      if (objIntScale * kHighsTiny > epsilon) objIntScale = 0.0;
+    } else
+      objIntScale = 1.0;
+  }
+}

data/ext/lpsolver-highs/highs/mip/HighsObjectiveFunction.h

@@ -0,0 +1,71 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+#ifndef HIGHS_OBJECTIVE_FUNCTION_H_
+#define HIGHS_OBJECTIVE_FUNCTION_H_
+
+#include <algorithm>
+#include <cassert>
+#include <vector>
+
+#include "util/HighsInt.h"
+
+class HighsCliqueTable;
+class HighsDomain;
+class HighsLp;
+class HighsMipSolver;
+
+class HighsObjectiveFunction {
+  const HighsLp* model;
+  double objIntScale;
+  HighsInt numIntegral;
+  HighsInt numBinary;
+  std::vector<HighsInt> objectiveNonzeros;
+  std::vector<double> objectiveVals;
+  std::vector<HighsInt> cliquePartitionStart;
+  std::vector<HighsInt> colToPartition;
+
+ public:
+  HighsObjectiveFunction(const HighsMipSolver& mipsolver);
+
+  void setupCliquePartition(const HighsDomain& globaldom,
+                            HighsCliqueTable& cliqueTable);
+
+  void checkIntegrality(double epsilon);
+
+  /// returns the vector of column indices with nonzero objective value
+  /// They will be ordered so that binary columns come first
+  const std::vector<HighsInt>& getObjectiveNonzeros() const {
+    return objectiveNonzeros;
+  }
+
+  const std::vector<double>& getObjectiveValuesPacked() const {
+    return objectiveVals;
+  }
+
+  HighsInt getNumBinariesInObjective() const { return numBinary; }
+
+  const std::vector<HighsInt>& getCliquePartitionStarts() const {
+    return cliquePartitionStart;
+  }
+
+  HighsInt getNumCliquePartitions() const {
+    return cliquePartitionStart.size() - 1;
+  }
+
+  HighsInt getColCliquePartition(HighsInt col) const {
+    return colToPartition[col];
+  }
+
+  double integralScale() const { return objIntScale; }
+
+  bool isIntegral() const { return objIntScale != 0.0; }
+
+  bool isZero() const { return objectiveNonzeros.empty(); }
+};
+
+#endif