casadi 3.6.4__cp38-none-manylinux2014_x86_64.whl → 3.6.6__cp38-none-manylinux2014_x86_64.whl

casadi/include/highs/test/DevKkt.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/test/KktCh2.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/FactorTimer.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/HFactor.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                     */
@@ -105,6 +105,35 @@ struct InvertibleRepresentation {
  */
 class HFactor {
  public:
+  HFactor()
+      : build_realTick(0.0),
+        build_synthetic_tick(0.0),
+        rank_deficiency(0),
+        basis_matrix_num_el(0),
+        invert_num_el(0),
+        kernel_dim(0),
+        kernel_num_el(0),
+        num_row(0),
+        num_col(0),
+        num_basic(0),
+        a_matrix_valid(false),
+        a_start(nullptr),
+        a_index(nullptr),
+        a_value(nullptr),
+        basic_index(nullptr),
+        pivot_threshold(0.0),
+        pivot_tolerance(0.0),
+        highs_debug_level(0),
+        time_limit_(0.0),
+        use_original_HFactor_logic(false),
+        debug_report_(false),
+        basis_matrix_limit_size(0),
+        update_method(0),
+        build_timer_(nullptr),
+        nwork(0),
+        u_merit_x(0),
+        u_total_x(0){};
+
   /**
    * @brief Copy problem size and pointers of constraint matrix, and set
    * up space for INVERT
@@ -304,10 +333,10 @@ class HFactor {
   RefactorInfo refactor_info_;
 
   // Properties of data held in HFactor.h
-  HighsInt basis_matrix_num_el = 0;
-  HighsInt invert_num_el = 0;
-  HighsInt kernel_dim = 0;
-  HighsInt kernel_num_el = 0;
+  HighsInt basis_matrix_num_el;
+  HighsInt invert_num_el;
+  HighsInt kernel_dim;
+  HighsInt kernel_num_el;
 
   /**
    * Data of the factor
@@ -339,7 +368,7 @@ class HFactor {
   HighsLogOptions log_options;
 
   bool use_original_HFactor_logic;
-  bool debug_report_ = false;
+  bool debug_report_;
   HighsInt basis_matrix_limit_size;
   HighsInt update_method;
 

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