lpsolver 0.1.0 → 0.2.0

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

@@ -0,0 +1,241 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+#ifndef HIGHS_SEARCH_H_
+#define HIGHS_SEARCH_H_
+
+#include <cstdint>
+#include <queue>
+#include <vector>
+
+#include "mip/HighsConflictPool.h"
+#include "mip/HighsDomain.h"
+#include "mip/HighsLpRelaxation.h"
+#include "mip/HighsMipSolver.h"
+#include "mip/HighsNodeQueue.h"
+#include "mip/HighsPseudocost.h"
+#include "mip/HighsSeparation.h"
+#include "presolve/HighsSymmetry.h"
+#include "util/HighsHash.h"
+
+class HighsMipSolver;
+class HighsImplications;
+class HighsCliqueTable;
+
+class HighsSearch {
+  HighsMipSolver& mipsolver;
+  HighsLpRelaxation* lp;
+  HighsDomain localdom;
+  HighsPseudocost& pseudocost;
+  HighsRandom random;
+  int64_t nnodes;
+  int64_t lpiterations;
+  int64_t heurlpiterations;
+  int64_t sblpiterations;
+  double upper_limit;
+  HighsCDouble treeweight;
+  std::vector<HighsInt> inds;
+  std::vector<double> vals;
+  HighsInt depthoffset;
+  bool inbranching;
+  bool inheuristic;
+  bool countTreeWeight;
+
+ public:
+  enum class ChildSelectionRule {
+    kUp,
+    kDown,
+    kRootSol,
+    kObj,
+    kRandom,
+    kBestCost,
+    kWorstCost,
+    kDisjunction,
+    kHybridInferenceCost,
+  };
+
+  enum class NodeResult {
+    kBoundExceeding,
+    kDomainInfeasible,
+    kLpInfeasible,
+    kBranched,
+    kSubOptimal,
+    kOpen,
+  };
+
+ private:
+  ChildSelectionRule childselrule;
+
+  struct NodeData {
+    double lower_bound;
+    double estimate;
+    double branching_point;
+    // we store the lp objective separately to the lower bound since the lower
+    // bound could be above the LP objective when cuts age out or below when the
+    // LP is unscaled dual infeasible and it is not set. We still want to use
+    // the objective for pseudocost updates and tiebreaking of best bound node
+    // selection
+    double lp_objective;
+    double other_child_lb;
+    std::shared_ptr<const HighsBasis> nodeBasis;
+    std::shared_ptr<const StabilizerOrbits> stabilizerOrbits;
+    HighsDomainChange branchingdecision;
+    HighsInt domgchgStackPos;
+    uint8_t skipDepthCount;
+    uint8_t opensubtrees;
+
+    NodeData(double parentlb = -kHighsInf, double parentestimate = -kHighsInf,
+             std::shared_ptr<const HighsBasis> parentBasis = nullptr,
+             std::shared_ptr<const StabilizerOrbits> stabilizerOrbits = nullptr)
+        : lower_bound(parentlb),
+          estimate(parentestimate),
+          branching_point(0.0),
+          lp_objective(-kHighsInf),
+          other_child_lb(parentlb),
+          nodeBasis(std::move(parentBasis)),
+          stabilizerOrbits(std::move(stabilizerOrbits)),
+          branchingdecision{0.0, -1, HighsBoundType::kLower},
+          domgchgStackPos(-1),
+          skipDepthCount(0),
+          opensubtrees(2) {}
+  };
+
+  enum ReliableFlags {
+    kUpReliable = 1,
+    kDownReliable = 2,
+    kReliable = kDownReliable | kUpReliable,
+  };
+
+  std::vector<double> subrootsol;
+  std::vector<NodeData> nodestack;
+  HighsHashTable<HighsInt, int> reliableatnode;
+
+  int branchingVarReliableAtNodeFlags(HighsInt col) const {
+    auto it = reliableatnode.find(col);
+    if (it == nullptr) return 0;
+    return *it;
+  }
+
+  bool branchingVarReliableAtNode(HighsInt col) const {
+    auto it = reliableatnode.find(col);
+    if (it == nullptr || *it != kReliable) return false;
+
+    return true;
+  }
+
+  void markBranchingVarUpReliableAtNode(HighsInt col) {
+    reliableatnode[col] |= kUpReliable;
+  }
+
+  void markBranchingVarDownReliableAtNode(HighsInt col) {
+    reliableatnode[col] |= kDownReliable;
+  }
+
+  bool orbitsValidInChildNode(const HighsDomainChange& branchChg) const;
+
+ public:
+  HighsSearch(HighsMipSolver& mipsolver, HighsPseudocost& pseudocost);
+
+  void setRINSNeighbourhood(const std::vector<double>& basesol,
+                            const std::vector<double>& relaxsol);
+
+  void setRENSNeighbourhood(const std::vector<double>& lpsol);
+
+  double getCutoffBound() const;
+
+  void setLpRelaxation(HighsLpRelaxation* lp) { this->lp = lp; }
+
+  double checkSol(const std::vector<double>& sol, bool& integerfeasible) const;
+
+  void createNewNode();
+
+  void cutoffNode();
+
+  void branchDownwards(HighsInt col, double newub, double branchpoint);
+
+  void branchUpwards(HighsInt col, double newlb, double branchpoint);
+
+  void setMinReliable(HighsInt minreliable);
+
+  void setHeuristic(bool inheuristic) {
+    this->inheuristic = inheuristic;
+    if (inheuristic) childselrule = ChildSelectionRule::kHybridInferenceCost;
+  }
+
+  void addBoundExceedingConflict();
+
+  void resetLocalDomain();
+
+  int64_t getHeuristicLpIterations() const;
+
+  int64_t getTotalLpIterations() const;
+
+  int64_t getLocalLpIterations() const;
+
+  int64_t getLocalNodes() const;
+
+  int64_t getStrongBranchingLpIterations() const;
+
+  bool hasNode() const { return !nodestack.empty(); }
+
+  bool currentNodePruned() const { return nodestack.back().opensubtrees == 0; }
+
+  double getCurrentEstimate() const { return nodestack.back().estimate; }
+
+  double getCurrentLowerBound() const { return nodestack.back().lower_bound; }
+
+  HighsInt getCurrentDepth() const { return nodestack.size() + depthoffset; }
+
+  void openNodesToQueue(HighsNodeQueue& nodequeue);
+
+  void currentNodeToQueue(HighsNodeQueue& nodequeue);
+
+  void flushStatistics();
+
+  void installNode(HighsNodeQueue::OpenNode&& node);
+
+  void addInfeasibleConflict();
+
+  HighsInt selectBranchingCandidate(int64_t maxSbIters, double& downNodeLb,
+                                    double& upNodeLb);
+
+  void evalUnreliableBranchCands();
+
+  const NodeData* getParentNodeData() const;
+
+  NodeResult evaluateNode();
+
+  NodeResult branch();
+
+  /// backtrack one level in DFS manner
+  bool backtrack(bool recoverBasis = true);
+
+  /// backtrack an unspecified amount of depth level until the next
+  /// node that seems worthwhile to continue the plunge. Put unpromising nodes
+  /// to the node queue
+  bool backtrackPlunge(HighsNodeQueue& nodequeue);
+
+  /// for heuristics. Will discard nodes above targetDepth regardless of their
+  /// status
+  bool backtrackUntilDepth(HighsInt targetDepth);
+
+  void printDisplayLine(char first, bool header = false);
+
+  NodeResult dive();
+
+  HighsDomain& getLocalDomain() { return localdom; }
+
+  const HighsDomain& getLocalDomain() const { return localdom; }
+
+  HighsPseudocost& getPseudoCost() { return pseudocost; }
+
+  const HighsPseudocost& getPseudoCost() const { return pseudocost; }
+
+  void solveDepthFirst(int64_t maxbacktracks = 1);
+};
+
+#endif

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

@@ -0,0 +1,186 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+#include "mip/HighsSeparation.h"
+
+#include <algorithm>
+#include <cassert>
+#include <queue>
+
+#include "mip/HighsCliqueTable.h"
+#include "mip/HighsDomain.h"
+#include "mip/HighsImplications.h"
+#include "mip/HighsLpAggregator.h"
+#include "mip/HighsLpRelaxation.h"
+#include "mip/HighsMipSolverData.h"
+#include "mip/HighsModkSeparator.h"
+#include "mip/HighsPathSeparator.h"
+#include "mip/HighsTableauSeparator.h"
+#include "mip/HighsTransformedLp.h"
+
+HighsSeparation::HighsSeparation(const HighsMipSolver& mipsolver) {
+  if (mipsolver.analysis_.analyse_mip_time) {
+    implBoundClock =
+        mipsolver.analysis_.getSepaClockIndex(kImplboundSepaString);
+    cliqueClock = mipsolver.analysis_.getSepaClockIndex(kCliqueSepaString);
+  }
+  separators.emplace_back(new HighsTableauSeparator(mipsolver));
+  separators.emplace_back(new HighsPathSeparator(mipsolver));
+  separators.emplace_back(new HighsModkSeparator(mipsolver));
+}
+
+HighsInt HighsSeparation::separationRound(HighsDomain& propdomain,
+                                          HighsLpRelaxation::Status& status) {
+  const HighsSolution& sol = lp->getLpSolver().getSolution();
+
+  HighsMipSolverData& mipdata = *lp->getMipSolver().mipdata_;
+
+  auto propagateAndResolve = [&]() {
+    if (propdomain.infeasible() || mipdata.domain.infeasible()) {
+      status = HighsLpRelaxation::Status::kInfeasible;
+      propdomain.clearChangedCols();
+      return -1;
+    }
+
+    propdomain.propagate();
+    if (propdomain.infeasible()) {
+      status = HighsLpRelaxation::Status::kInfeasible;
+      propdomain.clearChangedCols();
+      return -1;
+    }
+
+    mipdata.cliquetable.cleanupFixed(mipdata.domain);
+    if (mipdata.domain.infeasible()) {
+      status = HighsLpRelaxation::Status::kInfeasible;
+      propdomain.clearChangedCols();
+      return -1;
+    }
+
+    int numBoundChgs = (int)propdomain.getChangedCols().size();
+
+    while (!propdomain.getChangedCols().empty()) {
+      lp->setObjectiveLimit(mipdata.upper_limit);
+      status = lp->resolveLp(&propdomain);
+      if (!lp->scaledOptimal(status)) return -1;
+
+      if (&propdomain == &mipdata.domain && lp->unscaledDualFeasible(status)) {
+        mipdata.redcostfixing.addRootRedcost(
+            mipdata.mipsolver, lp->getSolution().col_dual, lp->getObjective());
+        if (mipdata.upper_limit != kHighsInf)
+          mipdata.redcostfixing.propagateRootRedcost(mipdata.mipsolver);
+      }
+    }
+
+    return numBoundChgs;
+  };
+
+  lp->getMipSolver().analysis_.mipTimerStart(implBoundClock);
+  mipdata.implications.separateImpliedBounds(*lp, lp->getSolution().col_value,
+                                             mipdata.cutpool, mipdata.feastol);
+  lp->getMipSolver().analysis_.mipTimerStop(implBoundClock);
+
+  HighsInt ncuts = 0;
+  HighsInt numboundchgs = propagateAndResolve();
+  if (numboundchgs == -1)
+    return 0;
+  else
+    ncuts += numboundchgs;
+
+  lp->getMipSolver().analysis_.mipTimerStart(cliqueClock);
+  mipdata.cliquetable.separateCliques(lp->getMipSolver(), sol.col_value,
+                                      mipdata.cutpool, mipdata.feastol);
+  lp->getMipSolver().analysis_.mipTimerStop(cliqueClock);
+
+  numboundchgs = propagateAndResolve();
+  if (numboundchgs == -1)
+    return 0;
+  else
+    ncuts += numboundchgs;
+
+  if (&propdomain != &mipdata.domain)
+    lp->computeBasicDegenerateDuals(mipdata.feastol, &propdomain);
+
+  HighsTransformedLp transLp(*lp, mipdata.implications);
+  if (mipdata.domain.infeasible()) {
+    status = HighsLpRelaxation::Status::kInfeasible;
+    return 0;
+  }
+  HighsLpAggregator lpAggregator(*lp);
+
+  for (const std::unique_ptr<HighsSeparator>& separator : separators) {
+    separator->run(*lp, lpAggregator, transLp, mipdata.cutpool);
+    if (mipdata.domain.infeasible()) {
+      status = HighsLpRelaxation::Status::kInfeasible;
+      return 0;
+    }
+  }
+
+  numboundchgs = propagateAndResolve();
+  if (numboundchgs == -1)
+    return 0;
+  else
+    ncuts += numboundchgs;
+
+  mipdata.cutpool.separate(sol.col_value, propdomain, cutset, mipdata.feastol);
+
+  if (cutset.numCuts() > 0) {
+    ncuts += cutset.numCuts();
+    lp->addCuts(cutset);
+    status = lp->resolveLp(&propdomain);
+    lp->performAging(true);
+    if (&propdomain == &mipdata.domain && lp->unscaledDualFeasible(status)) {
+      mipdata.redcostfixing.addRootRedcost(
+          mipdata.mipsolver, lp->getSolution().col_dual, lp->getObjective());
+      if (mipdata.upper_limit != kHighsInf)
+        mipdata.redcostfixing.propagateRootRedcost(mipdata.mipsolver);
+    }
+  }
+
+  return ncuts;
+}
+
+void HighsSeparation::separate(HighsDomain& propdomain) {
+  HighsLpRelaxation::Status status = lp->getStatus();
+  const HighsMipSolver& mipsolver = lp->getMipSolver();
+
+  if (lp->scaledOptimal(status) && !lp->getFractionalIntegers().empty()) {
+    // double firstobj = lp->getObjective();
+    double firstobj = mipsolver.mipdata_->rootlpsolobj;
+
+    while (lp->getObjective() < mipsolver.mipdata_->optimality_limit) {
+      double lastobj = lp->getObjective();
+
+      size_t nlpiters = -lp->getNumLpIterations();
+      HighsInt ncuts = separationRound(propdomain, status);
+      nlpiters += lp->getNumLpIterations();
+      mipsolver.mipdata_->sepa_lp_iterations += nlpiters;
+      mipsolver.mipdata_->total_lp_iterations += nlpiters;
+      // printf("separated %" HIGHSINT_FORMAT " cuts\n", ncuts);
+
+      // printf(
+      //     "separation round %" HIGHSINT_FORMAT " at node %" HIGHSINT_FORMAT "
+      //     added %" HIGHSINT_FORMAT " cuts objective changed " "from %g to %g,
+      //     first obj is %g\n", nrounds, (HighsInt)nnodes, ncuts, lastobj,
+      //     lp->getObjective(), firstobj);
+      if (ncuts == 0 || !lp->scaledOptimal(status) ||
+          lp->getFractionalIntegers().empty())
+        break;
+
+      // if the objective improved considerably we continue
+      if ((lp->getObjective() - firstobj) <=
+          std::max((lastobj - firstobj), mipsolver.mipdata_->feastol) * 1.01)
+        break;
+    }
+
+    // printf("done separating\n");
+  } else {
+    // printf("no separation, just aging. status: %" HIGHSINT_FORMAT "\n",
+    //        (HighsInt)status);
+    lp->performAging(true);
+    mipsolver.mipdata_->cutpool.performAging();
+  }
+}

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

@@ -0,0 +1,41 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+#ifndef HIGHS_SEPARATION_H_
+#define HIGHS_SEPARATION_H_
+
+#include <cstdint>
+#include <vector>
+
+#include "mip/HighsCutPool.h"
+#include "mip/HighsLpRelaxation.h"
+#include "mip/HighsSeparator.h"
+
+class HighsMipSolver;
+class HighsImplications;
+class HighsCliqueTable;
+
+class HighsSeparation {
+ public:
+  HighsInt separationRound(HighsDomain& propdomain,
+                           HighsLpRelaxation::Status& status);
+
+  void separate(HighsDomain& propdomain);
+
+  void setLpRelaxation(HighsLpRelaxation* lp) { this->lp = lp; }
+
+  HighsSeparation(const HighsMipSolver& mipsolver);
+
+ private:
+  HighsInt implBoundClock;
+  HighsInt cliqueClock;
+  std::vector<std::unique_ptr<HighsSeparator>> separators;
+  HighsCutSet cutset;
+  HighsLpRelaxation* lp;
+};
+
+#endif

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

@@ -0,0 +1,39 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+#include "mip/HighsSeparator.h"
+
+#include <string>
+
+#include "mip/HighsCutPool.h"
+#include "mip/HighsLpRelaxation.h"
+#include "mip/HighsMipSolver.h"
+
+HighsSeparator::HighsSeparator(const HighsMipSolver& mipsolver,
+                               const std::string& name)
+    : numCutsFound(0), numCalls(0) {
+  this->clockIndex = -1;
+  // Don't get the clock index when analyse_mip_time is false - as
+  // will generally be the case, and always so for sub-MIPs
+  if (mipsolver.analysis_.analyse_mip_time) {
+    this->clockIndex = mipsolver.analysis_.getSepaClockIndex(name);
+    assert(this->clockIndex > 0);
+  }
+}
+
+void HighsSeparator::run(HighsLpRelaxation& lpRelaxation,
+                         HighsLpAggregator& lpAggregator,
+                         HighsTransformedLp& transLp, HighsCutPool& cutpool) {
+  ++numCalls;
+  HighsInt currNumCuts = cutpool.getNumCuts();
+
+  lpRelaxation.getMipSolver().analysis_.mipTimerStart(clockIndex);
+  separateLpSolution(lpRelaxation, lpAggregator, transLp, cutpool);
+  lpRelaxation.getMipSolver().analysis_.mipTimerStop(clockIndex);
+
+  numCutsFound += cutpool.getNumCuts() - currNumCuts;
+}

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

@@ -0,0 +1,60 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/**@file mip/HighsSeparator.h
+ * @brief Base class for separators
+ *
+ */
+
+#ifndef MIP_HIGHS_SEPARATOR_H_
+#define MIP_HIGHS_SEPARATOR_H_
+
+#include <string>
+
+#include "util/HighsInt.h"
+
+const std::string kImplboundSepaString = "Separation: Implied bounds";
+const std::string kCliqueSepaString = "Separation: Clique";
+const std::string kTableauSepaString = "Separation: Tableau";
+const std::string kPathAggrSepaString = "Separation: Path aggregation";
+const std::string kModKSepaString = "Separation: Mod-k";
+
+class HighsLpRelaxation;
+class HighsTransformedLp;
+class HighsCutPool;
+class HighsLpAggregator;
+class HighsMipSolver;
+
+/// Helper class to compute single-row relaxations from the current LP
+/// relaxation by substituting bounds and aggregating rows
+class HighsSeparator {
+ private:
+  HighsInt numCutsFound;
+  HighsInt numCalls;
+  int clockIndex;
+
+ public:
+  HighsSeparator(const HighsMipSolver& mipsolver, const std::string& name);
+
+  virtual void separateLpSolution(HighsLpRelaxation& lpRelaxation,
+                                  HighsLpAggregator& lpAggregator,
+                                  HighsTransformedLp& transLp,
+                                  HighsCutPool& cutpool) = 0;
+
+  void run(HighsLpRelaxation& lpRelaxation, HighsLpAggregator& lpAggregator,
+           HighsTransformedLp& transLp, HighsCutPool& cutpool);
+
+  HighsInt getNumCutsFound() const { return numCutsFound; }
+
+  HighsInt getNumCalls() const { return numCalls; }
+
+  HighsInt getClockIndex() const { return clockIndex; }
+
+  virtual ~HighsSeparator() {}
+};
+
+#endif