casadi 3.6.4__cp312-none-win_amd64.whl → 3.6.6__cp312-none-win_amd64.whl

casadi/include/highs/util/HighsIntegers.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                     */
@@ -29,8 +29,7 @@ class HighsIntegers {
   }
 
   static double mod(double a, double m) {
-    int64_t r = std::fmod(a, m);
-    return r + (a < 0) * m;
+    return std::trunc(std::fmod(a, m)) + (a < 0) * m;
   }
 
   static int64_t nearestInteger(double x) {
@@ -38,7 +37,7 @@ class HighsIntegers {
   }
 
   static bool isIntegral(double x, double eps) {
-    double y = std::fabs(x - (int64_t)x);
+    double y = std::fabs(x - std::trunc(x));
     return std::min(y, 1.0 - y) <= eps;
   }
 
@@ -118,8 +117,8 @@ class HighsIntegers {
     m[1] += m[0] * ai;
     m[3] += m[2] * ai;
 
-    double x0 = m[0] / (double)m[2];
-    double x1 = m[1] / (double)m[3];
+    double x0 = static_cast<double>(m[0]) / static_cast<double>(m[2]);
+    double x1 = static_cast<double>(m[1]) / static_cast<double>(m[3]);
     x = std::abs(x);
     double err0 = std::abs(x - x0);
     double err1 = std::abs(x - x1);
@@ -147,7 +146,7 @@ class HighsIntegers {
     expshift = std::max(-expshift, 0) + 3;
 
     // guard against making the largest value too big which may cause overflows
-    // with intermdediate gcd values
+    // with intermediate gcd values
     int expMaxVal;
     std::frexp(maxval, &expMaxVal);
     expMaxVal = std::min(expMaxVal, 32);
@@ -195,7 +194,7 @@ class HighsIntegers {
         currgcd = gcd(currgcd, (int64_t) double(downval));
 
         // if the denominator is large, divide by the current gcd to prevent
-        // unecessary overflows
+        // unnecessary overflows
         if (denom > std::numeric_limits<unsigned int>::max()) {
           denom /= currgcd;
           if (startdenom != 1) startdenom /= gcd(currgcd, startdenom);
@@ -204,7 +203,7 @@ class HighsIntegers {
       }
     }
 
-    return denom / (double)currgcd;
+    return static_cast<double>(denom) / static_cast<double>(currgcd);
   }
 
   static double integralScale(const std::vector<double>& vals, double deltadown,

casadi/include/highs/util/HighsLinearSumBounds.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/util/HighsMatrixPic.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/util/HighsMatrixSlice.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                     */
@@ -196,10 +196,11 @@ class HighsMatrixSlice<HighsTripletListSlice> {
     using pointer = const HighsSliceNonzero*;
     using reference = const HighsSliceNonzero&;
 
-    iterator(HighsInt node) : currentNode(node) {}
+    iterator(HighsInt node) : pos_(), nodeNext(nullptr), currentNode(node) {}
     iterator(const HighsInt* nodeIndex, const double* nodeValue,
              const HighsInt* nodeNext, HighsInt node)
-        : pos_(nodeIndex + node, nodeValue + node),
+        : pos_(node == -1 ? nullptr : nodeIndex + node,
+               node == -1 ? nullptr : nodeValue + node),
           nodeNext(nodeNext),
           currentNode(node) {}
     iterator() = default;
@@ -275,7 +276,8 @@ class HighsMatrixSlice<HighsTripletTreeSlicePreOrder> {
     using pointer = const HighsSliceNonzero*;
     using reference = const HighsSliceNonzero&;
 
-    iterator(HighsInt node) : currentNode(node) {}
+    iterator(HighsInt node)
+        : pos_(), nodeLeft(nullptr), nodeRight(nullptr), currentNode(node) {}
     iterator(const HighsInt* nodeIndex, const double* nodeValue,
              const HighsInt* nodeLeft, const HighsInt* nodeRight, HighsInt node)
         : pos_(nodeIndex + node, nodeValue + node),
@@ -373,7 +375,8 @@ class HighsMatrixSlice<HighsTripletTreeSliceInOrder> {
     using pointer = const HighsSliceNonzero*;
     using reference = const HighsSliceNonzero&;
 
-    iterator(HighsInt node) : currentNode(node) {}
+    iterator(HighsInt node)
+        : pos_(), nodeLeft(nullptr), nodeRight(nullptr), currentNode(node) {}
     iterator(const HighsInt* nodeIndex, const double* nodeValue,
              const HighsInt* nodeLeft, const HighsInt* nodeRight, HighsInt node)
         : pos_(nodeIndex, nodeValue),
@@ -476,7 +479,7 @@ class HighsMatrixSlice<HighsTripletPositionSlice> {
     using pointer = const HighsSliceNonzero*;
     using reference = const HighsSliceNonzero&;
 
-    iterator(const HighsInt* node) : node(node) {}
+    iterator(const HighsInt* node) : pos_(), node(node), currentNode(0) {}
     iterator(const HighsInt* nodeIndex, const double* nodeValue,
              const HighsInt* node)
         : pos_(nodeIndex, nodeValue), node(node), currentNode(0) {}

casadi/include/highs/util/HighsMatrixUtils.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/util/HighsMemoryAllocation.h

@@ -0,0 +1,55 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    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                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/**@file HighsMemoryAllocation.h
+ * @brief Utilities for memory allocation that return true if successful
+ */
+
+#ifndef UTIL_HIGHS_MEMORY_ALLOCATION_H_
+#define UTIL_HIGHS_MEMORY_ALLOCATION_H_
+
+#include <vector>
+
+#include "util/HighsInt.h"
+
+template <typename T>
+bool okResize(std::vector<T>& use_vector, HighsInt dimension, T value = T{}) {
+  try {
+    use_vector.resize(dimension, value);
+  } catch (const std::bad_alloc& e) {
+    printf("HighsMemoryAllocation::okResize fails with %s\n", e.what());
+    return false;
+  }
+  return true;
+}
+
+template <typename T>
+bool okReserve(std::vector<T>& use_vector, HighsInt dimension) {
+  try {
+    use_vector.reserve(dimension);
+  } catch (const std::bad_alloc& e) {
+    printf("HighsMemoryAllocation::okReserve fails with %s\n", e.what());
+    return false;
+  }
+  return true;
+}
+
+template <typename T>
+bool okAssign(std::vector<T>& use_vector, HighsInt dimension, T value = T{}) {
+  try {
+    use_vector.assign(dimension, value);
+  } catch (const std::bad_alloc& e) {
+    printf("HighsMemoryAllocation::okAssign fails with %s\n", e.what());
+    return false;
+  }
+  return true;
+}
+
+#endif

casadi/include/highs/util/HighsRandom.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                     */
@@ -32,13 +32,14 @@ class HighsRandom {
     assert(sup <= uint32_t{1} << nbits);
     while (true) {
       advance();
-      uint32_t lo = state;
+      uint32_t lo = static_cast<uint32_t>(state);
       uint32_t hi = state >> 32;
 
-      uint64_t val;
+      uint32_t val;
 
-#define HIGHS_RAND_TRY_OUTPUT(n)                                \
-  val = HighsHashHelpers::pair_hash<n>(lo, hi) >> (64 - nbits); \
+#define HIGHS_RAND_TRY_OUTPUT(n)                                        \
+  val = static_cast<uint32_t>(HighsHashHelpers::pair_hash<n>(lo, hi) >> \
+                              (64 - nbits));                            \
   if (val < sup) return val;
 
       HIGHS_RAND_TRY_OUTPUT(0);
@@ -86,7 +87,7 @@ class HighsRandom {
     assert(sup <= uint64_t{1} << nbits);
     while (true) {
       advance();
-      uint32_t lo = state;
+      uint32_t lo = static_cast<uint32_t>(state);
       uint32_t hi = state >> 32;
 
       uint64_t val;
@@ -128,7 +129,8 @@ class HighsRandom {
   void initialise(HighsUInt seed = 0) {
     state = seed;
     do {
-      state = HighsHashHelpers::pair_hash<0>(state, state >> 32);
+      state = HighsHashHelpers::pair_hash<0>(static_cast<uint32_t>(state),
+                                             state >> 32);
       state ^= (HighsHashHelpers::pair_hash<1>(state >> 32, seed) >> 32);
     } while (state == 0);
   }
@@ -154,7 +156,9 @@ class HighsRandom {
            (HighsHashHelpers::pair_hash<1>(state, state >> 32) >> 32);
 #else
     // use 31 bits of the 64 bit result
-    return HighsHashHelpers::pair_hash<0>(state, state >> 32) >> 33;
+    return HighsHashHelpers::pair_hash<0>(static_cast<uint32_t>(state),
+                                          state >> 32) >>
+           33;
 #endif
   }
 
@@ -181,9 +185,12 @@ class HighsRandom {
   double fraction() {
     advance();
     // 52 bit output is in interval [0,2^52-1]
-    uint64_t output =
-        (HighsHashHelpers::pair_hash<0>(state, state >> 32) >> (64 - 52)) ^
-        (HighsHashHelpers::pair_hash<1>(state, state >> 32) >> (64 - 26));
+    uint64_t output = (HighsHashHelpers::pair_hash<0>(
+                           static_cast<uint32_t>(state), state >> 32) >>
+                       (64 - 52)) ^
+                      (HighsHashHelpers::pair_hash<1>(
+                           static_cast<uint32_t>(state), state >> 32) >>
+                       (64 - 26));
     // compute (1+output) / (2^52+1) which is strictly between 0 and 1
     return (1 + output) * 2.2204460492503125e-16;
   }
@@ -194,9 +201,12 @@ class HighsRandom {
   double closedFraction() {
     advance();
     // 53 bit result is in interval [0,2^53-1]
-    uint64_t output =
-        (HighsHashHelpers::pair_hash<0>(state, state >> 32) >> (64 - 53)) ^
-        (HighsHashHelpers::pair_hash<1>(state, state >> 32) >> 32);
+    uint64_t output = (HighsHashHelpers::pair_hash<0>(
+                           static_cast<uint32_t>(state), state >> 32) >>
+                       (64 - 53)) ^
+                      (HighsHashHelpers::pair_hash<1>(
+                           static_cast<uint32_t>(state), state >> 32) >>
+                       32);
     // compute output / (2^53-1) in double precision which is in the closed
     // interval [0,1]
     return output * 1.1102230246251566e-16;
@@ -212,7 +222,9 @@ class HighsRandom {
    */
   bool bit() {
     advance();
-    return HighsHashHelpers::pair_hash<0>(state, state >> 32) >> 63;
+    return HighsHashHelpers::pair_hash<0>(static_cast<uint32_t>(state),
+                                          state >> 32) >>
+           63;
   }
 
   /**

casadi/include/highs/util/HighsRbTree.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                     */
@@ -141,7 +141,7 @@ class RbTree {
   }
 
   void setColor(LinkType node, HighsUInt color) {
-    static_cast<Impl*>(this)->getRbTreeLinks(node).setColor(color);
+    static_cast<Impl*>(this)->getRbTreeLinks(node).setColor(color != 0);
   }
 
   HighsUInt getColor(LinkType node) const {

casadi/include/highs/util/HighsSort.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                     */
@@ -36,7 +36,7 @@ void maxheapsort(HighsInt* heap_v,  //!< HighsInt values to be sorted
  */
 void maxheapsort(
     HighsInt* heap_v,  //!< Values to be sorted
-    HighsInt* heap_i,  //!< Indices corrresponding to (sorted) values
+    HighsInt* heap_i,  //!< Indices corresponding to (sorted) values
     HighsInt n         //!< Number of values to be sorted
 );
 /**
@@ -45,7 +45,7 @@ void maxheapsort(
  */
 void maxheapsort(
     double* heap_v,    //!< Values to be sorted
-    HighsInt* heap_i,  //!< Indices corrresponding to (sorted) values
+    HighsInt* heap_i,  //!< Indices corresponding to (sorted) values
     HighsInt n         //!< Number of values to be sorted
 );
 /**
@@ -61,7 +61,7 @@ void buildMaxheap(HighsInt* heap_v,  //!< HighsInt values to be sorted
  */
 void buildMaxheap(
     HighsInt* heap_v,  //!< Values to be sorted
-    HighsInt* heap_i,  //!< Indices corrresponding to (sorted) values
+    HighsInt* heap_i,  //!< Indices corresponding to (sorted) values
     HighsInt n         //!< Number of values to be sorted
 );
 /**
@@ -70,7 +70,7 @@ void buildMaxheap(
  */
 void buildMaxheap(
     double* heap_v,    //!< Values to be sorted
-    HighsInt* heap_i,  //!< Indices corrresponding to (sorted) values
+    HighsInt* heap_i,  //!< Indices corresponding to (sorted) values
     HighsInt n         //!< Number of values to be sorted
 );
 /**
@@ -84,7 +84,7 @@ void maxHeapsort(HighsInt* heap_v,  //!< HighsInt values to be sorted
  */
 void maxHeapsort(
     HighsInt* heap_v,  //!< Values to be sorted
-    HighsInt* heap_i,  //!< Indices corrresponding to (sorted) values
+    HighsInt* heap_i,  //!< Indices corresponding to (sorted) values
     HighsInt n         //!< Number of values to be sorted
 );
 /**
@@ -92,7 +92,7 @@ void maxHeapsort(
  */
 void maxHeapsort(
     double* heap_v,    //!< Values to be sorted
-    HighsInt* heap_i,  //!< Indices corrresponding to (sorted) values
+    HighsInt* heap_i,  //!< Indices corresponding to (sorted) values
     HighsInt n         //!< Number of values to be sorted
 );
 /**

casadi/include/highs/util/HighsSparseMatrix.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                     */
@@ -58,7 +58,10 @@ class HighsSparseMatrix {
                const int8_t* in_partition = NULL);
   void addRows(const HighsSparseMatrix new_rows,
                const int8_t* in_partition = NULL);
-
+  void getRow(const HighsInt iRow, HighsInt& num_nz, HighsInt* index,
+              double* value) const;
+  void getCol(const HighsInt iCol, HighsInt& num_nz, HighsInt* index,
+              double* value) const;
   void deleteCols(const HighsIndexCollection& index_collection);
   void deleteRows(const HighsIndexCollection& index_collection);
   HighsStatus assessDimensions(const HighsLogOptions& log_options,

casadi/include/highs/util/HighsSparseVectorSum.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                     */
@@ -62,7 +62,7 @@ class HighsSparseVectorSum {
   double getValue(HighsInt index) const { return double(values[index]); }
 
   void clear() {
-    if (nonzeroinds.size() < 0.3 * values.size())
+    if (10 * nonzeroinds.size() < 3 * values.size())
       for (HighsInt i : nonzeroinds) values[i] = 0.0;
     else
       values.assign(values.size(), false);

casadi/include/highs/util/HighsSplay.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/util/HighsTimer.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                     */
@@ -177,6 +177,16 @@ class HighsTimer {
     return read_time;
   }
 
+  /**
+   * @brief Return whether a clock is running
+   */
+  bool running(HighsInt i_clock  //!< Index of the clock to be read
+  ) {
+    assert(i_clock >= 0);
+    assert(i_clock < num_clock);
+    return clock_start[i_clock] < 0;
+  }
+
   /**
    * @brief Start the RunHighs clock
    */
@@ -195,7 +205,7 @@ class HighsTimer {
   /**
    * @brief Test whether the RunHighs clock is running
    */
-  bool runningRunHighsClock() { return clock_start[run_highs_clock] < 0; }
+  bool runningRunHighsClock() { return running(run_highs_clock); }
 
   /**
    * @brief Report timing information for the clock indices in the list
@@ -219,7 +229,7 @@ class HighsTimer {
           0  //!< Lower bound on percentage of total time
              //!< before an individual clock is reported
   ) {
-    HighsInt num_clock_list_entries = clock_list.size();
+    size_t num_clock_list_entries = clock_list.size();
     double current_run_highs_time = readRunHighsClock();
     bool non_null_report = false;
 
@@ -228,7 +238,7 @@ class HighsTimer {
     // determine the total clock times
     HighsInt sum_calls = 0;
     double sum_clock_times = 0;
-    for (HighsInt i = 0; i < num_clock_list_entries; i++) {
+    for (size_t i = 0; i < num_clock_list_entries; i++) {
       HighsInt iClock = clock_list[i];
       assert(iClock >= 0);
       assert(iClock < num_clock);
@@ -243,7 +253,7 @@ class HighsTimer {
 
     std::vector<double> percent_sum_clock_times(num_clock_list_entries);
     double max_percent_sum_clock_times = 0;
-    for (HighsInt i = 0; i < num_clock_list_entries; i++) {
+    for (size_t i = 0; i < num_clock_list_entries; i++) {
       HighsInt iClock = clock_list[i];
       percent_sum_clock_times[i] = 100.0 * clock_time[iClock] / sum_clock_times;
       max_percent_sum_clock_times =
@@ -261,7 +271,7 @@ class HighsTimer {
     printf(";  Local):    Calls  Time/Call\n");
     // Convert approximate seconds
     double sum_time = 0;
-    for (HighsInt i = 0; i < num_clock_list_entries; i++) {
+    for (size_t i = 0; i < num_clock_list_entries; i++) {
       HighsInt iClock = clock_list[i];
       double time = clock_time[iClock];
       double percent_run_highs = 100.0 * time / current_run_highs_time;
@@ -275,9 +285,8 @@ class HighsTimer {
             double percent_ideal = 100.0 * time / ideal_sum_time;
             printf("; %5.1f%%", percent_ideal);
           }
-          printf("; %5.1f%%):%9" HIGHSINT_FORMAT " %11.4e\n",
-                 percent_sum_clock_times[i], clock_num_call[iClock],
-                 time_per_call);
+          printf("; %5.1f%%):%9ld %11.4e\n", percent_sum_clock_times[i],
+                 static_cast<long int>(clock_num_call[iClock]), time_per_call);
         }
       }
       sum_time += time;

casadi/include/highs/util/HighsUtils.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,6 +20,13 @@
 
 #include "lp_data/HighsOptions.h"
 
+const HighsInt kIndexCollectionCreateOk = 0;
+const HighsInt kIndexCollectionCreateIllegalInterval = 1;
+const HighsInt kIndexCollectionCreateIllegalSetSize = 1;
+const HighsInt kIndexCollectionCreateIllegalSetDimension = 2;
+const HighsInt kIndexCollectionCreateIllegalSetOrder = 3;
+const HighsInt kIndexCollectionCreateIllegalMaskSize = 1;
+
 void highsSparseTranspose(HighsInt numRow, HighsInt numCol,
                           const std::vector<HighsInt>& Astart,
                           const std::vector<HighsInt>& Aindex,
@@ -81,15 +88,15 @@ const double awful_regression_error = 2.0;
 const double bad_regression_error = 0.2;
 const double fair_regression_error = 0.02;
 
-bool create(HighsIndexCollection& index_collection, const HighsInt from_col,
-            const HighsInt to_col, const HighsInt dimension);
+HighsInt create(HighsIndexCollection& index_collection, const HighsInt from_col,
+                const HighsInt to_col, const HighsInt dimension);
 
-bool create(HighsIndexCollection& index_collection,
-            const HighsInt num_set_entries, const HighsInt* set,
-            const HighsInt dimension);
+HighsInt create(HighsIndexCollection& index_collection,
+                const HighsInt num_set_entries, const HighsInt* set,
+                const HighsInt dimension);
 
-void create(HighsIndexCollection& index_collection, const HighsInt* mask,
-            const HighsInt dimension);
+HighsInt create(HighsIndexCollection& index_collection, const HighsInt* mask,
+                const HighsInt dimension);
 
 bool ok(const HighsIndexCollection& index_collection);
 

casadi/include/highs/util/stringutil.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                     */
@@ -16,11 +16,16 @@
 #include <cstring>
 #include <string>
 
+/*
 void strRemoveWhitespace(char* str);
 char* strClone(const char* str);
 int strIsWhitespace(const char* str);
 void strToLower(char* str);
 void strTrim(char* str);
+*/
+// std::string& str_tolower(std::string s);
+
+void tolower(std::string& str);
 
 const std::string non_chars = "\t\n\v\f\r ";
 std::string& ltrim(std::string& str, const std::string& chars = non_chars);
@@ -29,11 +34,11 @@ std::string& trim(std::string& str, const std::string& chars = non_chars);
 
 bool is_empty(std::string& str, const std::string& chars = non_chars);
 bool is_empty(char c, const std::string& chars = non_chars);
-bool is_end(std::string& str, int end, const std::string& chars = non_chars);
+bool is_end(std::string& str, size_t end, const std::string& chars = non_chars);
 
 // todo: replace with pair of references rather than string ret value to avoid
 // copy and also using function below. or do it properly with iterators.
-std::string first_word(std::string& str, int start);
-int first_word_end(std::string& str, int start);
+std::string first_word(std::string& str, size_t start);
+size_t first_word_end(std::string& str, size_t start);
 
 #endif