casadi 3.6.7__cp311-none-manylinux2014_x86_64.whl → 3.7.1__cp311-none-manylinux2014_x86_64.whl

casadi/include/highs/util/HighsHashTree.h

@@ -2,9 +2,6 @@
 /*                                                                       */
 /*    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                     */
 /*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
@@ -113,17 +110,20 @@ class HighsHashTree {
     // to do a linear scan and key comparisons at all
     Occupation occupation;
     int size;
-    uint64_t hashes[capacity() + 1];
-    Entry entries[capacity()];
+    std::array<uint64_t, capacity() + 1> hashes;
+    std::array<Entry, capacity()> entries;
 
     InnerLeaf() : occupation(0), size(0) { hashes[0] = 0; }
 
     template <int kOtherSize>
     InnerLeaf(InnerLeaf<kOtherSize>&& other) {
       assert(other.size <= capacity());
-      memcpy((void*)this, (void*)&other,
-             (char*)&other.hashes[other.size + 1] - (char*)&other);
-      std::move(&other.entries[0], &other.entries[size], &entries[0]);
+      occupation = other.occupation;
+      size = other.size;
+      std::copy(other.hashes.cbegin(),
+                std::next(other.hashes.cbegin(), size + 1), hashes.begin());
+      std::move(other.entries.begin(), std::next(other.entries.begin(), size),
+                entries.begin());
     }
 
     int get_num_entries() const { return size; }
@@ -190,7 +190,9 @@ class HighsHashTree {
 
       --size;
       if (pos < size) {
-        std::move(&entries[pos + 1], &entries[size + 1], &entries[pos]);
+        std::move(std::next(entries.begin(), pos + 1),
+                  std::next(entries.begin(), size + 1),
+                  std::next(entries.begin(), pos));
         memmove(&hashes[pos], &hashes[pos + 1],
                 sizeof(hashes[0]) * (size - pos));
         if (get_first_chunk16(hashes[startPos]) != hashChunk)
@@ -254,7 +256,9 @@ class HighsHashTree {
 
     void move_backward(const int& first, const int& last) {
       // move elements backwards
-      std::move_backward(&entries[first], &entries[last], &entries[last + 1]);
+      std::move_backward(std::next(entries.begin(), first),
+                         std::next(entries.begin(), last),
+                         std::next(entries.begin(), last + 1));
       memmove(&hashes[first + 1], &hashes[first],
               sizeof(hashes[0]) * (last - first));
     }
@@ -836,7 +840,7 @@ class HighsHashTree {
                 hash, hashPos + 1, entry);
           } else {
             // there are many collisions, determine the exact sizes first
-            uint8_t sizes[InnerLeaf<4>::capacity() + 1] = {};
+            std::array<uint8_t, InnerLeaf<4>::capacity() + 1> sizes = {};
             sizes[occupation.num_set_until(hashChunk) - 1] += 1;
             for (int i = 0; i < leaf->size; ++i) {
               int pos =

casadi/include/highs/util/HighsInt.h

@@ -2,9 +2,6 @@
 /*                                                                       */
 /*    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                     */
 /*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

casadi/include/highs/util/HighsIntegers.h

@@ -2,9 +2,6 @@
 /*                                                                       */
 /*    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                     */
 /*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

casadi/include/highs/util/HighsLinearSumBounds.h

@@ -2,9 +2,6 @@
 /*                                                                       */
 /*    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                     */
 /*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

casadi/include/highs/util/HighsMatrixPic.h

@@ -2,9 +2,6 @@
 /*                                                                       */
 /*    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                     */
 /*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

casadi/include/highs/util/HighsMatrixSlice.h

@@ -2,9 +2,6 @@
 /*                                                                       */
 /*    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                     */
 /*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
@@ -13,15 +10,15 @@
  * underlying matrix storage formats
  */
 
+#ifndef UTIL_HIGHS_MATRIX_SLICE_H_
+#define UTIL_HIGHS_MATRIX_SLICE_H_
+
 #include <cstddef>
 #include <iterator>
 #include <vector>
 
 #include "util/HighsInt.h"
 
-#ifndef UTIL_HIGHS_MATRIX_SLICE_H_
-#define UTIL_HIGHS_MATRIX_SLICE_H_
-
 template <typename StorageFormat>
 class HighsMatrixSlice;
 

casadi/include/highs/util/HighsMatrixUtils.h

@@ -2,9 +2,6 @@
 /*                                                                       */
 /*    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                     */
 /*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

casadi/include/highs/util/HighsMemoryAllocation.h

@@ -2,9 +2,6 @@
 /*                                                                       */
 /*    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                     */
 /*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
@@ -41,6 +38,17 @@ bool okReserve(std::vector<T>& use_vector, HighsInt dimension) {
   return true;
 }
 
+template <typename T, typename T2>
+bool okReserve(std::unordered_map<T, T2>& use_map, HighsInt dimension) {
+  try {
+    use_map.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 {

casadi/include/highs/util/HighsRandom.h

@@ -2,9 +2,6 @@
 /*                                                                       */
 /*    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                     */
 /*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
@@ -169,7 +166,7 @@ class HighsRandom {
                                     // or the 64bit version
     if (sup <= 1) return 0;
     int nbits = HighsHashHelpers::log2i(HighsUInt(sup - 1)) + 1;
-    return drawUniform(HighsUInt(sup), nbits);
+    return static_cast<HighsInt>(drawUniform(HighsUInt(sup), nbits));
   }
 
   /**
@@ -192,7 +189,7 @@ class HighsRandom {
                            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;
+    return static_cast<double>(1 + output) * 2.2204460492503125e-16;
   }
 
   /**
@@ -209,7 +206,7 @@ class HighsRandom {
                        32);
     // compute output / (2^53-1) in double precision which is in the closed
     // interval [0,1]
-    return output * 1.1102230246251566e-16;
+    return static_cast<double>(output) * 1.1102230246251566e-16;
   }
 
   /**

casadi/include/highs/util/HighsRbTree.h

@@ -2,9 +2,6 @@
 /*                                                                       */
 /*    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                     */
 /*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

casadi/include/highs/util/HighsSort.h

@@ -2,9 +2,6 @@
 /*                                                                       */
 /*    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                     */
 /*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

casadi/include/highs/util/HighsSparseMatrix.h

@@ -2,9 +2,6 @@
 /*                                                                       */
 /*    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                     */
 /*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
@@ -66,6 +63,9 @@ class HighsSparseMatrix {
   void deleteRows(const HighsIndexCollection& index_collection);
   HighsStatus assessDimensions(const HighsLogOptions& log_options,
                                const std::string matrix_name);
+  HighsStatus assessStart(const HighsLogOptions& log_options);
+  HighsStatus assessIndexBounds(const HighsLogOptions& log_options);
+
   HighsStatus assess(const HighsLogOptions& log_options,
                      const std::string matrix_name,
                      const double small_matrix_value,
@@ -94,6 +94,9 @@ class HighsSparseMatrix {
   void productTranspose(vector<double>& result, const vector<double>& x) const;
   void productQuad(vector<double>& result, const vector<double>& x,
                    const HighsInt debug_report = kDebugReportOff) const;
+  void productTransposeQuad(
+      vector<double>& result_value, const vector<double>& x,
+      const HighsInt debug_report = kDebugReportOff) const;
   void productTransposeQuad(
       vector<double>& result_value, vector<HighsInt>& result_index,
       const HVector& x, const HighsInt debug_report = kDebugReportOff) const;

casadi/include/highs/util/HighsSparseVectorSum.h

@@ -2,9 +2,6 @@
 /*                                                                       */
 /*    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                     */
 /*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

casadi/include/highs/util/HighsSplay.h

@@ -2,9 +2,6 @@
 /*                                                                       */
 /*    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                     */
 /*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

casadi/include/highs/util/HighsTimer.h

@@ -2,9 +2,6 @@
 /*                                                                       */
 /*    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                     */
 /*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
@@ -24,6 +21,10 @@
 
 #include "util/HighsInt.h"
 
+const HighsInt check_clock = -46;
+const HighsInt ipm_clock = 9;
+const bool kNoClockCalls = false;
+
 /**
  * @brief Clock record structure
  */
@@ -33,7 +34,6 @@ struct HighsClockRecord {
   double start;
   double time;
   std::string name;
-  std::string ch3_name;
 };
 */
 /**
@@ -43,28 +43,25 @@ class HighsTimer {
  public:
   HighsTimer() {
     num_clock = 0;
-    HighsInt i_clock = clock_def("Run HiGHS", "RnH");
+    HighsInt i_clock = clock_def("Run HiGHS");
     assert(i_clock == 0);
-    run_highs_clock = i_clock;
 
-    presolve_clock = clock_def("Presolve", "Pre");
-    solve_clock = clock_def("Solve", "Slv");
-    postsolve_clock = clock_def("Postsolve", "Pst");
+    presolve_clock = clock_def("Presolve");
+    solve_clock = clock_def("Solve");
+    postsolve_clock = clock_def("Postsolve");
   }
 
   /**
    * @brief Define a clock
    */
   HighsInt clock_def(
-      const char* name,  //!< Full-length name (<=16 characters) for the clock
-      const char* ch3_name = "N/A"  //!< 3-character name for the clock
-  ) {
+      const char* name)  //!< Full-length name (<=16 characters) for the clock
+  {
     HighsInt i_clock = num_clock;
     clock_num_call.push_back(0);
     clock_start.push_back(initial_clock_start);
     clock_time.push_back(0);
     clock_names.push_back(name);
-    clock_ch3_names.push_back(ch3_name);
     num_clock++;
     return i_clock;
   }
@@ -79,7 +76,6 @@ class HighsTimer {
       x_clock.start = 0;
       x_clock.time = 0;
       x_clock.name = "";
-      x_clock.ch3_name = "";
     }
     */
 
@@ -104,13 +100,11 @@ class HighsTimer {
     this->clock_num_call.clear();
     this->clock_start.clear();
     this->clock_names.clear();
-    this->clock_ch3_names.clear();
-    HighsInt i_clock = clock_def("Run HiGHS", "RnH");
+    HighsInt i_clock = clock_def("Run HiGHS");
     assert(i_clock == 0);
-    this->run_highs_clock = i_clock;
-    this->presolve_clock = clock_def("Presolve", "Pre");
-    this->solve_clock = clock_def("Solve", "Slv");
-    this->postsolve_clock = clock_def("Postsolve", "Pst");
+    this->presolve_clock = clock_def("Presolve");
+    this->solve_clock = clock_def("Solve");
+    this->postsolve_clock = clock_def("Postsolve");
   }
 
   /**
@@ -124,47 +118,86 @@ class HighsTimer {
     }
   }
 
+  /**
+   * @brief write all clocks
+   */
+  void writeAllClocks() {
+    for (HighsInt i = 0; i < num_clock; i++)
+      if (clock_num_call[i])
+        printf("Time %7.5f for %9d calls of clock %3d: %s\n", clock_time[i],
+               int(clock_num_call[i]), int(i), clock_names[i].c_str());
+  }
+
   /**
    * @brief Start a clock
    */
-  void start(HighsInt i_clock  //!< Index of the clock to be started
+  void start(const HighsInt i_clock = 0  //!< Index of the clock to be started
   ) {
     assert(i_clock >= 0);
     assert(i_clock < num_clock);
     // Check that the clock's been stopped. It should be set to
     // getWallTime() >= 0 (or initialised to initial_clock_start > 0)
-    assert(clock_start[i_clock] > 0);
+    const bool clock_stopped = clock_start[i_clock] > 0;
+    if (i_clock != ipm_clock) {
+      // Sometimes the analytic centre clock isn't stopped - because
+      // it runs on a separate thread. Although it would be good to
+      // understand this better, for now don't assert that this clock
+      // has stopped
+      if (!clock_stopped) {
+        printf("Clock %d - %s - still running\n", int(i_clock),
+               clock_names[i_clock].c_str());
+      }
+      assert(clock_stopped);
+    }
     // Set the start to be the negation of the WallTick to check that
     // the clock's been started when it's next stopped
+    if (i_clock == check_clock) {
+      printf("HighsTimer: starting clock %d: %s\n", int(check_clock),
+             this->clock_names[check_clock].c_str());
+    }
     clock_start[i_clock] = -getWallTime();
   }
 
   /**
    * @brief Stop a clock
    */
-  void stop(HighsInt i_clock  //!< Index of the clock to be stopped
+  void stop(const HighsInt i_clock = 0  //!< Index of the clock to be stopped
   ) {
     assert(i_clock >= 0);
     assert(i_clock < num_clock);
     // Check that the clock's been started. It should be set to
     // -getWallTime() <= 0
-    assert(clock_start[i_clock] < 0);
+    const bool clock_stopped = clock_start[i_clock] > 0;
+    if (clock_stopped) {
+      printf("Clock %d - %s - not running\n", int(i_clock),
+             clock_names[i_clock].c_str());
+    }
+    assert(!clock_stopped);
     double wall_time = getWallTime();
     double callClockTimes = wall_time + clock_start[i_clock];
     clock_time[i_clock] += callClockTimes;
     clock_num_call[i_clock]++;
     // Set the start to be the WallTick to check that the clock's been
     // stopped when it's next started
+    if (i_clock == check_clock) {
+      printf("HighsTimer: stopping clock %d: %s\n", int(check_clock),
+             this->clock_names[check_clock].c_str());
+    }
     clock_start[i_clock] = wall_time;
   }
 
   /**
    * @brief Read the time of a clock
    */
-  double read(HighsInt i_clock  //!< Index of the clock to be read
-  ) {
+  double read(const HighsInt i_clock = 0  //!< Index of the clock to be read
+  ) const {
     assert(i_clock >= 0);
     assert(i_clock < num_clock);
+    if (i_clock == check_clock) {
+      std::string clock_name = this->clock_names[check_clock];
+      printf("HighsTimer: reading clock %d: %s\n", int(check_clock),
+             clock_name.c_str());
+    }
     double read_time;
     if (clock_start[i_clock] < 0) {
       // The clock's been started, so find the current time
@@ -180,32 +213,28 @@ class HighsTimer {
   /**
    * @brief Return whether a clock is running
    */
-  bool running(HighsInt i_clock  //!< Index of the clock to be read
+  bool running(const HighsInt i_clock = 0  //!< Index of the clock to be read
   ) {
     assert(i_clock >= 0);
     assert(i_clock < num_clock);
+    if (i_clock == check_clock) {
+      printf("HighsTimer: querying clock %d: %s - with start record %g\n",
+             int(check_clock), this->clock_names[check_clock].c_str(),
+             clock_start[i_clock]);
+    }
     return clock_start[i_clock] < 0;
   }
 
   /**
-   * @brief Start the RunHighs clock
+   * @brief Return number of calls to a clock
    */
-  void startRunHighsClock() { start(run_highs_clock); }
-
-  /**
-   * @brief Stop the RunHighs clock
-   */
-  void stopRunHighsClock() { stop(run_highs_clock); }
-
-  /**
-   * @brief Read the RunHighs clock
-   */
-  double readRunHighsClock() { return read(run_highs_clock); }
-
-  /**
-   * @brief Test whether the RunHighs clock is running
-   */
-  bool runningRunHighsClock() { return running(run_highs_clock); }
+  HighsInt numCall(
+      const HighsInt i_clock = 0  //!< Index of the clock to be read
+  ) {
+    assert(i_clock >= 0);
+    assert(i_clock < num_clock);
+    return clock_num_call[i_clock];
+  }
 
   /**
    * @brief Report timing information for the clock indices in the list
@@ -230,7 +259,7 @@ class HighsTimer {
              //!< before an individual clock is reported
   ) {
     size_t num_clock_list_entries = clock_list.size();
-    double current_run_highs_time = readRunHighsClock();
+    double current_run_highs_time = read();
     bool non_null_report = false;
 
     // Check validity of the clock list and check no clocks are still
@@ -244,7 +273,12 @@ class HighsTimer {
       assert(iClock < num_clock);
       // Check that the clock's not still running. It should be set to
       // getWallTime() >= 0 (or initialised to initial_clock_start > 0)
-      assert(clock_start[iClock] > 0);
+      const bool clock_stopped = clock_start[iClock] > 0;
+      if (!clock_stopped) {
+        printf("Clock %d - %s - still running\n", int(iClock),
+               clock_names[iClock].c_str());
+      }
+      assert(clock_stopped);
       sum_calls += clock_num_call[iClock];
       sum_clock_times += clock_time[iClock];
     }
@@ -265,7 +299,7 @@ class HighsTimer {
     non_null_report = true;
 
     // Report one line per clock, the time, number of calls and time per call
-    printf("%s-time  Operation                       :    Time     ( Total",
+    printf("\n%s-time  Operation                       :    Time     ( Total",
            grep_stamp);
     if (ideal_sum_time > 0) printf(";  Ideal");
     printf(";  Local):    Calls  Time/Call\n");
@@ -278,7 +312,11 @@ class HighsTimer {
       double time_per_call = 0;
       if (clock_num_call[iClock] > 0) {
         time_per_call = time / clock_num_call[iClock];
-        if (percent_sum_clock_times[i] >= tolerance_percent_report) {
+        const bool report_time =
+            tolerance_percent_report > 0
+                ? percent_sum_clock_times[i] >= tolerance_percent_report
+                : clock_num_call[iClock] > 0;
+        if (report_time) {
           printf("%s-time  %-32s: %11.4e (%5.1f%%", grep_stamp,
                  clock_names[iClock].c_str(), time, percent_run_highs);
           if (ideal_sum_time > 0) {
@@ -309,11 +347,14 @@ class HighsTimer {
   /**
    * @brief Return the current wall-clock time
    */
-  double getWallTime() {
+  double getWallTime() const {
     using namespace std::chrono;
-    return duration_cast<duration<double> >(
-               wall_clock::now().time_since_epoch())
-        .count();
+    const double wall_time = kNoClockCalls
+                                 ? 0
+                                 : duration_cast<duration<double> >(
+                                       wall_clock::now().time_since_epoch())
+                                       .count();
+    return wall_time;
   }
 
   virtual ~HighsTimer() = default;
@@ -331,10 +372,7 @@ class HighsTimer {
   std::vector<double> clock_start;
   std::vector<double> clock_time;
   std::vector<std::string> clock_names;
-  std::vector<std::string> clock_ch3_names;
-  // The index of the RunHighsClock - should always be 0
-  HighsInt run_highs_clock;
-  // Fundamental Highs clocks
+  // Fundamental clocks
   HighsInt presolve_clock;
   HighsInt solve_clock;
   HighsInt postsolve_clock;

casadi/include/highs/util/HighsUtils.h

@@ -2,9 +2,6 @@
 /*                                                                       */
 /*    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                     */
 /*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
@@ -207,4 +204,14 @@ void highsAssert(const bool assert_condition, const std::string message = "");
 // If pause_condition is true, then keyboard input is required. Allows
 // breakpoints in VScode where optimization might prevent them.
 bool highsPause(const bool pause_condition, const std::string message = "");
+
+// Utility for computing fractional part
+template <typename T>
+inline T fractionality(T input, T* intval = nullptr) {
+  using std::abs;
+  using std::round;
+  T val = round(input);
+  if (intval != nullptr) *intval = val;
+  return abs(input - val);
+}
 #endif  // UTIL_HIGHSUTILS_H_

casadi/include/highs/util/stringutil.h

@@ -2,9 +2,6 @@
 /*                                                                       */
 /*    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                     */
 /*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
@@ -26,15 +23,20 @@ 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);
-std::string& rtrim(std::string& str, const std::string& chars = non_chars);
-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, size_t end, const std::string& chars = non_chars);
+void toupper(std::string& str);
+
+const std::string default_non_chars = "\t\n\v\f\r ";
+std::string& ltrim(std::string& str,
+                   const std::string& chars = default_non_chars);
+std::string& rtrim(std::string& str,
+                   const std::string& chars = default_non_chars);
+std::string& trim(std::string& str,
+                  const std::string& chars = default_non_chars);
+
+bool is_empty(std::string& str, const std::string& chars = default_non_chars);
+bool is_empty(char c, const std::string& chars = default_non_chars);
+bool is_end(std::string& str, size_t end,
+            const std::string& chars = default_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.