casadi 3.6.5__cp39-none-manylinux2014_x86_64.whl → 3.6.7__cp39-none-manylinux2014_x86_64.whl

casadi/include/highs/util/HFactorDebug.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/HSet.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/HVector.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/HVectorBase.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/HighsCDouble.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,7 +32,7 @@ class HighsCDouble {
   // Proceedings of. 2005.
 
   /// performs an exact transformation such that x + y = a + b
-  /// and x = double(a + b). The operation uses 6 flops (addition/substraction).
+  /// and x = double(a + b). The operation uses 6 flops (addition/subtraction).
   static void two_sum(double& x, double& y, double a, double b) {
     x = a + b;
     double z = x - a;
@@ -50,7 +50,7 @@ class HighsCDouble {
 
   /// performs an exact transformation such that x + y = a * b
   /// and x = double(a * b). The operation uses 10 flops for
-  /// addition/substraction and 7 flops for multiplication.
+  /// addition/subtraction and 7 flops for multiplication.
   static void two_product(double& x, double& y, double a, double b) {
     x = a * b;
     double a1, a2, b1, b2;

casadi/include/highs/util/HighsComponent.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/HighsDataStack.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,7 +29,7 @@
 
 class HighsDataStack {
   std::vector<char> data;
-  HighsInt position;
+  std::size_t position;
 
  public:
   void resetPosition() { position = data.size(); }
@@ -78,9 +78,9 @@ class HighsDataStack {
     }
   }
 
-  void setPosition(HighsInt position_) { this->position = position_; }
+  void setPosition(size_t position_) { this->position = position_; }
 
-  HighsInt getCurrentDataSize() const { return data.size(); }
+  size_t getCurrentDataSize() const { return data.size(); }
 };
 
 #endif

casadi/include/highs/util/HighsDisjointSets.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/HighsHash.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                     */
@@ -130,7 +130,7 @@ struct HighsHashHelpers {
 
   static int popcnt(uint64_t x) {
 #ifdef _WIN64
-    return __popcnt64(x);
+    return static_cast<int>(__popcnt64(x));
 #else
     return __popcnt(x & 0xffffffffu) + __popcnt(x >> 32);
 #endif
@@ -253,7 +253,7 @@ struct HighsHashHelpers {
     u64 result = u64(a) * u64(b);
     result = (result >> 31) + (result & M31());
     if (result >= M31()) result -= M31();
-    return result;
+    return static_cast<u32>(result);
   }
 
   static u32 modexp_M31(u32 a, u64 e) {
@@ -277,7 +277,8 @@ struct HighsHashHelpers {
 
   template <HighsInt k>
   static u64 pair_hash(u32 a, u32 b) {
-    return (a + c[2 * k]) * (b + c[2 * k + 1]);
+    return (static_cast<u64>(a) + c[2 * k]) *
+           (static_cast<u64>(b) + c[2 * k + 1]);
   }
 
   static void sparse_combine(u64& hash, HighsInt index, u64 value) {
@@ -383,18 +384,20 @@ struct HighsHashHelpers {
     // which we evaluate at the random vector of 16.
 
     // make sure input value is never zero and at most 31bits are used
-    value = (pair_hash<0>(value, value >> 32) >> 33) | 1;
+    value = (pair_hash<0>(static_cast<u32>(value), value >> 32) >> 33) | 1;
 
     // make sure that the constant has at most 31 bits, as otherwise the modulo
     // algorithm for multiplication mod M31 might not work properly due to
     // overflow
-    u32 a = c[index & 63] & M31();
+    u32 a = static_cast<u32>(c[index & 63] & M31());
     HighsInt degree = (index >> 6) + 1;
 
-    hash += multiply_modM31(value, modexp_M31(a, degree));
-    hash = (hash >> 31) + (hash & M31());
-    if (hash >= M31()) hash -= M31();
-    assert(hash < M31());
+    u64 result = hash;
+    result += multiply_modM31(static_cast<u32>(value), modexp_M31(a, degree));
+    result = (result >> 31) + (result & M31());
+    if (result >= M31()) result -= M31();
+    assert(result < M31());
+    hash = static_cast<u32>(result);
   }
 
   static void sparse_inverse_combine32(u32& hash, HighsInt index, u64 value) {
@@ -407,16 +410,19 @@ struct HighsHashHelpers {
     // procedure.
 
     // make sure input value is never zero and at most 31bits are used
-    value = (pair_hash<0>(value, value >> 32) >> 33) | 1;
+    value = (pair_hash<0>(static_cast<u32>(value), value >> 32) >> 33) | 1;
 
-    u32 a = c[index & 63] & M31();
+    u32 a = static_cast<u32>(c[index & 63] & M31());
     HighsInt degree = (index >> 6) + 1;
     // add the additive inverse (M31() - hashvalue) instead of the hash value
     // itself
-    hash += M31() - multiply_modM31(value, modexp_M31(a, degree));
-    hash = (hash >> 31) + (hash & M31());
-    if (hash >= M31()) hash -= M31();
-    assert(hash < M31());
+    u64 result = hash;
+    result +=
+        M31() - multiply_modM31(static_cast<u32>(value), modexp_M31(a, degree));
+    result = (result >> 31) + (result & M31());
+    if (result >= M31()) result -= M31();
+    assert(result < M31());
+    hash = static_cast<u32>(result);
   }
 
   static constexpr u64 fibonacci_muliplier() { return u64{0x9e3779b97f4a7c15}; }
@@ -746,7 +752,8 @@ struct HighsHashHelpers {
     // now be different values which exhibit the same pattern as the 0.5 case,
     // but they do not have a small denominator like 1/2 in their rational
     // representation but are power of two multiples of the golden ratio and
-    // therefore irrational, which we do not expect in non-artifical input data.
+    // therefore irrational, which we do not expect in non-artificial input
+    // data.
     int exponent;
     double hashbits = std::frexp(val * golden_ratio_reciprocal(), &exponent);
 
@@ -813,7 +820,7 @@ struct HighsHashTableEntry {
   // and the value as default
   // the enable if statement makes sure this overload is never selected
   // when the type of the single argument is HighsHashTableEntry<K,V> so that
-  // the default move and copy constructures are preferred when they match
+  // the default move and copy constructors are preferred when they match
   // and this is only used to initialize the key type from a single argument.
   template <
       typename K_,
@@ -868,7 +875,7 @@ struct HighsHashTableEntry<T, void> {
   // Add a constructor to accept an arbitrary argument pack for initialize the
   // underlying value of type T. The enable if statement makes sure this
   // overload is never selected when the type of the single argument is
-  // HighsHashTableEntry<T,void> so that the default move and copy constructures
+  // HighsHashTableEntry<T,void> so that the default move and copy constructors
   // are preferred when they match and this is only used to initialize the value
   // of type from a set of arguments which are properly forwarded.
   // The std::tuple usage in enable_if is a work-around to make the statement
@@ -981,8 +988,8 @@ class HighsHashTable {
 
   HighsHashTable() { makeEmptyTable(128); }
   HighsHashTable(u64 minCapacity) {
-    u64 initCapacity = u64{1} << (u64)std::ceil(
-                           std::log2(std::max(128.0, 8 * minCapacity / 7.0)));
+    u64 initCapacity = u64{1} << (u64)std::ceil(std::log2(std::max(
+                           128.0, 8 * static_cast<double>(minCapacity) / 7)));
     makeEmptyTable(initCapacity);
   }
 

casadi/include/highs/util/HighsHashTree.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                     */
@@ -143,39 +143,22 @@ class HighsHashTree {
         --pos;
         while (hashes[pos] > hash) ++pos;
 
-        while (pos != size && hashes[pos] == hash) {
-          if (entry.key() == entries[pos].key())
-            return std::make_pair(&entries[pos].value(), false);
+        if (find_key(entry.key(), hash, pos))
+          return std::make_pair(&entries[pos].value(), false);
 
-          ++pos;
-        }
-
-        if (pos < size) {
-          std::move_backward(&entries[pos], &entries[size], &entries[size + 1]);
-          memmove(&hashes[pos + 1], &hashes[pos],
-                  sizeof(hashes[0]) * (size - pos));
-        }
-
-        entries[pos] = std::move(entry);
-        hashes[pos] = hash;
-        ++size;
-        hashes[size] = 0;
       } else {
         occupation.set(hashChunk);
 
-        if (pos < size) {
+        if (pos < size)
           while (hashes[pos] > hash) ++pos;
-          std::move_backward(&entries[pos], &entries[size], &entries[size + 1]);
-          memmove(&hashes[pos + 1], &hashes[pos],
-                  sizeof(hashes[0]) * (size - pos));
-        }
-
-        entries[pos] = std::move(entry);
-        hashes[pos] = hash;
-        ++size;
-        hashes[size] = 0;
       }
 
+      if (pos < size) move_backward(pos, size);
+      entries[pos] = std::move(entry);
+      hashes[pos] = hash;
+      ++size;
+      hashes[size] = 0;
+
       return std::make_pair(&entries[pos].value(), true);
     }
 
@@ -187,10 +170,7 @@ class HighsHashTree {
       int pos = occupation.num_set_until(hashChunk) - 1;
       while (hashes[pos] > hash) ++pos;
 
-      while (pos != size && hashes[pos] == hash) {
-        if (key == entries[pos].key()) return &entries[pos].value();
-        ++pos;
-      }
+      if (find_key(key, hash, pos)) return &entries[pos].value();
 
       return nullptr;
     }
@@ -206,26 +186,20 @@ class HighsHashTree {
       int pos = startPos;
       while (hashes[pos] > hash) ++pos;
 
-      while (pos != size && hashes[pos] == hash) {
-        if (key == entries[pos].key()) {
-          --size;
-          if (pos < size) {
-            std::move(&entries[pos + 1], &entries[size + 1], &entries[pos]);
-            memmove(&hashes[pos], &hashes[pos + 1],
-                    sizeof(hashes[0]) * (size - pos));
-            if (get_first_chunk16(hashes[startPos]) != hashChunk)
-              occupation.flip(hashChunk);
-          } else if (startPos == pos)
-            occupation.flip(hashChunk);
-
-          hashes[size] = 0;
-          return true;
-        }
+      if (!find_key(key, hash, pos)) return false;
 
-        ++pos;
-      }
+      --size;
+      if (pos < size) {
+        std::move(&entries[pos + 1], &entries[size + 1], &entries[pos]);
+        memmove(&hashes[pos], &hashes[pos + 1],
+                sizeof(hashes[0]) * (size - pos));
+        if (get_first_chunk16(hashes[startPos]) != hashChunk)
+          occupation.flip(hashChunk);
+      } else if (startPos == pos)
+        occupation.flip(hashChunk);
 
-      return false;
+      hashes[size] = 0;
+      return true;
     }
 
     void rehash(int hashPos) {
@@ -268,17 +242,31 @@ class HighsHashTree {
         // make space at that position, otherwise nothing needs to be done but
         // incrementing i increasing the sorted range by 1.
         if (pos < i) {
-          uint16_t hash = hashes[i];
+          uint64_t hash = hashes[i];
           auto entry = std::move(entries[i]);
-          std::move_backward(&entries[pos], &entries[i], &entries[i + 1]);
-          memmove(&hashes[pos + 1], &hashes[pos],
-                  sizeof(hashes[0]) * (size - pos));
+          move_backward(pos, i);
           hashes[pos] = hash;
           entries[pos] = std::move(entry);
         }
         ++i;
       }
     }
+
+    void move_backward(const int& first, const int& last) {
+      // move elements backwards
+      std::move_backward(&entries[first], &entries[last], &entries[last + 1]);
+      memmove(&hashes[first + 1], &hashes[first],
+              sizeof(hashes[0]) * (last - first));
+    }
+
+    bool find_key(const K& key, const uint16_t& hash, int& pos) const {
+      // find key
+      while (pos != size && hashes[pos] == hash) {
+        if (key == entries[pos].key()) return true;
+        ++pos;
+      }
+      return false;
+    }
   };
 
   struct ListNode {
@@ -509,13 +497,15 @@ class HighsHashTree {
       int pos = HighsHashHelpers::log2i(matchMask);
       matchMask ^= (uint64_t{1} << pos);
 
-      int i = leaf1->occupation.num_set_until(pos) + offset1;
+      int i =
+          leaf1->occupation.num_set_until(static_cast<uint8_t>(pos)) + offset1;
       while (get_first_chunk16(leaf1->hashes[i]) != pos) {
         ++i;
         ++offset1;
       }
 
-      int j = leaf2->occupation.num_set_until(pos) + offset2;
+      int j =
+          leaf2->occupation.num_set_until(static_cast<uint8_t>(pos)) + offset2;
       while (get_first_chunk16(leaf2->hashes[j]) != pos) {
         ++j;
         ++offset2;
@@ -568,13 +558,15 @@ class HighsHashTree {
           int pos = HighsHashHelpers::log2i(matchMask);
           matchMask ^= (uint64_t{1} << pos);
 
-          int i = leaf->occupation.num_set_until(pos) + offset;
+          int i = leaf->occupation.num_set_until(static_cast<uint8_t>(pos)) +
+                  offset;
           while (get_first_chunk16(leaf->hashes[i]) != pos) {
             ++i;
             ++offset;
           }
 
-          int j = branch->occupation.num_set_until(pos) - 1;
+          int j =
+              branch->occupation.num_set_until(static_cast<uint8_t>(pos)) - 1;
 
           do {
             if (find_recurse(branch->child[j],
@@ -654,7 +646,11 @@ class HighsHashTree {
               newNode = newLeafSize4;
               for (int i = 0; i <= newNumChild; ++i)
                 mergeIntoLeaf(newLeafSize4, hashPos, branch->child[i]);
+              break;
             }
+            default:
+              // Unexpected result from 'entries_to_size_class'
+              assert(false);
           }
 
           destroyBranchingNode(branch);
@@ -815,11 +811,11 @@ class HighsHashTree {
           // maxsize in one bucket = number of items - (num buckets-1)
           // since each bucket has at least 1 item the largest one can only
           // have all remaining ones After adding the item: If it does not
-          // collid
+          // collide
           int maxEntriesPerLeaf = 2 + leaf->size - branchSize;
 
           if (maxEntriesPerLeaf <= InnerLeaf<1>::capacity()) {
-            // all items can go into the smalles leaf size
+            // all items can go into the smallest leaf size
             for (int i = 0; i < branchSize; ++i)
               branch->child[i] = new InnerLeaf<1>;
 
@@ -840,8 +836,7 @@ class HighsHashTree {
                 hash, hashPos + 1, entry);
           } else {
             // there are many collisions, determine the exact sizes first
-            uint8_t sizes[InnerLeaf<4>::capacity() + 1];
-            memset(sizes, 0, branchSize);
+            uint8_t sizes[InnerLeaf<4>::capacity() + 1] = {};
             sizes[occupation.num_set_until(hashChunk) - 1] += 1;
             for (int i = 0; i < leaf->size; ++i) {
               int pos =
@@ -864,6 +859,9 @@ class HighsHashTree {
                 case 4:
                   branch->child[i] = new InnerLeaf<4>;
                   break;
+                default:
+                  // Unexpected result from 'entries_to_size_class'
+                  assert(false);
               }
             }
 
@@ -1139,8 +1137,10 @@ class HighsHashTree {
 
           assert(((matchMask >> pos) & 1) == 0);
 
-          int location1 = branch1->occupation.num_set_until(pos) - 1;
-          int location2 = branch2->occupation.num_set_until(pos) - 1;
+          int location1 =
+              branch1->occupation.num_set_until(static_cast<uint8_t>(pos)) - 1;
+          int location2 =
+              branch2->occupation.num_set_until(static_cast<uint8_t>(pos)) - 1;
 
           const HighsHashTableEntry<K, V>* match =
               find_common_recurse(branch1->child[location1],

casadi/include/highs/util/HighsInt.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/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                     */