casadi 3.6.5__cp39-none-win_amd64.whl → 3.6.6__cp39-none-win_amd64.whl

casadi/include/highs/lp_data/HighsRuntimeOptions.h

@@ -2,7 +2,7 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
 /*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
@@ -119,7 +119,7 @@ bool loadOptions(const HighsLogOptions& report_log_options, int argc,
       auto& v = result[kReadSolutionFileString].as<std::vector<std::string>>();
       if (v.size() > 1) {
         HighsInt nonEmpty = 0;
-        for (HighsInt i = 0; i < (HighsInt)v.size(); i++) {
+        for (size_t i = 0; i < v.size(); i++) {
           std::string arg = v[i];
           if (trim(arg).size() > 0) {
             nonEmpty++;

casadi/include/highs/lp_data/HighsSolution.h

@@ -2,7 +2,7 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
 /*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
@@ -85,7 +85,7 @@ void getKktFailures(const HighsOptions& options, const HighsLp& lp,
                     HighsPrimalDualErrors& primal_dual_errors,
                     const bool get_residuals = false);
 
-void getVariableKktFailures(const double primal_feasibility_tolerance,
+bool getVariableKktFailures(const double primal_feasibility_tolerance,
                             const double dual_feasibility_tolerance,
                             const double lower, const double upper,
                             const double value, const double dual,

casadi/include/highs/lp_data/HighsSolutionDebug.h

@@ -2,7 +2,7 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    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/lp_data/HighsSolve.h

@@ -2,7 +2,7 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
 /*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
@@ -21,4 +21,6 @@ HighsStatus solveUnconstrainedLp(const HighsOptions& options, const HighsLp& lp,
                                  HighsModelStatus& model_status,
                                  HighsInfo& highs_info, HighsSolution& solution,
                                  HighsBasis& basis);
+void assessExcessiveBoundCost(const HighsLogOptions log_options,
+                              const HighsModel& model);
 #endif  // LP_DATA_HIGHSSOLVE_H_

casadi/include/highs/lp_data/HighsStatus.h

@@ -2,7 +2,7 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    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/HighsCliqueTable.h

@@ -2,7 +2,7 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
 /*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
@@ -158,9 +158,9 @@ class HighsCliqueTable {
   int64_t numNeighbourhoodQueries;
 
   HighsCliqueTable(HighsInt ncols) {
-    invertedHashList.resize(2 * ncols);
-    invertedHashListSizeTwo.resize(2 * ncols);
-    numcliquesvar.resize(2 * ncols, 0);
+    invertedHashList.resize(2 * static_cast<size_t>(ncols));
+    invertedHashListSizeTwo.resize(2 * static_cast<size_t>(ncols));
+    numcliquesvar.resize(2 * static_cast<size_t>(ncols), 0);
     colsubstituted.resize(ncols);
     colDeleted.resize(ncols, false);
     nfixings = 0;

casadi/include/highs/mip/HighsConflictPool.h

@@ -2,7 +2,7 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    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/HighsCutGeneration.h

@@ -2,7 +2,7 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    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/HighsCutPool.h

@@ -2,7 +2,7 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
 /*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
@@ -136,7 +136,7 @@ class HighsCutPool {
 
   void separateLpCutsAfterRestart(HighsCutSet& cutset);
 
-  bool cutIsIntegral(HighsInt cut) const { return rowintegral[cut]; }
+  bool cutIsIntegral(HighsInt cut) const { return (rowintegral[cut] != 0); }
 
   HighsInt getNumCuts() const {
     return matrix_.getNumRows() - matrix_.getNumDelRows();

casadi/include/highs/mip/HighsDebugSol.h

@@ -2,7 +2,7 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
 /*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
@@ -88,54 +88,47 @@ struct HighsDebugSol {
 
 #else
 struct HighsDebugSol {
-  HighsDebugSol(HighsMipSolver& mipsolver) {}
+  HighsDebugSol(HighsMipSolver&) {}
 
   void newIncumbentFound() const {}
 
   void activate() const {}
 
-  void shrink(const std::vector<HighsInt>& newColIndex) const {}
+  void shrink(const std::vector<HighsInt>&) const {}
 
-  void registerDomain(const HighsDomain& domain) const {}
+  void registerDomain(const HighsDomain&) const {}
 
-  void boundChangeAdded(const HighsDomain& domain,
-                        const HighsDomainChange& domchg,
-                        bool branching = false) const {}
+  void boundChangeAdded(const HighsDomain&, const HighsDomainChange&,
+                        bool = false) const {}
 
-  void boundChangeRemoved(const HighsDomain& domain,
-                          const HighsDomainChange& domchg) const {}
+  void boundChangeRemoved(const HighsDomain&, const HighsDomainChange&) const {}
 
-  void resetDomain(const HighsDomain& domain) const {}
+  void resetDomain(const HighsDomain&) const {}
 
-  void nodePruned(const HighsDomain& localdomain) const {}
+  void nodePruned(const HighsDomain&) const {}
 
-  void checkCut(const HighsInt* Rindex, const double* Rvalue, HighsInt Rlen,
-                double rhs) const {}
+  void checkCut(const HighsInt*, const double*, HighsInt, double) const {}
 
-  void checkRow(const HighsInt* Rindex, const double* Rvalue, HighsInt Rlen,
-                double Rlower, double Rupper) const {}
+  void checkRow(const HighsInt*, const double*, HighsInt, double,
+                double) const {}
 
-  void checkRowAggregation(const HighsLp& lp, const HighsInt* Rindex,
-                           const double* Rvalue, HighsInt Rlen) const {}
+  void checkRowAggregation(const HighsLp&, const HighsInt*, const double*,
+                           HighsInt) const {}
 
-  void checkClique(const HighsCliqueTable::CliqueVar* clq,
-                   HighsInt clqlen) const {}
+  void checkClique(const HighsCliqueTable::CliqueVar*, HighsInt) const {}
 
-  void checkVub(HighsInt col, HighsInt vubcol, double vubcoef,
-                double vubconstant) const {}
+  void checkVub(HighsInt, HighsInt, double, double) const {}
 
-  void checkVlb(HighsInt col, HighsInt vlbcol, double vlbcoef,
-                double vlbconstant) const {}
+  void checkVlb(HighsInt, HighsInt, double, double) const {}
 
   void checkConflictReasonFrontier(
-      const std::set<HighsDomain::ConflictSet::LocalDomChg>& reasonSideFrontier,
-      const std::vector<HighsDomainChange>& domchgstack) const {}
+      const std::set<HighsDomain::ConflictSet::LocalDomChg>&,
+      const std::vector<HighsDomainChange>&) const {}
 
   void checkConflictReconvergenceFrontier(
-      const std::set<HighsDomain::ConflictSet::LocalDomChg>&
-          reconvergenceFrontier,
-      const HighsDomain::ConflictSet::LocalDomChg& reconvDomchgPos,
-      const std::vector<HighsDomainChange>& domchgstack) const {}
+      const std::set<HighsDomain::ConflictSet::LocalDomChg>&,
+      const HighsDomain::ConflictSet::LocalDomChg&,
+      const std::vector<HighsDomainChange>&) const {}
 };
 #endif
 

casadi/include/highs/mip/HighsDomain.h

@@ -2,7 +2,7 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
 /*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
@@ -255,7 +255,14 @@ class HighsDomain {
 
     std::vector<PartitionCliqueData> partitionCliqueData;
 
-    ObjectivePropagation() = default;
+    ObjectivePropagation() {
+      objFunc = nullptr;
+      cost = nullptr;
+      objectiveLower = 0.0;
+      numInfObjLower = 0;
+      capacityThreshold = 0.0;
+      isPropagated = false;
+    }
     ObjectivePropagation(HighsDomain* domain);
 
     bool isActive() const { return domain != nullptr; }
@@ -351,6 +358,7 @@ class HighsDomain {
         conflictPoolPropagation(other.conflictPoolPropagation),
         infeasible_(other.infeasible_),
         infeasible_reason(other.infeasible_reason),
+        infeasible_pos(other.infeasible_pos),
         colLowerPos_(other.colLowerPos_),
         colUpperPos_(other.colUpperPos_),
         branchPos_(other.branchPos_),

casadi/include/highs/mip/HighsDomainChange.h

@@ -2,7 +2,7 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    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/HighsDynamicRowMatrix.h

@@ -2,7 +2,7 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
 /*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
@@ -42,7 +42,7 @@ class HighsDynamicRowMatrix {
 
   /// vector of column sizes
 
-  /// keep an ordered set ofof free spaces in the row arrays so that they can be
+  /// keep an ordered set of free spaces in the row arrays so that they can be
   /// reused efficiently
   std::set<std::pair<HighsInt, HighsInt>> freespaces_;
 
@@ -52,7 +52,9 @@ class HighsDynamicRowMatrix {
  public:
   HighsDynamicRowMatrix(HighsInt ncols);
 
-  bool columnsLinked(HighsInt rowindex) const { return colsLinked[rowindex]; }
+  bool columnsLinked(HighsInt rowindex) const {
+    return (colsLinked[rowindex] != 0);
+  }
 
   void unlinkColumns(HighsInt rowindex);
 

casadi/include/highs/mip/HighsGFkSolve.h

@@ -2,7 +2,7 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
 /*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
@@ -23,7 +23,7 @@
 
 #include "lp_data/HConst.h"
 
-// helper struct to compute the multipicative inverse by using fermats
+// helper struct to compute the multiplicative inverse by using fermats
 // theorem and recursive repeated squaring.
 // Under the assumption that k is a small prime and an 32bit HighsInt is enough
 // to hold the number (k-1)^(k-2) good compilers should be able to optimize this
@@ -39,7 +39,7 @@ struct HighsGFk;
 template <>
 struct HighsGFk<2> {
   static constexpr unsigned int powk(unsigned int a) { return a * a; }
-  static constexpr unsigned int inverse(unsigned int a) { return 1; }
+  static constexpr unsigned int inverse(unsigned int) { return 1; }
 };
 
 template <>

casadi/include/highs/mip/HighsImplications.h

@@ -2,7 +2,7 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
 /*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
@@ -54,7 +54,7 @@ class HighsImplications {
   std::vector<uint8_t> colsubstituted;
   HighsImplications(const HighsMipSolver& mipsolver) : mipsolver(mipsolver) {
     HighsInt numcol = mipsolver.numCol();
-    implications.resize(2 * numcol);
+    implications.resize(2 * static_cast<size_t>(numcol));
     colsubstituted.resize(numcol);
     vubs.resize(numcol);
     vlbs.resize(numcol);
@@ -69,7 +69,7 @@ class HighsImplications {
     implications.shrink_to_fit();
 
     HighsInt numcol = mipsolver.numCol();
-    implications.resize(2 * numcol);
+    implications.resize(2 * static_cast<size_t>(numcol));
     colsubstituted.resize(numcol);
     numImplications = 0;
     vubs.clear();

casadi/include/highs/mip/HighsLpAggregator.h

@@ -2,7 +2,7 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    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,7 +2,7 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
 /*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
@@ -96,6 +96,11 @@ class HighsLpRelaxation {
 
   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;

casadi/include/highs/mip/HighsMipSolver.h

@@ -2,7 +2,7 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
 /*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
@@ -94,10 +94,12 @@ class HighsMipSolver {
   mutable HighsTimer timer_;
   void cleanupSolve();
 
-  void runPresolve();
+  void runPresolve(const HighsInt presolve_reduction_limit);
   const HighsLp& getPresolvedModel() const;
   HighsPresolveStatus getPresolveStatus() const;
   presolve::HighsPostsolveStack getPostsolveStack() const;
+
+  void callbackGetCutPool() const;
 };
 
 #endif

casadi/include/highs/mip/HighsMipSolverData.h

@@ -2,7 +2,7 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
 /*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
@@ -128,6 +128,46 @@ struct HighsMipSolverData {
         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),
+        last_disptime(0.0),
+        firstrootlpiters(0),
+        num_nodes(0),
+        num_leaves(0),
+        num_leaves_before_run(0),
+        num_nodes_before_run(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);
@@ -156,11 +196,13 @@ struct HighsMipSolverData {
   void init();
   void basisTransfer();
   void checkObjIntegrality();
-  void runPresolve();
+  void runPresolve(const HighsInt presolve_reduction_limit);
   void setupDomainPropagation();
-  void saveReportMipSolution(const double new_upper_limit);
+  void saveReportMipSolution(const double new_upper_limit = -kHighsInf);
   void runSetup();
-  double transformNewIncumbent(const std::vector<double>& sol);
+  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;
@@ -187,6 +229,7 @@ struct HighsMipSolverData {
   void limitsToBounds(double& dual_bound, double& primal_bound,
                       double& mip_rel_gap) const;
   bool interruptFromCallbackWithData(const int callback_type,
+                                     const double mipsolver_objective_value,
                                      const std::string message = "") const;
 };
 

casadi/include/highs/mip/HighsModkSeparator.h

@@ -2,7 +2,7 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
 /*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
@@ -20,7 +20,7 @@
  * cut.
  *
  * If a row contains continuous variables that sit at zero after bound
- * substitution, then those rows are included in the congurence system, as the
+ * 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

casadi/include/highs/mip/HighsNodeQueue.h

@@ -2,7 +2,7 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
 /*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
@@ -106,8 +106,8 @@ class HighsNodeQueue {
               reinterpret_cast<FreelistNode*>(state->freeListHead)->next;
         } else {
           ptr = reinterpret_cast<T*>(state->currChunkStart);
-          state->currChunkStart += sizeof(FreelistNode);
-          if (state->currChunkStart > state->currChunkEnd) {
+          if (!ptr || state->currChunkStart + sizeof(FreelistNode) >
+                          state->currChunkEnd) {
             auto newChunk = new Chunk;
             newChunk->next = state->chunkListHead;
             state->chunkListHead = newChunk;
@@ -116,6 +116,8 @@ class HighsNodeQueue {
                 state->currChunkStart + sizeof(newChunk->storage);
             ptr = reinterpret_cast<T*>(state->currChunkStart);
             state->currChunkStart += sizeof(FreelistNode);
+          } else {
+            state->currChunkStart += sizeof(FreelistNode);
           }
         }
         return ptr;

casadi/include/highs/mip/HighsObjectiveFunction.h

@@ -2,7 +2,7 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    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,7 +2,7 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
 /*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
@@ -10,7 +10,7 @@
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 /**@file mip/HighsPathSeparator.h
  * @brief Class for separating cuts from heuristically aggregating rows from the
- * LP to indetify path's in a network
+ * LP to identify path's in a network
  *
  */
 

casadi/include/highs/mip/HighsPrimalHeuristics.h

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