casadi 3.6.3__cp311-none-manylinux2014_i686.whl → 3.6.4__cp311-none-manylinux2014_i686.whl

casadi/include/highs/lp_data/HighsRuntimeOptions.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
 #ifndef LP_DATA_HIGHSRUNTIMEOPTIONS_H_
@@ -75,7 +73,9 @@ bool loadOptions(const HighsLogOptions& report_log_options, int argc,
          cxxopts::value<HighsInt>())
         // ranging option
         (kRangingString, "Compute cost, bound, RHS and basic solution ranging.",
-         cxxopts::value<std::string>())("h, help", "Print help.");
+         cxxopts::value<std::string>())
+        // version
+        (kVersionString, "Print version.")("h, help", "Print help.");
 
     // Handle command line file specifications
     //
@@ -88,6 +88,13 @@ bool loadOptions(const HighsLogOptions& report_log_options, int argc,
       std::cout << cxx_options.help({""}) << std::endl;
       exit(0);
     }
+    if (result.count("version")) {
+      std::cout << "HiGHS version " << HIGHS_VERSION_MAJOR << "."
+                << HIGHS_VERSION_MINOR << "." << HIGHS_VERSION_PATCH;
+      std::cout << " Githash " << HIGHS_GITHASH << ". ";
+      std::cout << kHighsCopyrightStatement << std::endl;
+      exit(0);
+    }
     if (result.count(kModelFileString)) {
       auto& v = result[kModelFileString].as<std::vector<std::string>>();
       if (v.size() > 1) {
@@ -134,7 +141,15 @@ bool loadOptions(const HighsLogOptions& report_log_options, int argc,
         std::cout << "Multiple options files not implemented.\n";
         return false;
       }
-      if (!loadOptionsFromFile(report_log_options, options, v[0])) return false;
+      switch (loadOptionsFromFile(report_log_options, options, v[0])) {
+        case HighsLoadOptionsStatus::kError:
+          return false;
+        case HighsLoadOptionsStatus::kEmpty:
+          writeOptionsToFile(stdout, options.records);
+          return false;
+        default:
+          break;
+      }
     }
 
     // Handle command line option specifications

casadi/include/highs/lp_data/HighsSolution.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 /**@file lp_data/HighsSolution.h
  * @brief Class-independent utilities for HiGHS
@@ -117,6 +115,8 @@ HighsStatus ipxBasicSolutionToHighsBasicSolution(
     const IpxSolution& ipx_solution, HighsBasis& highs_basis,
     HighsSolution& highs_solution);
 
+HighsStatus formSimplexLpBasisAndFactorReturn(
+    const HighsStatus return_status, HighsLpSolverObject& solver_object);
 HighsStatus formSimplexLpBasisAndFactor(
     HighsLpSolverObject& solver_object,
     const bool only_from_known_basis = false);

casadi/include/highs/lp_data/HighsSolutionDebug.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 /**@file lp_data/HighsSolutionDebug.h
  * @brief

casadi/include/highs/lp_data/HighsSolve.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 /**@file lp_data/HighsSolve.h
  * @brief Class-independent utilities for HiGHS

casadi/include/highs/lp_data/HighsStatus.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 #ifndef LP_DATA_HIGHS_STATUS_H_
 #define LP_DATA_HIGHS_STATUS_H_

casadi/include/highs/mip/HighsCliqueTable.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 #ifndef HIGHS_CLIQUE_TABLE_H_
 #define HIGHS_CLIQUE_TABLE_H_
@@ -109,7 +107,7 @@ class HighsCliqueTable {
                               CliqueVar v2) const;
 
   HighsInt findCommonCliqueId(CliqueVar v1, CliqueVar v2) {
-    return findCommonCliqueId(numNeighborhoodQueries, v1, v2);
+    return findCommonCliqueId(numNeighbourhoodQueries, v1, v2);
   }
 
   HighsInt runCliqueSubsumption(const HighsDomain& globaldom,
@@ -120,7 +118,7 @@ class HighsCliqueTable {
     std::vector<CliqueVar> R;
     std::vector<CliqueVar> Z;
     std::vector<std::vector<CliqueVar>> cliques;
-    std::vector<HighsInt> neighborhoodInds;
+    std::vector<HighsInt> neighbourhoodInds;
 
     double wR = 0.0;
     double minW = 1.05;
@@ -128,12 +126,12 @@ class HighsCliqueTable {
     HighsInt ncalls = 0;
     HighsInt maxcalls = 10000;
     HighsInt maxcliques = 100;
-    int64_t maxNeighborhoodQueries = std::numeric_limits<int64_t>::max();
-    int64_t numNeighborhoodQueries = 0;
+    int64_t maxNeighbourhoodQueries = std::numeric_limits<int64_t>::max();
+    int64_t numNeighbourhoodQueries = 0;
 
     bool stop() const {
       return maxcalls == ncalls || int(cliques.size()) == maxcliques ||
-             numNeighborhoodQueries > maxNeighborhoodQueries;
+             numNeighbourhoodQueries > maxNeighbourhoodQueries;
     }
 
     BronKerboschData(const std::vector<double>& sol) : sol(sol) {}
@@ -152,12 +150,12 @@ class HighsCliqueTable {
 
   void propagateAndCleanup(HighsDomain& globaldom);
 
-  void queryNeighborhood(std::vector<HighsInt>& neighborhoodInds,
-                         int64_t& numNeighborhoodqueries, CliqueVar v,
-                         CliqueVar* q, HighsInt N) const;
+  void queryNeighbourhood(std::vector<HighsInt>& neighbourhoodInds,
+                          int64_t& numNeighbourhoodqueries, CliqueVar v,
+                          CliqueVar* q, HighsInt N) const;
 
  public:
-  int64_t numNeighborhoodQueries;
+  int64_t numNeighbourhoodQueries;
 
   HighsCliqueTable(HighsInt ncols) {
     invertedHashList.resize(2 * ncols);
@@ -166,7 +164,7 @@ class HighsCliqueTable {
     colsubstituted.resize(ncols);
     colDeleted.resize(ncols, false);
     nfixings = 0;
-    numNeighborhoodQueries = 0;
+    numNeighbourhoodQueries = 0;
     numEntries = 0;
     maxEntries = kHighsIInf;
     minEntriesForParallelism = kHighsIInf;
@@ -179,13 +177,13 @@ class HighsCliqueTable {
 
   HighsInt getNumEntries() const { return numEntries; }
 
-  HighsInt partitionNeighborhood(std::vector<HighsInt>& neighborhoodInds,
-                                 int64_t& numNeighborhoodqueries, CliqueVar v,
-                                 CliqueVar* q, HighsInt N) const;
+  HighsInt partitionNeighbourhood(std::vector<HighsInt>& neighbourhoodInds,
+                                  int64_t& numNeighbourhoodqueries, CliqueVar v,
+                                  CliqueVar* q, HighsInt N) const;
 
-  HighsInt shrinkToNeighborhood(std::vector<HighsInt>& neighborhoodInds,
-                                int64_t& numNeighborhoodqueries, CliqueVar v,
-                                CliqueVar* q, HighsInt N);
+  HighsInt shrinkToNeighbourhood(std::vector<HighsInt>& neighbourhoodInds,
+                                 int64_t& numNeighbourhoodqueries, CliqueVar v,
+                                 CliqueVar* q, HighsInt N);
 
   bool processNewEdge(HighsDomain& globaldom, CliqueVar v1, CliqueVar v2);
 

casadi/include/highs/mip/HighsConflictPool.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 #ifndef HIGHS_CONFLICTPOOL_H_
 #define HIGHS_CONFLICTPOOL_H_

casadi/include/highs/mip/HighsCutGeneration.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 /**@file mip/HighsCutGeneration.h
  * @brief Class that generates cuts from single row relaxations

casadi/include/highs/mip/HighsCutPool.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 #ifndef HIGHS_CUTPOOL_H_
 #define HIGHS_CUTPOOL_H_

casadi/include/highs/mip/HighsDebugSol.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 /**@file mip/HighsDebugSol.h
  * @brief Debug solution for MIP solver

casadi/include/highs/mip/HighsDomain.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 #ifndef HIGHS_DOMAIN_H_
 #define HIGHS_DOMAIN_H_
@@ -480,7 +478,9 @@ class HighsDomain {
   }
 
   void fixCol(HighsInt col, double val, Reason reason = Reason::unspecified()) {
-    assert(infeasible_ == 0);
+    if (kAllowDeveloperAssert) {
+      assert(infeasible_ == 0);
+    }
     if (col_lower_[col] < val) {
       changeBound({val, col, HighsBoundType::kLower}, reason);
       if (infeasible_ == 0) propagate();

casadi/include/highs/mip/HighsDomainChange.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
 #ifndef HIGHS_DOMAIN_CHANGE_H_

casadi/include/highs/mip/HighsDynamicRowMatrix.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 #ifndef HIGHS_DYNAMIC_ROW_MATRIX_H_
 #define HIGHS_DYNAMIC_ROW_MATRIX_H_

casadi/include/highs/mip/HighsGFkSolve.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 /**@file mip/HighsGFkLU.h
  * @brief linear system solve in GF(k) for mod-k cut separation

casadi/include/highs/mip/HighsImplications.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 #ifndef HIGHS_IMPLICATIONS_H_
 #define HIGHS_IMPLICATIONS_H_

casadi/include/highs/mip/HighsLpAggregator.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 /**@file mip/HighsLpAggregator.h
  * @brief Class to aggregate rows of the LP

casadi/include/highs/mip/HighsLpRelaxation.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 #ifndef HIGHS_LP_RELAXATION_H_
 #define HIGHS_LP_RELAXATION_H_

casadi/include/highs/mip/HighsMipSolver.h

@@ -2,18 +2,17 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 #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"
 
 struct HighsMipSolverData;
@@ -24,6 +23,7 @@ class HighsImplications;
 
 class HighsMipSolver {
  public:
+  HighsCallback* callback_;
   const HighsOptions* options_mip_;
   const HighsLp* model_;
   const HighsLp* orig_model_;
@@ -33,10 +33,16 @@ class HighsMipSolver {
   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_;
+
+  FILE* improving_solution_file_;
+  std::vector<HighsObjectiveSolution> saved_objective_and_solution_;
 
   bool submip;
   const HighsBasis* rootbasis;
@@ -74,8 +80,9 @@ class HighsMipSolver {
     return model_->integrality_[col];
   }
 
-  HighsMipSolver(const HighsOptions& options, const HighsLp& lp,
-                 const HighsSolution& solution, bool submip = false);
+  HighsMipSolver(HighsCallback& callback, const HighsOptions& options,
+                 const HighsLp& lp, const HighsSolution& solution,
+                 bool submip = false);
 
   ~HighsMipSolver();
 
@@ -86,6 +93,11 @@ class HighsMipSolver {
 
   mutable HighsTimer timer_;
   void cleanupSolve();
+
+  void runPresolve();
+  const HighsLp& getPresolvedModel() const;
+  HighsPresolveStatus getPresolveStatus() const;
+  presolve::HighsPostsolveStack getPostsolveStack() const;
 };
 
 #endif

casadi/include/highs/mip/HighsMipSolverData.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
 #ifndef HIGHS_MIP_SOLVER_DATA_H_
@@ -48,6 +46,7 @@ struct HighsMipSolverData {
   HighsRedcostFixing redcostfixing;
   HighsObjectiveFunction objectiveFunction;
   presolve::HighsPostsolveStack postSolveStack;
+  HighsPresolveStatus presolve_status;
   HighsLp presolvedModel;
   bool cliquesExtracted;
   bool rowMatrixSet;
@@ -159,6 +158,7 @@ struct HighsMipSolverData {
   void checkObjIntegrality();
   void runPresolve();
   void setupDomainPropagation();
+  void saveReportMipSolution(const double new_upper_limit);
   void runSetup();
   double transformNewIncumbent(const std::vector<double>& sol);
   double percentageInactiveIntegers() const;
@@ -184,6 +184,10 @@ struct HighsMipSolverData {
   }
 
   bool checkLimits(int64_t nodeOffset = 0) const;
+  void limitsToBounds(double& dual_bound, double& primal_bound,
+                      double& mip_rel_gap) const;
+  bool interruptFromCallbackWithData(const int callback_type,
+                                     const std::string message = "") const;
 };
 
 #endif

casadi/include/highs/mip/HighsModkSeparator.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 /**@file mip/HighsModkSeparator.h
  * @brief Class for separating maximally violated mod-k MIR cuts.

casadi/include/highs/mip/HighsNodeQueue.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
 #ifndef HIGHS_NODE_QUEUE_H_
@@ -288,11 +286,7 @@ class HighsNodeQueue {
 
   HighsInt getBestBoundDomchgStackSize() const;
 
-  void clear() {
-    HighsNodeQueue nodequeue;
-    nodequeue.setNumCol(numCol);
-    *this = std::move(nodequeue);
-  }
+  void clear();
 
   int64_t numNodes() const { return nodes.size() - freeslots.size(); }
 

casadi/include/highs/mip/HighsObjectiveFunction.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 #ifndef HIGHS_OBJECTIVE_FUNCTION_H_
 #define HIGHS_OBJECTIVE_FUNCTION_H_

casadi/include/highs/mip/HighsPathSeparator.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 /**@file mip/HighsPathSeparator.h
  * @brief Class for separating cuts from heuristically aggregating rows from the