casadi 3.6.3__cp311-none-manylinux2014_i686.whl → 3.6.4__cp311-none-manylinux2014_i686.whl

casadi/include/highs/util/HVector.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 /**@file util/HVector.h
  * @brief Vector structure for HiGHS

casadi/include/highs/util/HVectorBase.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 /**@file util/HVector.h
  * @brief Vector structure for HiGHS

casadi/include/highs/util/HighsCDouble.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
 /**@file util/HighsCDouble.h

casadi/include/highs/util/HighsComponent.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 /**@file HighsComponent.h
  * @brief The HiGHS class

casadi/include/highs/util/HighsDataStack.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 /**@file util/HighsDataStack.h
  * @brief A stack of unstructured data stored as bytes
@@ -23,7 +21,7 @@
 
 #include "util/HighsInt.h"
 
-#if __GNUG__ && __GNUC__ < 5
+#if __GNUG__ && __GNUC__ < 5 && !defined(__clang__)
 #define IS_TRIVIALLY_COPYABLE(T) __has_trivial_copy(T)
 #else
 #define IS_TRIVIALLY_COPYABLE(T) std::is_trivially_copyable<T>::value

casadi/include/highs/util/HighsDisjointSets.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 #ifndef HIGHS_UTIL_DISJOINT_SETS_H_
 #define HIGHS_UTIL_DISJOINT_SETS_H_
@@ -46,9 +44,9 @@ class HighsDisjointSets {
   }
 
   HighsInt getSet(HighsInt item) {
-    assert(item >= 0 && item < sets.size());
+    assert(item >= 0 && item < (HighsInt)sets.size());
     HighsInt repr = sets[item];
-    assert(repr >= 0 && repr < sets.size());
+    assert(repr >= 0 && repr < (HighsInt)sets.size());
 
     if (repr != sets[repr]) {
       do {
@@ -75,16 +73,16 @@ class HighsDisjointSets {
   }
 
   void merge(HighsInt item1, HighsInt item2) {
-    assert(item1 >= 0 && item1 < sets.size());
-    assert(item2 >= 0 && item2 < sets.size());
+    assert(item1 >= 0 && item1 < (HighsInt)sets.size());
+    assert(item2 >= 0 && item2 < (HighsInt)sets.size());
 
     HighsInt repr1 = getSet(item1);
     assert(sets[repr1] == repr1);
-    assert(repr1 >= 0 && repr1 < sets.size());
+    assert(repr1 >= 0 && repr1 < (HighsInt)sets.size());
 
     HighsInt repr2 = getSet(item2);
     assert(sets[repr2] == repr2);
-    assert(repr2 >= 0 && repr2 < sets.size());
+    assert(repr2 >= 0 && repr2 < (HighsInt)sets.size());
     assert(sizes.size() == sets.size());
 
     if (repr1 == repr2) return;

casadi/include/highs/util/HighsHash.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 #ifndef HIGHS_UTIL_HASH_H_
 #define HIGHS_UTIL_HASH_H_
@@ -31,11 +29,15 @@
 #ifdef HIGHS_HAVE_BITSCAN_REVERSE
 #include <intrin.h>
 #pragma intrinsic(_BitScanReverse)
+#ifdef _WIN64
 #pragma intrinsic(_BitScanReverse64)
 #pragma intrinsic(__popcnt64)
+#else
+#pragma intrinsic(__popcnt)
+#endif
 #endif
 
-#if __GNUG__ && __GNUC__ < 5
+#if __GNUG__ && __GNUC__ < 5 && !defined(__clang__)
 #define IS_TRIVIALLY_COPYABLE(T) __has_trivial_copy(T)
 #else
 #define IS_TRIVIALLY_COPYABLE(T) std::is_trivially_copyable<T>::value
@@ -109,7 +111,14 @@ struct HighsHashHelpers {
 #elif defined(HIGHS_HAVE_BITSCAN_REVERSE)
   static int log2i(uint64_t n) {
     unsigned long result;
+#ifdef _WIN64
     _BitScanReverse64(&result, n);
+#else
+    if (_BitScanReverse(&result, (n >> 32)))
+      result += 32;
+    else
+      _BitScanReverse(&result, (n & 0xffffffffu));
+#endif
     return result;
   }
 
@@ -119,7 +128,13 @@ struct HighsHashHelpers {
     return result;
   }
 
-  static int popcnt(uint64_t x) { return __popcnt64(x); }
+  static int popcnt(uint64_t x) {
+#ifdef _WIN64
+    return __popcnt64(x);
+#else
+    return __popcnt(x & 0xffffffffu) + __popcnt(x >> 32);
+#endif
+  }
 #else
   // integer log2 algorithm without floating point arithmetic. It uses an
   // unrolled loop and requires few instructions that can be well optimized.
@@ -742,7 +757,7 @@ struct HighsHashHelpers {
     // defined to be UINT16_MAX - |exponent| when the exponent is negative.
     // casting the exponent to a uint32_t directly would give wrong promotion
     // of negative exponents as UINT32_MAX - |exponent| and take up to many bits
-    // or possibly loose information after the 16 bit shift. For the mantissa we
+    // or possibly lose information after the 16 bit shift. For the mantissa we
     // take the 15 most significant bits, even though we could squeeze out a few
     // more of the exponent. We don't need more bits as this would make the
     // buckets very small and might miss more values that are equal within

casadi/include/highs/util/HighsHashTree.h

@@ -2,17 +2,17 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 #ifndef HIGHS_UTIL_HASH_TREE_H_
 #define HIGHS_UTIL_HASH_TREE_H_
 
+#include <stdexcept>
+
 #include "util/HighsHash.h"
 
 using std::memcpy;
@@ -338,6 +338,8 @@ class HighsHashTree {
           // is estimated above the threshold to merge when the parent checks
           // its children after deletion
           return kBranchFactor;
+        default:
+          throw std::logic_error("Unexpected type in hash tree");
       }
     }
 
@@ -360,6 +362,8 @@ class HighsHashTree {
           // is estimated above the threshold to merge when the parent checks
           // its children after deletion
           return kBranchFactor;
+        default:
+          throw std::logic_error("Unexpected type in hash tree");
       }
     }
 
@@ -487,6 +491,9 @@ class HighsHashTree {
       case kInnerLeafSizeClass4:
         mergeIntoLeaf(leaf, mergeNode.getInnerLeafSizeClass4(), hashPos);
         delete mergeNode.getInnerLeafSizeClass4();
+        break;
+      default:
+        break;
     }
   }
 
@@ -577,7 +584,10 @@ class HighsHashTree {
             ++i;
           } while (i < leaf->size && get_first_chunk16(leaf->hashes[i]) == pos);
         }
+        break;
       }
+      default:
+        break;
     }
 
     return nullptr;
@@ -882,6 +892,9 @@ class HighsHashTree {
                   branch->child[pos].getInnerLeafSizeClass4()->insert_entry(
                       compute_hash(leaf->entries[i].key()), hashPos + 1,
                       leaf->entries[i]);
+                  break;
+                default:
+                  break;
               }
             }
           }
@@ -1137,11 +1150,15 @@ class HighsHashTree {
 
         return nullptr;
       }
+      default:
+        throw std::logic_error("Unexpected type in hash tree");
     }
   }
 
   static void destroy_recurse(NodePtr node) {
     switch (node.getType()) {
+      case kEmpty:
+        break;
       case kListLeaf: {
         ListLeaf* leaf = node.getListLeaf();
         ListNode* iter = leaf->first.next;
@@ -1149,7 +1166,7 @@ class HighsHashTree {
         while (iter != nullptr) {
           ListNode* next = iter->next;
           delete iter;
-          iter = iter->next;
+          iter = next;
         }
 
         break;
@@ -1180,8 +1197,7 @@ class HighsHashTree {
   static NodePtr copy_recurse(NodePtr node) {
     switch (node.getType()) {
       case kEmpty:
-        assert(false);
-        break;
+        throw std::logic_error("Unexpected node type in empty in hash tree");
       case kListLeaf: {
         ListLeaf* leaf = node.getListLeaf();
 
@@ -1224,6 +1240,8 @@ class HighsHashTree {
 
         return newBranch;
       }
+      default:
+        throw std::logic_error("Unexpected type in hash tree");
     }
   }
 

casadi/include/highs/util/HighsInt.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 /**@file HighsInt.h
  * @brief The definition for the integer type to use

casadi/include/highs/util/HighsIntegers.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 #ifndef HIGHS_UTIL_INTEGERS_H_
 #define HIGHS_UTIL_INTEGERS_H_

casadi/include/highs/util/HighsLinearSumBounds.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 /**@file util/HighsLinearSumBounds.h
  * @brief Data structure to compute and update bounds on a linear sum of

casadi/include/highs/util/HighsMatrixPic.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 /**@file util/HighsMatrixPic.h
  * @brief Class-independent utilities for HiGHS

casadi/include/highs/util/HighsMatrixSlice.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 /**@file util/HighsMatrixSlice.h
  * @brief Provides a uniform interface to iterate rows and columns in different

casadi/include/highs/util/HighsMatrixUtils.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 /**@file util/HighsMatrixUtils.h
  * @brief Class-independent utilities for HiGHS

casadi/include/highs/util/HighsRandom.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 /**@file util/HighsRandom.h
  * @brief Random number generators for HiGHS

casadi/include/highs/util/HighsRbTree.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 #ifndef HIGHS_RBTREE_H_
 #define HIGHS_RBTREE_H_

casadi/include/highs/util/HighsSort.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 /**@file util/HighsSort.h
  * @brief Sorting routines for HiGHS

casadi/include/highs/util/HighsSparseMatrix.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 /**@file util/HighsSparseMatrix.h
  * @brief
@@ -69,6 +67,8 @@ class HighsSparseMatrix {
                      const std::string matrix_name,
                      const double small_matrix_value,
                      const double large_matrix_value);
+  void assessSmallValues(const HighsLogOptions& log_options,
+                         const double small_matrix_value);
   bool hasLargeValue(const double large_matrix_value);
   void considerColScaling(const HighsInt max_scale_factor_exponent,
                           double* col_scale);
@@ -84,12 +84,16 @@ class HighsSparseMatrix {
                    const HighsInt to_col);
   void createColwise(const HighsSparseMatrix& matrix);
   void createRowwise(const HighsSparseMatrix& matrix);
-  void productQuad(vector<double>& result, const vector<double>& row,
+  void alphaProductPlusY(const double alpha, const std::vector<double>& x,
+                         std::vector<double>& y,
+                         const bool transpose = false) const;
+  void product(vector<double>& result, const vector<double>& x) const;
+  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, vector<HighsInt>& result_index,
-      const HVector& column,
-      const HighsInt debug_report = kDebugReportOff) const;
+      const HVector& x, const HighsInt debug_report = kDebugReportOff) const;
   // Methods for PRICE, including the creation and updating of the
   // partitioned row-wise matrix
   void createRowwisePartitioned(const HighsSparseMatrix& matrix,

casadi/include/highs/util/HighsSparseVectorSum.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 #ifndef HIGHS_SPARSE_VECTOR_SUM_H_
 #define HIGHS_SPARSE_VECTOR_SUM_H_

casadi/include/highs/util/HighsSplay.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 #ifndef HIGHS_SPLAY_H_
 #define HIGHS_SPLAY_H_

casadi/include/highs/util/HighsTimer.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 /**@file util/HighsTimer.h
  * @brief Profiling facility for computational components in HiGHS
@@ -16,6 +14,7 @@
 #ifndef UTIL_HIGHSTIMER_H_
 #define UTIL_HIGHSTIMER_H_
 
+#include <algorithm>
 #include <cassert>
 #include <chrono>
 #include <cstdio>

casadi/include/highs/util/HighsUtils.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 /**@file util/HUtils.h
  * @brief Class-independent utilities for HiGHS
@@ -129,6 +127,8 @@ double highsRelativeDifference(const double v0, const double v1);
  * @brief Analyse the values of a vector, assessing how many are in
  * each power of ten, and possibly analyse the distribution of
  * different values
+ *
+ * NB If log_options is a null pointer then printf is used
  */
 void analyseVectorValues(
     const HighsLogOptions* log_options,
@@ -142,6 +142,16 @@ void analyseVectorValues(
                    //!< different values in the vector
 );
 
+void analyseVectorValues(
+    const HighsLogOptions* log_options,
+    const std::string message,         //!< Message to be printed
+    HighsInt vecDim,                   //!< Dimension of vector
+    const std::vector<HighsInt>& vec,  //!< Vector of values
+    std::string model_name =
+        "Unknown"  //!< Model name to report if analysing distribution of
+                   //!< different values in the vector
+);
+
 void analyseMatrixSparsity(
     const HighsLogOptions& log_options,
     const char* message,                  //!< Message to be printed