casadi 3.6.7__cp37-none-manylinux2014_x86_64.whl → 3.7.1__cp37-none-manylinux2014_x86_64.whl

casadi/include/highs/mip/HighsImplications.h

@@ -2,9 +2,6 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
-/*    Leona Gottwald and Michael Feldmeier                               */
-/*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
@@ -40,8 +37,14 @@ class HighsImplications {
     double coef;
     double constant;
 
-    double minValue() const { return constant + std::min(coef, 0.0); }
-    double maxValue() const { return constant + std::max(coef, 0.0); }
+    double minValue() const {
+      return static_cast<double>(static_cast<HighsCDouble>(constant) +
+                                 std::min(coef, 0.0));
+    }
+    double maxValue() const {
+      return static_cast<double>(static_cast<HighsCDouble>(constant) +
+                                 std::max(coef, 0.0));
+    }
   };
 
  private:
@@ -62,6 +65,9 @@ class HighsImplications {
     numImplications = 0;
   }
 
+  std::function<void(HighsInt, HighsInt, HighsInt, double)>
+      storeLiftingOpportunity;
+
   void reset() {
     colsubstituted.clear();
     colsubstituted.shrink_to_fit();
@@ -109,6 +115,7 @@ class HighsImplications {
               double vlbconstant);
 
   void columnTransformed(HighsInt col, double scale, double constant) {
+    // Update variable bounds affected by transformation
     if (scale < 0) std::swap(vubs[col], vlbs[col]);
 
     auto transformVbd = [&](HighsInt, VarBound& vbd) {
@@ -119,6 +126,15 @@ class HighsImplications {
 
     vlbs[col].for_each(transformVbd);
     vubs[col].for_each(transformVbd);
+
+    // Update substitutions affected by transformation
+    for (auto& substitution : substitutions) {
+      if (substitution.substcol == col) {
+        substitution.offset -= constant;
+        substitution.offset /= scale;
+        substitution.scale /= scale;
+      }
+    }
   }
 
   std::pair<HighsInt, VarBound> getBestVub(HighsInt col,
@@ -141,6 +157,14 @@ class HighsImplications {
                              HighsCutPool& cutpool, double feastol);
 
   void cleanupVarbounds(HighsInt col);
+
+  void cleanupVlb(HighsInt col, HighsInt vlbCol,
+                  HighsImplications::VarBound& vlb, double lb, bool& redundant,
+                  bool& infeasible, bool allowBoundChanges = true) const;
+
+  void cleanupVub(HighsInt col, HighsInt vubCol,
+                  HighsImplications::VarBound& vub, double ub, bool& redundant,
+                  bool& infeasible, bool allowBoundChanges = true) const;
 };
 
 #endif

casadi/include/highs/mip/HighsLpAggregator.h

@@ -2,9 +2,6 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
-/*    Leona Gottwald and Michael Feldmeier                               */
-/*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

casadi/include/highs/mip/HighsLpRelaxation.h

@@ -2,9 +2,6 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
-/*    Leona Gottwald and Michael Feldmeier                               */
-/*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

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

@@ -2,9 +2,6 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
-/*    Leona Gottwald and Michael Feldmeier                               */
-/*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
@@ -14,6 +11,7 @@
 #include "Highs.h"
 #include "lp_data/HighsCallback.h"
 #include "lp_data/HighsOptions.h"
+#include "mip/HighsMipAnalysis.h"
 
 struct HighsMipSolverData;
 class HighsCutPool;
@@ -40,11 +38,14 @@ class HighsMipSolver {
   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;
@@ -52,6 +53,8 @@ class HighsMipSolver {
 
   std::unique_ptr<HighsMipSolverData> mipdata_;
 
+  HighsMipAnalysis analysis_;
+
   void run();
 
   HighsInt numCol() const { return model_->num_col_; }
@@ -82,7 +85,7 @@ class HighsMipSolver {
 
   HighsMipSolver(HighsCallback& callback, const HighsOptions& options,
                  const HighsLp& lp, const HighsSolution& solution,
-                 bool submip = false);
+                 bool submip = false, HighsInt submip_level = 0);
 
   ~HighsMipSolver();
 
@@ -100,6 +103,10 @@ class HighsMipSolver {
   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

casadi/include/highs/mip/HighsMipSolverData.h

@@ -2,9 +2,6 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
-/*    Leona Gottwald and Michael Feldmeier                               */
-/*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
@@ -33,6 +30,38 @@
 #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,
+  kSolutionSourceBranching,
+  kSolutionSourceCentralRounding,
+  kSolutionSourceFeasibilityPump,
+  kSolutionSourceHeuristic,
+  //  kSolutionSourceInitial,
+  kSolutionSourceSubMip,
+  kSolutionSourceEmptyMip,
+  kSolutionSourceRandomizedRounding,
+  kSolutionSourceSolveLp,
+  kSolutionSourceEvaluateNode,
+  kSolutionSourceUnbounded,
+  kSolutionSourceTrivialZ,
+  kSolutionSourceTrivialL,
+  kSolutionSourceTrivialU,
+  kSolutionSourceTrivialP,
+  kSolutionSourceUserSolution,
+  kSolutionSourceCleanup,
+  kSolutionSourceCount
+};
+
 struct HighsMipSolverData {
   HighsMipSolver& mipsolver;
   HighsCutPool cutpool;
@@ -88,12 +117,16 @@ struct HighsMipSolverData {
 
   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;
@@ -113,6 +146,8 @@ struct HighsMipSolverData {
 
   HighsNodeQueue nodequeue;
 
+  HighsPrimaDualIntegral primal_dual_integral;
+
   HighsDebugSol debugSolution;
 
   HighsMipSolverData(HighsMipSolver& mipsolver)
@@ -148,12 +183,16 @@ struct HighsMipSolverData {
         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),
@@ -173,6 +212,9 @@ struct HighsMipSolverData {
     domain.addConflictPool(conflictPool);
   }
 
+  bool solutionRowFeasible(const std::vector<double>& solution) const;
+  HighsModelStatus trivialHeuristics();
+
   void startAnalyticCenterComputation(
       const highs::parallel::TaskGroup& taskGroup);
   void finishAnalyticCenterComputation(
@@ -189,6 +231,15 @@ struct HighsMipSolverData {
   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;
@@ -206,16 +257,23 @@ struct HighsMipSolverData {
   double percentageInactiveIntegers() const;
   void performRestart();
   bool checkSolution(const std::vector<double>& solution) const;
-  bool trySolution(const std::vector<double>& solution, char source = ' ');
+  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, char source);
+  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;
 
-  void printDisplayLine(char first = ' ');
+  std::string solutionSourceToString(const int solution_source,
+                                     const bool code = true);
+  void printSolutionSourceKey();
+  void printDisplayLine(const int solution_source = kSolutionSourceNone);
 
   void getRow(HighsInt row, HighsInt& rowlen, const HighsInt*& rowinds,
               const double*& rowvals) const {
@@ -228,9 +286,12 @@ struct HighsMipSolverData {
   bool checkLimits(int64_t nodeOffset = 0) const;
   void limitsToBounds(double& dual_bound, double& primal_bound,
                       double& mip_rel_gap) const;
+  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 callbackUserSolution(const double mipsolver_objective_value,
+                            const HighsInt user_solution_callback_origin);
 };
 
 #endif

casadi/include/highs/mip/HighsModkSeparator.h

@@ -2,9 +2,6 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
-/*    Leona Gottwald and Michael Feldmeier                               */
-/*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
@@ -57,7 +54,7 @@ class HighsModkSeparator : public HighsSeparator {
                           HighsCutPool& cutpool) override;
 
   HighsModkSeparator(const HighsMipSolver& mipsolver)
-      : HighsSeparator(mipsolver, "Mod-k sepa", "Mod") {}
+      : HighsSeparator(mipsolver, "Mod-k sepa") {}
 };
 
 #endif

casadi/include/highs/mip/HighsNodeQueue.h

@@ -2,9 +2,6 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
-/*    Leona Gottwald and Michael Feldmeier                               */
-/*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

casadi/include/highs/mip/HighsObjectiveFunction.h

@@ -2,9 +2,6 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
-/*    Leona Gottwald and Michael Feldmeier                               */
-/*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

casadi/include/highs/mip/HighsPathSeparator.h

@@ -2,9 +2,6 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
-/*    Leona Gottwald and Michael Feldmeier                               */
-/*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
@@ -34,7 +31,7 @@ class HighsPathSeparator : public HighsSeparator {
                           HighsCutPool& cutpool) override;
 
   HighsPathSeparator(const HighsMipSolver& mipsolver)
-      : HighsSeparator(mipsolver, "PathAggr sepa", "Agg") {
+      : HighsSeparator(mipsolver, "PathAggr sepa") {
     randgen.initialise(mipsolver.options_mip_->random_seed);
   }
 };

casadi/include/highs/mip/HighsPrimalHeuristics.h

@@ -2,9 +2,6 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
-/*    Leona Gottwald and Michael Feldmeier                               */
-/*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
@@ -22,6 +19,9 @@ class HighsMipSolver;
 class HighsPrimalHeuristics {
  private:
   HighsMipSolver& mipsolver;
+  size_t total_repair_lp;
+  size_t total_repair_lp_feasible;
+  size_t total_repair_lp_iterations;
   size_t lp_iterations;
 
   double successObservations;
@@ -57,10 +57,12 @@ class HighsPrimalHeuristics {
 
   void flushStatistics();
 
-  bool tryRoundedPoint(const std::vector<double>& point, char source);
+  bool tryRoundedPoint(const std::vector<double>& point,
+                       const int solution_source);
 
   bool linesearchRounding(const std::vector<double>& point1,
-                          const std::vector<double>& point2, char source);
+                          const std::vector<double>& point2,
+                          const int solution_source);
 
   void randomizedRounding(const std::vector<double>& relaxationsol);
 };

casadi/include/highs/mip/HighsPseudocost.h

@@ -2,9 +2,6 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
-/*    Leona Gottwald and Michael Feldmeier                               */
-/*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

casadi/include/highs/mip/HighsRedcostFixing.h

@@ -2,9 +2,6 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
-/*    Leona Gottwald and Michael Feldmeier                               */
-/*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

casadi/include/highs/mip/HighsSearch.h

@@ -2,9 +2,6 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
-/*    Leona Gottwald and Michael Feldmeier                               */
-/*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

casadi/include/highs/mip/HighsSeparation.h

@@ -2,9 +2,6 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
-/*    Leona Gottwald and Michael Feldmeier                               */
-/*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

casadi/include/highs/mip/HighsSeparator.h

@@ -2,9 +2,6 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
-/*    Leona Gottwald and Michael Feldmeier                               */
-/*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
@@ -33,8 +30,7 @@ class HighsSeparator {
   int clockIndex;
 
  public:
-  HighsSeparator(const HighsMipSolver& mipsolver, const char* name,
-                 const char* ch3_name);
+  HighsSeparator(const HighsMipSolver& mipsolver, const char* name);
 
   virtual void separateLpSolution(HighsLpRelaxation& lpRelaxation,
                                   HighsLpAggregator& lpAggregator,

casadi/include/highs/mip/HighsTableauSeparator.h

@@ -2,9 +2,6 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
-/*    Leona Gottwald and Michael Feldmeier                               */
-/*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
@@ -31,7 +28,7 @@ class HighsTableauSeparator : public HighsSeparator {
                           HighsCutPool& cutpool) override;
 
   HighsTableauSeparator(const HighsMipSolver& mipsolver)
-      : HighsSeparator(mipsolver, "Tableau sepa", "Tbl"), numTries(0) {}
+      : HighsSeparator(mipsolver, "Tableau sepa"), numTries(0) {}
 };
 
 #endif

casadi/include/highs/mip/HighsTransformedLp.h

@@ -2,9 +2,6 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
-/*    Leona Gottwald and Michael Feldmeier                               */
-/*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */