lpsolver 0.1.0 → 0.2.1

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

@@ -0,0 +1,168 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+#ifndef HIGHS_CUTPOOL_H_
+#define HIGHS_CUTPOOL_H_
+
+#include <memory>
+#include <unordered_map>
+#include <vector>
+
+#include "lp_data/HConst.h"
+#include "mip/HighsDomain.h"
+#include "mip/HighsDynamicRowMatrix.h"
+
+class HighsLpRelaxation;
+
+struct HighsCutSet {
+  std::vector<HighsInt> cutindices;
+  std::vector<HighsInt> ARstart_;
+  std::vector<HighsInt> ARindex_;
+  std::vector<double> ARvalue_;
+  std::vector<double> lower_;
+  std::vector<double> upper_;
+
+  HighsInt numCuts() const { return cutindices.size(); }
+
+  void resize(HighsInt nnz) {
+    HighsInt ncuts = numCuts();
+    lower_.resize(ncuts, -kHighsInf);
+    upper_.resize(ncuts);
+    ARstart_.resize(ncuts + 1);
+    ARindex_.resize(nnz);
+    ARvalue_.resize(nnz);
+  }
+
+  void clear() {
+    cutindices.clear();
+    upper_.clear();
+    ARstart_.clear();
+    ARindex_.clear();
+    ARvalue_.clear();
+  }
+
+  bool empty() const { return cutindices.empty(); }
+};
+
+class HighsCutPool {
+ private:
+  HighsDynamicRowMatrix matrix_;
+  std::vector<double> rhs_;
+  std::vector<int16_t> ages_;
+  std::vector<double> rownormalization_;
+  std::vector<double> maxabscoef_;
+  std::vector<uint8_t> rowintegral;
+  std::unordered_multimap<uint64_t, HighsInt> hashToCutMap;
+  std::vector<HighsDomain::CutpoolPropagation*> propagationDomains;
+  std::set<std::pair<HighsInt, HighsInt>> propRows;
+
+  double bestObservedScore;
+  double minScoreFactor;
+  double minDensityLim;
+
+  HighsInt agelim_;
+  HighsInt softlimit_;
+  HighsInt numLpCuts;
+  HighsInt numPropNzs;
+  HighsInt numPropRows;
+  std::vector<HighsInt> ageDistribution;
+  std::vector<std::pair<HighsInt, double>> sortBuffer;
+
+  bool isDuplicate(size_t hash, double norm, const HighsInt* Rindex,
+                   const double* Rvalue, HighsInt Rlen, double rhs);
+
+ public:
+  HighsCutPool(HighsInt ncols, HighsInt agelim, HighsInt softlimit)
+      : matrix_(ncols),
+        agelim_(agelim),
+        softlimit_(softlimit),
+        numLpCuts(0),
+        numPropNzs(0),
+        numPropRows(0) {
+    ageDistribution.resize(agelim_ + 1);
+    minScoreFactor = 0.9;
+    bestObservedScore = 0.0;
+    minDensityLim = 0.1 * ncols;
+  }
+  const HighsDynamicRowMatrix& getMatrix() const { return matrix_; }
+
+  const std::vector<double>& getRhs() const { return rhs_; }
+
+  void resetAge(HighsInt cut) {
+    if (ages_[cut] > 0) {
+      if (matrix_.columnsLinked(cut)) {
+        propRows.erase(std::make_pair(ages_[cut], cut));
+        propRows.emplace(0, cut);
+      }
+      ageDistribution[ages_[cut]] -= 1;
+      ageDistribution[0] += 1;
+      ages_[cut] = 0;
+    }
+  }
+
+  double getParallelism(HighsInt row1, HighsInt row2) const;
+
+  void performAging();
+
+  void lpCutRemoved(HighsInt cut);
+
+  void addPropagationDomain(HighsDomain::CutpoolPropagation* domain) {
+    propagationDomains.push_back(domain);
+  }
+
+  void removePropagationDomain(HighsDomain::CutpoolPropagation* domain) {
+    for (HighsInt k = propagationDomains.size() - 1; k >= 0; --k) {
+      if (propagationDomains[k] == domain) {
+        propagationDomains.erase(propagationDomains.begin() + k);
+        return;
+      }
+    }
+  }
+
+  void setAgeLimit(HighsInt agelim) {
+    agelim_ = agelim;
+    ageDistribution.resize(agelim_ + 1);
+  }
+
+  void separate(const std::vector<double>& sol, HighsDomain& domprop,
+                HighsCutSet& cutset, double feastol);
+
+  void separateLpCutsAfterRestart(HighsCutSet& cutset);
+
+  bool cutIsIntegral(HighsInt cut) const { return (rowintegral[cut] != 0); }
+
+  HighsInt getNumCuts() const {
+    return matrix_.getNumRows() - matrix_.getNumDelRows();
+  }
+
+  HighsInt getNumAvailableCuts() const { return getNumCuts() - numLpCuts; }
+
+  double getMaxAbsCutCoef(HighsInt cut) const { return maxabscoef_[cut]; }
+
+  double getRowNormalization(HighsInt cut) const {
+    return rownormalization_[cut];
+  }
+
+  HighsInt addCut(const HighsMipSolver& mipsolver, HighsInt* Rindex,
+                  double* Rvalue, HighsInt Rlen, double rhs,
+                  bool integral = false, bool propagate = true,
+                  bool extractCliques = true, bool isConflict = false);
+
+  HighsInt getRowLength(HighsInt row) const {
+    return matrix_.getRowEnd(row) - matrix_.getRowStart(row);
+  }
+
+  void getCut(HighsInt cut, HighsInt& cutlen, const HighsInt*& cutinds,
+              const double*& cutvals) const {
+    HighsInt start = matrix_.getRowStart(cut);
+    cutlen = matrix_.getRowEnd(cut) - start;
+    cutinds = matrix_.getARindex() + start;
+    cutvals = matrix_.getARvalue() + start;
+  }
+};
+
+#endif

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

@@ -0,0 +1,313 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+#include "mip/HighsDebugSol.h"
+
+#ifdef HIGHS_DEBUGSOL
+
+#include <fstream>
+
+#include "io/FilereaderMps.h"
+#include "lp_data/HighsLpUtils.h"
+#include "mip/HighsDomain.h"
+#include "mip/HighsMipSolver.h"
+#include "mip/HighsMipSolverData.h"
+
+HighsDebugSol::HighsDebugSol(HighsMipSolver& mipsolver)
+    : debugSolActive(false) {
+  this->mipsolver = &mipsolver;
+  debugSolObjective = -kHighsInf;
+  debugSolActive = false;
+}
+
+void HighsDebugSol::activate() {
+  if (!mipsolver->submip &&
+      debugSolObjective <= mipsolver->mipdata_->upper_limit &&
+      !mipsolver->options_mip_->mip_debug_solution_file.empty()) {
+    highsLogDev(mipsolver->options_mip_->log_options, HighsLogType::kInfo,
+                "reading debug solution file %s\n",
+                mipsolver->options_mip_->mip_debug_solution_file.c_str());
+    std::ifstream file(mipsolver->options_mip_->mip_debug_solution_file);
+    if (file) {
+      std::string varname;
+      double varval;
+      std::string line;
+      bool incolsection = false;
+      std::map<std::string, int> nametoidx;
+
+      for (HighsInt i = 0; i != mipsolver->orig_model_->num_col_; ++i)
+        nametoidx[mipsolver->orig_model_->col_names_[i]] = i;
+
+      debugOrigSolution.resize(mipsolver->orig_model_->num_col_, 0.0);
+      while (std::getline(file, line)) {
+        // Check for start and stop markers
+        if (line.find("# Columns") != std::string::npos) {
+          incolsection = true;
+          continue;
+        }
+        if (line.find("# Rows") != std::string::npos) {
+          break;
+        }
+        if (!incolsection) continue;
+
+        std::istringstream linestream(line);
+        linestream >> varname;
+        auto it = nametoidx.find(varname);
+        if (it != nametoidx.end()) {
+          linestream >> varval;
+          debugOrigSolution[it->second] = varval;
+          highsLogDev(mipsolver->options_mip_->log_options, HighsLogType::kInfo,
+                      "%s = %g\n", varname.c_str(), varval);
+        }
+      }
+      debugSolution = debugOrigSolution;
+
+      HighsCDouble debugsolobj = 0.0;
+      for (HighsInt i = 0; i != mipsolver->orig_model_->num_col_; ++i)
+        debugsolobj += mipsolver->orig_model_->col_cost_[i] *
+                       HighsCDouble(debugOrigSolution[i]);
+
+      debugSolObjective = double(debugsolobj + mipsolver->orig_model_->offset_);
+      debugSolActive = true;
+      printf("debug sol active\n");
+      registerDomain(mipsolver->mipdata_->domain);
+    } else {
+      highsLogUser(mipsolver->options_mip_->log_options, HighsLogType::kWarning,
+                   "debug solution: could not open file '%s'\n",
+                   mipsolver->options_mip_->mip_debug_solution_file.c_str());
+      HighsModel model;
+      model.lp_ = *mipsolver->model_;
+      model.lp_.col_names_.clear();
+      model.lp_.row_names_.clear();
+      model.lp_.col_lower_ = mipsolver->mipdata_->domain.col_lower_;
+      model.lp_.col_upper_ = mipsolver->mipdata_->domain.col_upper_;
+      FilereaderMps().writeModelToFile(*mipsolver->options_mip_,
+                                       "debug_mip.mps", model);
+    }
+  }
+}
+
+void HighsDebugSol::shrink(const std::vector<HighsInt>& newColIndex) {
+  if (!debugSolActive) return;
+
+  HighsInt oldNumCol = debugSolution.size();
+  for (HighsInt i = 0; i != oldNumCol; ++i)
+    if (newColIndex[i] != -1) debugSolution[newColIndex[i]] = debugSolution[i];
+
+  debugSolution.resize(mipsolver->model_->num_col_);
+  HighsCDouble debugsolobj = 0.0;
+  for (HighsInt i = 0; i != mipsolver->model_->num_col_; ++i)
+    debugsolobj += mipsolver->model_->col_cost_[i] * debugSolution[i];
+
+  debugSolObjective = double(debugsolobj);
+
+  conflictingBounds.clear();
+}
+
+void HighsDebugSol::registerDomain(const HighsDomain& domain) {
+  conflictingBounds.emplace(&domain, std::multiset<HighsDomainChange>());
+
+  if (!debugSolActive) return;
+
+  for (HighsInt i = 0; i != mipsolver->numCol(); ++i) {
+    assert(domain.col_lower_[i] <=
+           debugSolution[i] + mipsolver->mipdata_->feastol);
+    assert(domain.col_upper_[i] >=
+           debugSolution[i] - mipsolver->mipdata_->feastol);
+  }
+}
+
+void HighsDebugSol::newIncumbentFound() {
+  if (debugSolActive && debugSolObjective > mipsolver->mipdata_->upper_limit) {
+    printf("debug sol inactive\n");
+    debugSolActive = false;
+  }
+}
+
+void HighsDebugSol::boundChangeAdded(const HighsDomain& domain,
+                                     const HighsDomainChange& domchg,
+                                     bool branching) {
+  if (!debugSolActive) return;
+
+  if (conflictingBounds.count(&domain) == 0) return;
+
+  if (domchg.boundtype == HighsBoundType::kLower) {
+    if (domchg.boundval <=
+        debugSolution[domchg.column] + mipsolver->mipdata_->feastol)
+      return;
+  } else {
+    if (domchg.boundval >=
+        debugSolution[domchg.column] - mipsolver->mipdata_->feastol)
+      return;
+  }
+
+  if (branching || !conflictingBounds[&domain].empty()) {
+    conflictingBounds[&domain].insert(domchg);
+    return;
+  }
+
+  assert(false);
+}
+
+void HighsDebugSol::boundChangeRemoved(const HighsDomain& domain,
+                                       const HighsDomainChange& domchg) {
+  if (!debugSolActive) return;
+
+  if (conflictingBounds.count(&domain) == 0) return;
+
+  auto i = conflictingBounds[&domain].find(domchg);
+  if (i != conflictingBounds[&domain].end())
+    conflictingBounds[&domain].erase(i);
+}
+
+void HighsDebugSol::checkCut(const HighsInt* Rindex, const double* Rvalue,
+                             HighsInt Rlen, double rhs) {
+  if (!debugSolActive) return;
+
+  HighsCDouble violation = -rhs;
+
+  for (HighsInt i = 0; i != Rlen; ++i)
+    violation += debugSolution[Rindex[i]] * Rvalue[i];
+
+  assert(violation <= mipsolver->mipdata_->feastol);
+}
+
+void HighsDebugSol::checkRowAggregation(const HighsLp& lp,
+                                        const HighsInt* Rindex,
+                                        const double* Rvalue, HighsInt Rlen) {
+  if (!debugSolActive) return;
+  HighsCDouble violation = 0.0;
+
+  HighsSolution dbgSol;
+  dbgSol.dual_valid = false;
+  dbgSol.value_valid = true;
+  dbgSol.col_value = debugSolution;
+  calculateRowValuesQuad(lp, dbgSol);
+  for (HighsInt i = 0; i < Rlen; ++i) {
+    if (Rindex[i] < lp.num_col_)
+      violation += dbgSol.col_value[Rindex[i]] * Rvalue[i];
+    else
+      violation += dbgSol.row_value[Rindex[i] - lp.num_col_] * Rvalue[i];
+  }
+
+  double viol = fabs(double(violation));
+
+  assert(viol <= mipsolver->mipdata_->feastol);
+}
+
+void HighsDebugSol::checkRow(const HighsInt* Rindex, const double* Rvalue,
+                             HighsInt Rlen, double Rlower, double Rupper) {
+  if (!debugSolActive) return;
+
+  HighsCDouble activity = 0;
+
+  for (HighsInt i = 0; i != Rlen; ++i)
+    activity += debugSolution[Rindex[i]] * Rvalue[i];
+
+  assert(activity - mipsolver->mipdata_->feastol <= Rupper);
+  assert(activity + mipsolver->mipdata_->feastol >= Rlower);
+}
+
+void HighsDebugSol::resetDomain(const HighsDomain& domain) {
+  if (conflictingBounds.count(&domain) == 0) return;
+
+  conflictingBounds[&domain].clear();
+}
+
+void HighsDebugSol::nodePruned(const HighsDomain& localdomain) {
+  if (!debugSolActive) return;
+
+  if (conflictingBounds.count(&localdomain) == 0) return;
+
+  assert(!conflictingBounds[&localdomain].empty());
+}
+
+void HighsDebugSol::checkClique(const HighsCliqueTable::CliqueVar* clq,
+                                HighsInt clqlen) {
+  if (!debugSolActive) return;
+
+  HighsInt violation = -1;
+
+  for (HighsInt i = 0; i != clqlen; ++i)
+    violation += (HighsInt)(clq[i].weight(debugSolution) + 0.5);
+
+  assert(violation <= 0);
+}
+
+void HighsDebugSol::checkVub(HighsInt col, HighsInt vubcol, double vubcoef,
+                             double vubconstant) const {
+  if (!debugSolActive || std::abs(vubcoef) == kHighsInf) return;
+
+  assert(debugSolution[col] <= debugSolution[vubcol] * vubcoef + vubconstant +
+                                   mipsolver->mipdata_->feastol);
+}
+
+void HighsDebugSol::checkVlb(HighsInt col, HighsInt vlbcol, double vlbcoef,
+                             double vlbconstant) const {
+  if (!debugSolActive || std::abs(vlbcoef) == kHighsInf) return;
+
+  assert(debugSolution[col] >= debugSolution[vlbcol] * vlbcoef + vlbconstant -
+                                   mipsolver->mipdata_->feastol);
+}
+
+void HighsDebugSol::checkConflictReasonFrontier(
+    const std::set<HighsDomain::ConflictSet::LocalDomChg>& reasonSideFrontier,
+    const std::vector<HighsDomainChange>& domchgstack) const {
+  if (!debugSolActive) return;
+
+  HighsInt numActiveBoundChgs = 0;
+  for (const HighsDomain::ConflictSet::LocalDomChg& domchg :
+       reasonSideFrontier) {
+    HighsInt col = domchg.domchg.column;
+
+    if (domchg.domchg.boundtype == HighsBoundType::kLower) {
+      if (debugSolution[col] >=
+          domchg.domchg.boundval - mipsolver->mipdata_->feastol)
+        ++numActiveBoundChgs;
+    } else {
+      if (debugSolution[col] <=
+          domchg.domchg.boundval + mipsolver->mipdata_->feastol)
+        ++numActiveBoundChgs;
+    }
+  }
+
+  assert(numActiveBoundChgs < (HighsInt)reasonSideFrontier.size());
+}
+
+void HighsDebugSol::checkConflictReconvergenceFrontier(
+    const std::set<HighsDomain::ConflictSet::LocalDomChg>&
+        reconvergenceFrontier,
+    const HighsDomain::ConflictSet::LocalDomChg& reconvDomchg,
+    const std::vector<HighsDomainChange>& domchgstack) const {
+  if (!debugSolActive) return;
+
+  HighsInt numActiveBoundChgs = 0;
+  for (const HighsDomain::ConflictSet::LocalDomChg& domchg :
+       reconvergenceFrontier) {
+    HighsInt col = domchg.domchg.column;
+
+    if (domchg.domchg.boundtype == HighsBoundType::kLower) {
+      if (debugSolution[col] >= domchg.domchg.boundval) ++numActiveBoundChgs;
+    } else {
+      if (debugSolution[col] <= domchg.domchg.boundval) ++numActiveBoundChgs;
+    }
+  }
+
+  auto reconvChg = mipsolver->mipdata_->domain.flip(reconvDomchg.domchg);
+
+  if (reconvChg.boundtype == HighsBoundType::kLower) {
+    if (debugSolution[reconvChg.column] >= reconvChg.boundval)
+      ++numActiveBoundChgs;
+  } else {
+    if (debugSolution[reconvChg.column] <= reconvChg.boundval)
+      ++numActiveBoundChgs;
+  }
+
+  assert(numActiveBoundChgs <= (HighsInt)reconvergenceFrontier.size());
+}
+
+#endif

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

@@ -0,0 +1,133 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/**@file mip/HighsDebugSol.h
+ * @brief Debug solution for MIP solver
+ */
+
+#ifndef HIGHS_DEBUG_SOL_H_
+#define HIGHS_DEBUG_SOL_H_
+
+class HighsDomain;
+class HighsMipSolver;
+class HighsLp;
+
+#include <set>
+#include <vector>
+
+#include "mip/HighsCliqueTable.h"
+#include "mip/HighsDomain.h"
+
+#ifdef HIGHS_DEBUGSOL
+
+#include <unordered_map>
+
+struct HighsDebugSol {
+  const HighsMipSolver* mipsolver;
+  double debugSolObjective;
+  std::vector<double> debugOrigSolution;
+  std::vector<double> debugSolution;
+  bool debugSolActive;
+  std::unordered_map<const HighsDomain*, std::multiset<HighsDomainChange>>
+      conflictingBounds;
+
+  HighsDebugSol(HighsMipSolver& mipsolver);
+
+  void newIncumbentFound();
+
+  void activate();
+
+  void shrink(const std::vector<HighsInt>& newColIndex);
+
+  void registerDomain(const HighsDomain& domain);
+
+  void boundChangeAdded(const HighsDomain& domain,
+                        const HighsDomainChange& domchg,
+                        bool branching = false);
+
+  void boundChangeRemoved(const HighsDomain& domain,
+                          const HighsDomainChange& domchg);
+
+  void resetDomain(const HighsDomain& domain);
+
+  void nodePruned(const HighsDomain& localdomain);
+
+  void checkCut(const HighsInt* Rindex, const double* Rvalue, HighsInt Rlen,
+                double rhs);
+
+  void checkRow(const HighsInt* Rindex, const double* Rvalue, HighsInt Rlen,
+                double Rlower, double Rupper);
+
+  void checkRowAggregation(const HighsLp& lp, const HighsInt* Rindex,
+                           const double* Rvalue, HighsInt Rlen);
+
+  void checkClique(const HighsCliqueTable::CliqueVar* clq, HighsInt clqlen);
+
+  void checkVub(HighsInt col, HighsInt vubcol, double vubcoef,
+                double vubconstant) const;
+
+  void checkVlb(HighsInt col, HighsInt vlbcol, double vlbcoef,
+                double vlbconstant) const;
+
+  void checkConflictReasonFrontier(
+      const std::set<HighsDomain::ConflictSet::LocalDomChg>& reasonSideFrontier,
+      const std::vector<HighsDomainChange>& domchgstack) const;
+
+  void checkConflictReconvergenceFrontier(
+      const std::set<HighsDomain::ConflictSet::LocalDomChg>&
+          reconvergenceFrontier,
+      const HighsDomain::ConflictSet::LocalDomChg& reconvDomchgPos,
+      const std::vector<HighsDomainChange>& domchgstack) const;
+};
+
+#else
+struct HighsDebugSol {
+  HighsDebugSol(HighsMipSolver&) {}
+
+  void newIncumbentFound() const {}
+
+  void activate() const {}
+
+  void shrink(const std::vector<HighsInt>&) const {}
+
+  void registerDomain(const HighsDomain&) const {}
+
+  void boundChangeAdded(const HighsDomain&, const HighsDomainChange&,
+                        bool = false) const {}
+
+  void boundChangeRemoved(const HighsDomain&, const HighsDomainChange&) const {}
+
+  void resetDomain(const HighsDomain&) const {}
+
+  void nodePruned(const HighsDomain&) const {}
+
+  void checkCut(const HighsInt*, const double*, HighsInt, double) const {}
+
+  void checkRow(const HighsInt*, const double*, HighsInt, double,
+                double) const {}
+
+  void checkRowAggregation(const HighsLp&, const HighsInt*, const double*,
+                           HighsInt) const {}
+
+  void checkClique(const HighsCliqueTable::CliqueVar*, HighsInt) const {}
+
+  void checkVub(HighsInt, HighsInt, double, double) const {}
+
+  void checkVlb(HighsInt, HighsInt, double, double) const {}
+
+  void checkConflictReasonFrontier(
+      const std::set<HighsDomain::ConflictSet::LocalDomChg>&,
+      const std::vector<HighsDomainChange>&) const {}
+
+  void checkConflictReconvergenceFrontier(
+      const std::set<HighsDomain::ConflictSet::LocalDomChg>&,
+      const HighsDomain::ConflictSet::LocalDomChg&,
+      const std::vector<HighsDomainChange>&) const {}
+};
+#endif
+
+#endif