lpsolver 0.1.0 → 0.2.0

data/ext/lpsolver-highs/build/include/highs/mip/HighsMipSolver.h

@@ -0,0 +1,159 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+#ifndef MIP_HIGHS_MIP_SOLVER_H_
+#define MIP_HIGHS_MIP_SOLVER_H_
+
+#include "Highs.h"
+#include "lp_data/HighsCallback.h"
+#include "lp_data/HighsOptions.h"
+#include "mip/HighsMipAnalysis.h"
+
+struct HighsMipSolverData;
+class HighsCutPool;
+struct HighsPseudocostInitialization;
+class HighsCliqueTable;
+class HighsImplications;
+
+struct HighsTerminator {
+  HighsInt num_instance;
+  HighsInt my_instance;
+  HighsModelStatus* record;
+  void clear();
+  void initialise(HighsInt num_instance_, HighsInt my_instance_,
+                  HighsModelStatus* record_);
+  HighsInt concurrency() const;
+  void terminate();
+  bool terminated() const;
+  HighsModelStatus terminationStatus() const;
+  void report(const HighsLogOptions log_options) const;
+};
+
+class HighsMipSolver {
+ public:
+  HighsCallback* callback_;
+  const HighsOptions* options_mip_;
+  const HighsLp* model_;
+  const HighsLp* orig_model_;
+  HighsModelStatus modelstatus_;
+  std::vector<double> solution_;
+  double solution_objective_;
+  double bound_violation_;
+  double integrality_violation_;
+  double row_violation_;
+  // The following are only to return data to HiGHS, and are set in
+  // HighsMipSolver::cleanupSolve
+  double dual_bound_;
+  double primal_bound_;
+  double gap_;
+  int64_t node_count_;
+  int64_t total_lp_iterations_;
+  double primal_dual_integral_;
+
+  FILE* improving_solution_file_;
+  std::vector<HighsObjectiveSolution> saved_objective_and_solution_;
+
+  bool submip;
+  HighsInt submip_level;
+  HighsInt max_submip_level;
+  const HighsBasis* rootbasis;
+  const HighsPseudocostInitialization* pscostinit;
+  const HighsCliqueTable* clqtableinit;
+  const HighsImplications* implicinit;
+
+  std::unique_ptr<HighsMipSolverData> mipdata_;
+
+  HighsMipAnalysis analysis_;
+
+  HighsModelStatus termination_status_;
+  HighsTerminator terminator_;
+
+  void run();
+
+  HighsInt numCol() const { return model_->num_col_; }
+
+  HighsInt numRow() const { return model_->num_row_; }
+
+  HighsInt numNonzero() const { return model_->a_matrix_.numNz(); }
+
+  const double* colCost() const { return model_->col_cost_.data(); }
+
+  double colCost(HighsInt col) const { return model_->col_cost_[col]; }
+
+  const double* rowLower() const { return model_->row_lower_.data(); }
+
+  double rowLower(HighsInt col) const { return model_->row_lower_[col]; }
+
+  const double* rowUpper() const { return model_->row_upper_.data(); }
+
+  double rowUpper(HighsInt col) const { return model_->row_upper_[col]; }
+
+  const HighsVarType* variableType() const {
+    return model_->integrality_.data();
+  }
+
+  HighsVarType variableType(HighsInt col) const {
+    return model_->integrality_[col];
+  }
+
+  bool isColIntegral(const HighsInt col) const {
+    return variableType(col) != HighsVarType::kContinuous;
+  }
+
+  bool isColInteger(const HighsInt col) const {
+    return variableType(col) == HighsVarType::kInteger;
+  }
+
+  bool isColContinuous(const HighsInt col) const {
+    return variableType(col) == HighsVarType::kContinuous;
+  }
+
+  HighsMipSolver(HighsCallback& callback, const HighsOptions& options,
+                 const HighsLp& lp, const HighsSolution& solution,
+                 bool submip = false, HighsInt submip_level = 0);
+
+  ~HighsMipSolver();
+
+  void setModel(const HighsLp& model) {
+    model_ = &model;
+    solution_objective_ = kHighsInf;
+  }
+
+  mutable HighsTimer timer_;
+  mutable HighsSubSolverCallTime sub_solver_call_time_;
+
+  void cleanupSolve();
+
+  void runMipPresolve(const HighsInt presolve_reduction_limit);
+  const HighsLp& getPresolvedModel() const;
+  HighsPresolveStatus getPresolveStatus() const;
+  presolve::HighsPostsolveStack getPostsolveStack() const;
+
+  void callbackGetCutPool() const;
+  bool solutionFeasible(const HighsLp* lp, const std::vector<double>& col_value,
+                        const std::vector<double>* pass_row_value,
+                        double& bound_violation, double& row_violation,
+                        double& integrality_violation, HighsCDouble& obj) const;
+
+  std::vector<HighsModelStatus> initialiseTerminatorRecord(
+      HighsInt num_instance) const;
+  void initialiseTerminator(HighsInt num_instance_ = 0,
+                            HighsInt my_instance_ = kNoThreadInstance,
+                            HighsModelStatus* record_ = nullptr);
+  void initialiseTerminator(const HighsMipSolver& mip_solver);
+  bool terminate() const {
+    return this->termination_status_ != HighsModelStatus::kNotset;
+  }
+  HighsModelStatus terminationStatus() const {
+    return this->termination_status_;
+  }
+};
+
+std::array<char, 128> getGapString(const double gap_,
+                                   const double primal_bound_,
+                                   const HighsOptions* options_mip_);
+#endif

data/ext/lpsolver-highs/build/include/highs/mip/HighsMipSolverData.h

@@ -0,0 +1,313 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#ifndef HIGHS_MIP_SOLVER_DATA_H_
+#define HIGHS_MIP_SOLVER_DATA_H_
+
+#include <vector>
+
+#include "mip/HighsCliqueTable.h"
+#include "mip/HighsConflictPool.h"
+#include "mip/HighsCutPool.h"
+#include "mip/HighsDebugSol.h"
+#include "mip/HighsDomain.h"
+#include "mip/HighsImplications.h"
+#include "mip/HighsLpRelaxation.h"
+#include "mip/HighsNodeQueue.h"
+#include "mip/HighsObjectiveFunction.h"
+#include "mip/HighsPrimalHeuristics.h"
+#include "mip/HighsPseudocost.h"
+#include "mip/HighsRedcostFixing.h"
+#include "mip/HighsSearch.h"
+#include "mip/HighsSeparation.h"
+#include "parallel/HighsParallel.h"
+#include "presolve/HighsPostsolveStack.h"
+#include "presolve/HighsSymmetry.h"
+#include "util/HighsTimer.h"
+
+struct HighsPrimaDualIntegral {
+  double value;
+  double prev_lb;
+  double prev_ub;
+  double prev_gap;
+  double prev_time;
+  void initialise();
+};
+
+enum MipSolutionSource : int {
+  kSolutionSourceNone = -1,
+  kSolutionSourceMin = kSolutionSourceNone,
+  //  kSolutionSourceInitial, // 0
+  kSolutionSourceBranching,           // B
+  kSolutionSourceCentralRounding,     // C
+  kSolutionSourceFeasibilityPump,     // F
+  kSolutionSourceHeuristic,           // H
+  kSolutionSourceShifting,            // I
+  kSolutionSourceFeasibilityJump,     // J
+  kSolutionSourceSubMip,              // L
+  kSolutionSourceEmptyMip,            // P
+  kSolutionSourceRandomizedRounding,  // R
+  kSolutionSourceSolveLp,             // S
+  kSolutionSourceEvaluateNode,        // T
+  kSolutionSourceUnbounded,           // U
+  kSolutionSourceUserSolution,        // X
+  kSolutionSourceHighsSolution,       // Y
+  kSolutionSourceZiRound,             // Z
+  kSolutionSourceTrivialL,            // l
+  kSolutionSourceTrivialP,            // p
+  kSolutionSourceTrivialU,            // u
+  kSolutionSourceTrivialZ,            // z
+  kSolutionSourceCleanup,
+  kSolutionSourceCount
+};
+
+struct HighsMipSolverData {
+  HighsMipSolver& mipsolver;
+  HighsCutPool cutpool;
+  HighsConflictPool conflictPool;
+  HighsDomain domain;
+  HighsLpRelaxation lp;
+  HighsPseudocost pseudocost;
+  HighsCliqueTable cliquetable;
+  HighsImplications implications;
+  HighsPrimalHeuristics heuristics;
+  HighsRedcostFixing redcostfixing;
+  HighsObjectiveFunction objectiveFunction;
+  presolve::HighsPostsolveStack postSolveStack;
+  HighsPresolveStatus presolve_status;
+  HighsLp presolvedModel;
+  bool cliquesExtracted;
+  bool rowMatrixSet;
+  bool analyticCenterComputed;
+  HighsModelStatus analyticCenterStatus;
+  bool detectSymmetries;
+  HighsInt numRestarts;
+  HighsInt numRestartsRoot;
+  HighsInt numCliqueEntriesAfterPresolve;
+  HighsInt numCliqueEntriesAfterFirstPresolve;
+
+  std::vector<HighsInt> ARstart_;
+  std::vector<HighsInt> ARindex_;
+  std::vector<double> ARvalue_;
+  std::vector<double> maxAbsRowCoef;
+  std::vector<uint8_t> rowintegral;
+  std::vector<HighsInt> uplocks;
+  std::vector<HighsInt> downlocks;
+  std::vector<HighsInt> integer_cols;
+  std::vector<HighsInt> implint_cols;
+  std::vector<HighsInt> integral_cols;
+  std::vector<HighsInt> continuous_cols;
+
+  HighsSymmetries symmetries;
+  std::shared_ptr<const StabilizerOrbits> globalOrbits;
+
+  double feastol;
+  double epsilon;
+  double heuristic_effort;
+  int64_t dispfreq;
+  std::vector<double> analyticCenter;
+  std::vector<double> firstlpsol;
+  std::vector<double> rootlpsol;
+  double firstlpsolobj;
+  HighsBasis firstrootbasis;
+  double rootlpsolobj;
+  HighsInt numintegercols;
+  HighsInt maxTreeSizeLog2;
+
+  HighsCDouble pruned_treeweight;
+  double avgrootlpiters;
+  double disptime;
+  double last_disptime;
+  int64_t firstrootlpiters;
+  int64_t num_nodes;
+  int64_t num_leaves;
+  int64_t num_leaves_before_run;
+  int64_t num_nodes_before_run;
+  int64_t total_repair_lp;
+  int64_t total_repair_lp_feasible;
+  int64_t total_repair_lp_iterations;
+  int64_t total_lp_iterations;
+  int64_t heuristic_lp_iterations;
+  int64_t sepa_lp_iterations;
+  int64_t sb_lp_iterations;
+  int64_t total_lp_iterations_before_run;
+  int64_t heuristic_lp_iterations_before_run;
+  int64_t sepa_lp_iterations_before_run;
+  int64_t sb_lp_iterations_before_run;
+  int64_t num_disp_lines;
+
+  HighsInt numImprovingSols;
+  double lower_bound;
+  double upper_bound;
+  double upper_limit;
+  double optimality_limit;
+  std::vector<double> incumbent;
+
+  HighsNodeQueue nodequeue;
+
+  HighsPrimaDualIntegral primal_dual_integral;
+
+  HighsDebugSol debugSolution;
+
+  HighsMipSolverData(HighsMipSolver& mipsolver)
+      : mipsolver(mipsolver),
+        cutpool(mipsolver.numCol(), mipsolver.options_mip_->mip_pool_age_limit,
+                mipsolver.options_mip_->mip_pool_soft_limit),
+        conflictPool(5 * mipsolver.options_mip_->mip_pool_age_limit,
+                     mipsolver.options_mip_->mip_pool_soft_limit),
+        domain(mipsolver),
+        lp(mipsolver),
+        pseudocost(),
+        cliquetable(mipsolver.numCol()),
+        implications(mipsolver),
+        heuristics(mipsolver),
+        objectiveFunction(mipsolver),
+        presolve_status(HighsPresolveStatus::kNotSet),
+        cliquesExtracted(false),
+        rowMatrixSet(false),
+        analyticCenterComputed(false),
+        analyticCenterStatus(HighsModelStatus::kNotset),
+        detectSymmetries(false),
+        numRestarts(0),
+        numRestartsRoot(0),
+        numCliqueEntriesAfterPresolve(0),
+        numCliqueEntriesAfterFirstPresolve(0),
+        feastol(0.0),
+        epsilon(0.0),
+        heuristic_effort(0.0),
+        dispfreq(0),
+        firstlpsolobj(-kHighsInf),
+        rootlpsolobj(-kHighsInf),
+        numintegercols(0),
+        maxTreeSizeLog2(0),
+        pruned_treeweight(0),
+        avgrootlpiters(0.0),
+        disptime(0.0),
+        last_disptime(0.0),
+        firstrootlpiters(0),
+        num_nodes(0),
+        num_leaves(0),
+        num_leaves_before_run(0),
+        num_nodes_before_run(0),
+        total_repair_lp(0),
+        total_repair_lp_feasible(0),
+        total_repair_lp_iterations(0),
+        total_lp_iterations(0),
+        heuristic_lp_iterations(0),
+        sepa_lp_iterations(0),
+        sb_lp_iterations(0),
+        total_lp_iterations_before_run(0),
+        heuristic_lp_iterations_before_run(0),
+        sepa_lp_iterations_before_run(0),
+        sb_lp_iterations_before_run(0),
+        num_disp_lines(0),
+        numImprovingSols(0),
+        lower_bound(-kHighsInf),
+        upper_bound(kHighsInf),
+        upper_limit(kHighsInf),
+        optimality_limit(kHighsInf),
+        debugSolution(mipsolver) {
+    domain.addCutpool(cutpool);
+    domain.addConflictPool(conflictPool);
+  }
+
+  bool solutionRowFeasible(const std::vector<double>& solution) const;
+  HighsModelStatus feasibilityJump();
+  HighsModelStatus trivialHeuristics();
+
+  void startAnalyticCenterComputation(
+      const highs::parallel::TaskGroup& taskGroup);
+  void finishAnalyticCenterComputation(
+      const highs::parallel::TaskGroup& taskGroup);
+
+  struct SymmetryDetectionData {
+    HighsSymmetryDetection symDetection;
+    HighsSymmetries symmetries;
+    double detectionTime = 0.0;
+  };
+
+  void startSymmetryDetection(const highs::parallel::TaskGroup& taskGroup,
+                              std::unique_ptr<SymmetryDetectionData>& symData);
+  void finishSymmetryDetection(const highs::parallel::TaskGroup& taskGroup,
+                               std::unique_ptr<SymmetryDetectionData>& symData);
+
+  void updatePrimalDualIntegral(const double from_lower_bound,
+                                const double to_lower_bound,
+                                const double from_upper_bound,
+                                const double to_upper_bound,
+                                const bool check_bound_change = true,
+                                const bool check_prev_data = true);
+  double limitsToGap(const double use_lower_bound, const double use_upper_bound,
+                     double& lb, double& ub) const;
+
+  double computeNewUpperLimit(double upper_bound, double mip_abs_gap,
+                              double mip_rel_gap) const;
+  bool moreHeuristicsAllowed() const;
+  void removeFixedIndices();
+  void init();
+  void basisTransfer();
+  void checkObjIntegrality();
+  void runMipPresolve(const HighsInt presolve_reduction_limit);
+  void setupDomainPropagation();
+  void saveReportMipSolution(const double new_upper_limit = -kHighsInf);
+  void runSetup();
+  double transformNewIntegerFeasibleSolution(
+      const std::vector<double>& sol,
+      const bool possibly_store_as_new_incumbent = true);
+  double percentageInactiveIntegers() const;
+  void performRestart();
+  bool checkSolution(const std::vector<double>& solution) const;
+  std::vector<std::tuple<HighsInt, HighsInt, double>> getInfeasibleRows(
+      const std::vector<double>& solution) const;
+  bool trySolution(const std::vector<double>& solution,
+                   const int solution_source = kSolutionSourceNone);
+  bool rootSeparationRound(HighsSeparation& sepa, HighsInt& ncuts,
+                           HighsLpRelaxation::Status& status);
+  HighsLpRelaxation::Status evaluateRootLp();
+  void evaluateRootNode();
+  bool addIncumbent(const std::vector<double>& sol, double solobj,
+                    const int solution_source,
+                    const bool print_display_line = true,
+                    const bool is_user_solution = false);
+
+  const std::vector<double>& getSolution() const;
+
+  std::string solutionSourceToString(const int solution_source,
+                                     const bool code = true) const;
+  void printSolutionSourceKey() const;
+  void printDisplayLine(const int solution_source = kSolutionSourceNone);
+
+  void getRow(HighsInt row, HighsInt& rowlen, const HighsInt*& rowinds,
+              const double*& rowvals) const {
+    HighsInt start = ARstart_[row];
+    rowlen = ARstart_[row + 1] - start;
+    rowinds = ARindex_.data() + start;
+    rowvals = ARvalue_.data() + start;
+  }
+
+  bool checkLimits(int64_t nodeOffset = 0) const;
+  void limitsToBounds(double& dual_bound, double& primal_bound,
+                      double& mip_rel_gap) const;
+  void updateLowerBound(double new_lower_bound);
+  void setCallbackDataOut(const double mipsolver_objective_value) const;
+  bool interruptFromCallbackWithData(const int callback_type,
+                                     const double mipsolver_objective_value,
+                                     const std::string message = "") const;
+  void queryExternalSolution(
+      const double mipsolver_objective_value,
+      const ExternalMipSolutionQueryOrigin external_solution_query_origin);
+
+  HighsInt terminatorConcurrency() const;
+  bool terminatorActive() const { return terminatorConcurrency() > 0; }
+  HighsInt terminatorMyInstance() const;
+  void terminatorTerminate();
+  bool terminatorTerminated() const;
+  void terminatorReport() const;
+};
+
+#endif

data/ext/lpsolver-highs/build/include/highs/mip/HighsModkSeparator.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/HighsModkSeparator.h
+ * @brief Class for separating maximally violated mod-k MIR cuts.
+ *
+ * Contrary to mod-k CG cuts as described in the literature, continuous
+ * variables are allowed to appear in the rows used for separation. In case an
+ * LP row is already an integral row it is included into the congruence system
+ * in the same way as for mod-k CG cuts. Should the LP row contain continuous
+ * variables that have a non-zero solution value after bound substitution, then
+ * it is discarded, as it can not participate in a maximally violated mod-K MIR
+ * cut.
+ *
+ * If a row contains continuous variables that sit at zero after bound
+ * substitution, then those rows are included in the congruence system, as the
+ * presence of such variables does not reduce the cuts violation when applying
+ * the MIR procedure. In order to handle their presence the row must simply be
+ * scaled, such that all integer variables that have a non-zero solution value
+ * after bound substitution, as well as the right hand side value, attain an
+ * integral value. If we succeed in finding such a scale that is not too large,
+ * the resulting row might get a non-zero weight in the solution of the
+ * congruence system. The aggregated row therefore can contain continuous
+ * variables. These variables, however, all sit at zero in the current LP
+ * solution. Using the weights from the solution of the congruence system all
+ * integer variables with non-zero solution value will attain a coefficient that
+ * is divisible by k, and the integral right hand side value will have a
+ * remainder of k - 1 when dividing by k. All other variables do not contribute
+ * to the activity of the cut in this LP solution, hence applying the MIR
+ * procedure will yield a cut that is violated by (k-1)/k. However, we prefer to
+ * generate inequalities with superadditive lifting from the aggregated row
+ * whenever all integer variables are bounded.
+ *
+ */
+
+#ifndef MIP_HIGHS_MODK_SEPARATOR_H_
+#define MIP_HIGHS_MODK_SEPARATOR_H_
+
+#include <vector>
+
+#include "mip/HighsSeparator.h"
+
+/// Helper class to compute single-row relaxations from the current LP
+/// relaxation by substituting bounds and aggregating rows
+class HighsModkSeparator : public HighsSeparator {
+ public:
+  void separateLpSolution(HighsLpRelaxation& lpRelaxation,
+                          HighsLpAggregator& lpAggregator,
+                          HighsTransformedLp& transLp,
+                          HighsCutPool& cutpool) override;
+
+  HighsModkSeparator(const HighsMipSolver& mipsolver)
+      : HighsSeparator(mipsolver, kModKSepaString) {}
+};
+
+#endif