casadi 3.7.2__cp314-none-manylinux2014_x86_64.whl

casadi/include/highs/mip/HighsLpAggregator.h

@@ -0,0 +1,50 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/**@file mip/HighsLpAggregator.h
+ * @brief Class to aggregate rows of the LP
+ *
+ *
+ */
+
+#ifndef MIP_HIGHS_LP_AGGREGATOR_H_
+#define MIP_HIGHS_LP_AGGREGATOR_H_
+
+#include <cstdint>
+#include <vector>
+
+#include "util/HighsSparseVectorSum.h"
+
+class HighsLpRelaxation;
+
+/// Helper class to compute single-row relaxations from the current LP
+/// relaxation by substituting bounds and aggregating rows
+class HighsLpAggregator {
+ private:
+  const HighsLpRelaxation& lprelaxation;
+
+  HighsSparseVectorSum vectorsum;
+
+ public:
+  HighsLpAggregator(const HighsLpRelaxation& lprelaxation);
+
+  /// add an LP row to the aggregation using the given weight
+  void addRow(HighsInt row, double weight);
+
+  /// returns the current aggregation of LP rows. The aggregation includes slack
+  /// variables so that it is always an equation with right hand side 0.
+  void getCurrentAggregation(std::vector<HighsInt>& inds,
+                             std::vector<double>& vals, bool negate);
+
+  /// clear the current aggregation
+  void clear();
+
+  /// checks whether the current aggregation is empty
+  bool isEmpty() { return vectorsum.nonzeroinds.empty(); }
+};
+
+#endif

casadi/include/highs/mip/HighsLpRelaxation.h

@@ -0,0 +1,357 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+#ifndef HIGHS_LP_RELAXATION_H_
+#define HIGHS_LP_RELAXATION_H_
+
+#include <cstdint>
+#include <memory>
+
+#include "Highs.h"
+#include "mip/HighsMipSolver.h"
+
+class HighsDomain;
+struct HighsCutSet;
+class HighsPseudocost;
+
+class HighsLpRelaxation {
+ public:
+  enum class Status {
+    kNotSet,
+    kOptimal,
+    kInfeasible,
+    kUnscaledDualFeasible,
+    kUnscaledPrimalFeasible,
+    kUnscaledInfeasible,
+    kUnbounded,
+    kError,
+  };
+
+ private:
+  struct LpRow {
+    enum Origin {
+      kModel,
+      kCutPool,
+    };
+
+    Origin origin;
+    HighsInt index;
+    HighsInt age;
+
+    void get(const HighsMipSolver& mipsolver, HighsInt& len,
+             const HighsInt*& inds, const double*& vals) const;
+
+    HighsInt getRowLen(const HighsMipSolver& mipsolver) const;
+
+    bool isIntegral(const HighsMipSolver& mipsolver) const;
+
+    double getMaxAbsVal(const HighsMipSolver& mipsolver) const;
+
+    static LpRow cut(HighsInt index) { return LpRow{kCutPool, index, 0}; }
+    static LpRow model(HighsInt index) { return LpRow{kModel, index, 0}; }
+  };
+
+  const HighsMipSolver& mipsolver;
+  Highs lpsolver;
+
+  std::vector<LpRow> lprows;
+
+  std::vector<std::pair<HighsInt, double>> fractionalints;
+  std::vector<double> dualproofvals;
+  std::vector<HighsInt> dualproofinds;
+  std::vector<double> dualproofbuffer;
+  std::vector<double> colLbBuffer;
+  std::vector<double> colUbBuffer;
+  HVector row_ep;
+  HighsSparseVectorSum row_ap;
+  double dualproofrhs;
+  bool hasdualproof;
+  double objective;
+  std::shared_ptr<const HighsBasis> basischeckpoint;
+  bool currentbasisstored;
+  int64_t numlpiters;
+  int64_t lastAgeCall;
+  double avgSolveIters;
+  int64_t numSolved;
+  size_t epochs;
+  HighsInt maxNumFractional;
+  Status status;
+  bool adjustSymBranchingCol;
+
+  void storeDualInfProof();
+
+  void storeDualUBProof();
+
+  bool checkDualProof() const;
+
+ public:
+  HighsLpRelaxation(const HighsMipSolver& mip);
+
+  HighsLpRelaxation(const HighsLpRelaxation& other);
+
+  void getCutPool(HighsInt& num_col, HighsInt& num_cut,
+                  std::vector<double>& cut_lower,
+                  std::vector<double>& cut_upper,
+                  HighsSparseMatrix& cut_matrix) const;
+
+  class Playground {
+    friend class HighsLpRelaxation;
+    HighsLpRelaxation* lp;
+    bool iterateStored;
+
+    Playground(HighsLpRelaxation* lp) : lp(lp), iterateStored(false) {}
+
+   public:
+    Playground(Playground&& other)
+        : lp(other.lp), iterateStored(other.iterateStored) {
+      other.iterateStored = false;
+    }
+
+    Playground& operator=(Playground&& other) {
+      std::swap(lp, other.lp);
+      std::swap(iterateStored, other.iterateStored);
+      return *this;
+    }
+
+    HighsLpRelaxation::Status solveLp(HighsDomain& localdom) {
+      if (iterateStored) {
+        lp->flushDomain(localdom);
+        lp->getLpSolver().getIterate();
+      } else {
+        assert(lp->getLpSolver().getInfo().valid);
+        lp->getLpSolver().putIterate();
+        lp->flushDomain(localdom);
+        iterateStored = true;
+      }
+
+      return lp->run(false);
+    }
+
+    Playground(const Playground& other) = delete;
+    Playground& operator=(const Playground& other) = delete;
+
+    ~Playground() {
+      if (iterateStored) {
+        lp->getLpSolver().getIterate();
+        lp->run();
+        // If desired, here is the place to clear the stored iterate
+      }
+    }
+  };
+
+  Playground playground() { return Playground(this); }
+
+  void loadModel();
+
+  void getRow(HighsInt row, HighsInt& len, const HighsInt*& inds,
+              const double*& vals) const {
+    if (row < mipsolver.numRow())
+      assert(lprows[row].origin == LpRow::Origin::kModel);
+    else
+      assert(lprows[row].origin == LpRow::Origin::kCutPool);
+    lprows[row].get(mipsolver, len, inds, vals);
+  }
+
+  bool isRowIntegral(HighsInt row) const {
+    assert(row < (HighsInt)lprows.size());
+    return lprows[row].isIntegral(mipsolver);
+  }
+
+  void setAdjustSymmetricBranchingCol(bool adjustSymBranchingCol) {
+    this->adjustSymBranchingCol = adjustSymBranchingCol;
+  }
+
+  void resetToGlobalDomain();
+
+  void computeBasicDegenerateDuals(double threshold,
+                                   HighsDomain* localdom = nullptr);
+
+  double getAvgSolveIters() { return avgSolveIters; }
+
+  HighsInt getRowLen(HighsInt row) const {
+    return lprows[row].getRowLen(mipsolver);
+  }
+
+  double getMaxAbsRowVal(HighsInt row) const {
+    return lprows[row].getMaxAbsVal(mipsolver);
+  }
+
+  const HighsLp& getLp() const { return lpsolver.getLp(); }
+
+  const HighsSolution& getSolution() const { return lpsolver.getSolution(); }
+
+  double slackUpper(HighsInt row) const;
+
+  double slackLower(HighsInt row) const;
+
+  double rowLower(HighsInt row) const {
+    return lpsolver.getLp().row_lower_[row];
+  }
+
+  double rowUpper(HighsInt row) const {
+    return lpsolver.getLp().row_upper_[row];
+  }
+
+  double colLower(HighsInt col) const {
+    return col < lpsolver.getLp().num_col_
+               ? lpsolver.getLp().col_lower_[col]
+               : slackLower(col - lpsolver.getLp().num_col_);
+  }
+
+  double colUpper(HighsInt col) const {
+    return col < lpsolver.getLp().num_col_
+               ? lpsolver.getLp().col_upper_[col]
+               : slackUpper(col - lpsolver.getLp().num_col_);
+  }
+
+  bool isColIntegral(HighsInt col) const {
+    return col < lpsolver.getLp().num_col_
+               ? mipsolver.variableType(col) != HighsVarType::kContinuous
+               : isRowIntegral(col - lpsolver.getLp().num_col_);
+  }
+
+  double solutionValue(HighsInt col) const {
+    return col < lpsolver.getLp().num_col_
+               ? getSolution().col_value[col]
+               : getSolution().row_value[col - lpsolver.getLp().num_col_];
+  }
+
+  Status getStatus() const { return status; }
+
+  const HighsInfo& getSolverInfo() const { return lpsolver.getInfo(); }
+
+  int64_t getNumLpIterations() const { return numlpiters; }
+
+  bool integerFeasible() const {
+    if ((status == Status::kOptimal ||
+         status == Status::kUnscaledPrimalFeasible) &&
+        fractionalints.empty())
+      return true;
+
+    return false;
+  }
+
+  double computeBestEstimate(const HighsPseudocost& ps) const;
+
+  double computeLPDegneracy(const HighsDomain& localdomain) const;
+
+  static bool scaledOptimal(Status status) {
+    switch (status) {
+      case Status::kOptimal:
+      case Status::kUnscaledDualFeasible:
+      case Status::kUnscaledPrimalFeasible:
+      case Status::kUnscaledInfeasible:
+        return true;
+      default:
+        return false;
+    }
+  }
+
+  static bool unscaledPrimalFeasible(Status status) {
+    switch (status) {
+      case Status::kOptimal:
+      case Status::kUnscaledPrimalFeasible:
+        return true;
+      default:
+        return false;
+    }
+  }
+
+  static bool unscaledDualFeasible(Status status) {
+    switch (status) {
+      case Status::kOptimal:
+      case Status::kUnscaledDualFeasible:
+        return true;
+      default:
+        return false;
+    }
+  }
+
+  void recoverBasis();
+
+  void setObjectiveLimit(double objlim = kHighsInf);
+
+  void storeBasis() {
+    if (!currentbasisstored && lpsolver.getBasis().valid) {
+      basischeckpoint = std::make_shared<HighsBasis>(lpsolver.getBasis());
+      currentbasisstored = true;
+    }
+  }
+
+  std::shared_ptr<const HighsBasis> getStoredBasis() const {
+    return basischeckpoint;
+  }
+
+  void setStoredBasis(std::shared_ptr<const HighsBasis> basis) {
+    basischeckpoint = std::move(basis);
+    currentbasisstored = false;
+  }
+
+  const HighsMipSolver& getMipSolver() const { return mipsolver; }
+
+  HighsInt getNumModelRows() const { return mipsolver.numRow(); }
+
+  HighsInt numRows() const { return lpsolver.getNumRow(); }
+
+  HighsInt numCols() const { return lpsolver.getNumCol(); }
+
+  HighsInt numNonzeros() const { return lpsolver.getNumNz(); }
+
+  void addCuts(HighsCutSet& cutset);
+
+  void performAging(bool deleteRows = false);
+
+  void resetAges();
+
+  void removeObsoleteRows(bool notifyPool = true);
+
+  void removeCuts(HighsInt ndelcuts, std::vector<HighsInt>& deletemask);
+
+  void removeCuts();
+
+  void flushDomain(HighsDomain& domain, bool continuous = false);
+
+  void getDualProof(const HighsInt*& inds, const double*& vals, double& rhs,
+                    HighsInt& len) {
+    inds = dualproofinds.data();
+    vals = dualproofvals.data();
+    rhs = dualproofrhs;
+    len = dualproofinds.size();
+  }
+
+  bool computeDualProof(const HighsDomain& globaldomain, double upperbound,
+                        std::vector<HighsInt>& inds, std::vector<double>& vals,
+                        double& rhs, bool extractCliques = true) const;
+
+  bool computeDualInfProof(const HighsDomain& globaldomain,
+                           std::vector<HighsInt>& inds,
+                           std::vector<double>& vals, double& rhs);
+
+  Status resolveLp(HighsDomain* domain = nullptr);
+
+  Status run(bool resolve_on_error = true);
+
+  Highs& getLpSolver() { return lpsolver; }
+  const Highs& getLpSolver() const { return lpsolver; }
+
+  const std::vector<std::pair<HighsInt, double>>& getFractionalIntegers()
+      const {
+    return fractionalints;
+  }
+
+  std::vector<std::pair<HighsInt, double>>& getFractionalIntegers() {
+    return fractionalints;
+  }
+
+  double getObjective() const { return objective; }
+
+  void setIterationLimit(HighsInt limit = kHighsIInf) {
+    lpsolver.setOptionValue("simplex_iteration_limit", limit);
+  }
+};
+
+#endif

casadi/include/highs/mip/HighsMipAnalysis.h

@@ -0,0 +1,52 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/**@file mip/HighsMipAnalysis.h
+ * @brief Analyse MIP iterations, both for run-time control and data
+ * gathering
+ */
+#ifndef MIP_HIGHSMIPANALYSIS_H_
+#define MIP_HIGHSMIPANALYSIS_H_
+
+#include "lp_data/HighsAnalysis.h"
+#include "lp_data/HighsLp.h"
+#include "util/HighsTimer.h"
+
+class HighsMipAnalysis {
+ public:
+  HighsMipAnalysis() : timer_(nullptr), analyse_mip_time(false) {}
+
+  HighsTimer* timer_;
+  void setup(const HighsLp& lp, const HighsOptions& options);
+
+  void setupMipTime(const HighsOptions& options);
+  void mipTimerStart(const HighsInt mip_clock = 0
+                     //		     , const HighsInt thread_id = 0
+  ) const;
+  void mipTimerStop(const HighsInt mip_clock = 0
+                    //		    , const HighsInt thread_id = 0
+  ) const;
+  bool mipTimerRunning(const HighsInt mip_clock = 0
+                       //		    , const HighsInt thread_id = 0
+  ) const;
+  double mipTimerRead(const HighsInt mip_clock = 0
+                      //		    , const HighsInt thread_id = 0
+  ) const;
+  HighsInt mipTimerNumCall(const HighsInt mip_clock = 0
+                           // , const HighsInt thread_id
+  ) const;
+  void reportMipSolveLpClock(const bool header);
+  void reportMipTimer();
+
+  std::string model_name;
+  HighsTimerClock mip_clocks;
+  bool analyse_mip_time;
+  std::vector<double> dive_time;
+  std::vector<double> node_search_time;
+};
+
+#endif /* MIP_HIGHSMIPANALYSIS_H_ */

casadi/include/highs/mip/HighsMipSolver.h

@@ -0,0 +1,112 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    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;
+
+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_;
+
+  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];
+  }
+
+  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_;
+  void cleanupSolve();
+
+  void runPresolve(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);
+};
+
+#endif