casadi 3.6.4__cp312-none-macosx_10_13_x86_64.macosx_10_13_intel.whl

casadi/include/highs/util/HSet.h

@@ -0,0 +1,92 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/**@file util/HSet.h
+ * @brief Set structure for HiGHS.
+ */
+
+// Maintains an unordered set of distinct non-negative integer entries,
+// allowing entries to be removed from the set at cost O(1)
+#ifndef UTIL_HSET_H_
+#define UTIL_HSET_H_
+
+#include <cstdio>
+#include <vector>
+
+#include "util/HighsInt.h"
+
+// #include <iostream>
+
+using std::vector;
+
+const HighsInt min_entry = 0;
+const HighsInt no_pointer = min_entry - 1;
+/**
+ * @brief Class for the set structure for HiGHS
+ */
+class HSet {
+ public:
+  /**
+   * @brief Initialise a set. Neither limit is binding, but more
+   * efficient memory-wise if known in advance
+   */
+  bool setup(const HighsInt size,  //!< Dimension of the set to be initialised
+             const HighsInt max_entry,  //!< Maximum entry to be in the set.
+             const bool output_flag = false,  //!< Option for output
+             FILE* log_stream = NULL,         //!< File stream for output
+             const bool debug = false,        //!< Debug mode
+             const bool allow_assert = true   //!< Allow asserts in debug
+  );
+
+  /**
+   * @brief Clear the set
+   */
+  void clear();
+  /**
+   * @brief Add entry to the set
+   */
+  bool add(const HighsInt entry);
+  /**
+   * @brief Remove entry from the set
+   */
+  bool remove(const HighsInt entry);
+  /**
+   * @brief Returns whether entry is in the set
+   */
+  bool in(const HighsInt entry) const;
+  /**
+   * @brief Returns the number of entries in the set
+   */
+  const HighsInt& count() const { return count_; }
+  /**
+   * @brief Returns the entries in the set
+   */
+  const vector<HighsInt>& entry() const { return entry_; }
+  /**
+   * @brief Print out the set and pointer entries not set to no_pointer
+   */
+  void print() const;
+  /**
+   * @brief Debug the set
+   */
+  bool debug() const;
+
+ private:
+  HighsInt count_ = 0;      //!< Number of entries
+  vector<HighsInt> entry_;  //!< Entries
+  bool setup_ = false;
+  bool debug_ = false;
+  bool allow_assert_ = true;
+  bool output_flag_ = false;
+  FILE* log_file_;
+  HighsInt max_entry_;        //!< Maximum entry to be in the set.
+  vector<HighsInt> pointer_;  //!< Set of pointers into the set
+};
+#endif /* UTIL_HSET_H_ */

casadi/include/highs/util/HVector.h

@@ -0,0 +1,25 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/**@file util/HVector.h
+ * @brief Vector structure for HiGHS
+ */
+#ifndef UTIL_HVECTOR_H_
+#define UTIL_HVECTOR_H_
+
+#include "util/HVectorBase.h"
+#include "util/HighsCDouble.h"
+
+using HVector = HVectorBase<double>;
+using HVectorQuad = HVectorBase<HighsCDouble>;
+using HVector_ptr = HVector*;
+using HVectorQuad_ptr = HVectorQuad*;
+
+#endif /* UTIL_HVECTOR_H_ */

casadi/include/highs/util/HVectorBase.h

@@ -0,0 +1,105 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/**@file util/HVector.h
+ * @brief Vector structure for HiGHS
+ */
+#ifndef UTIL_HVECTOR_BASE_H_
+#define UTIL_HVECTOR_BASE_H_
+
+#include <vector>
+
+#include "util/HighsInt.h"
+
+// using std::map;
+using std::vector;
+
+/**
+ * @brief Class for the vector structure for HiGHS
+ */
+template <typename Real>
+class HVectorBase {
+ public:
+  /**
+   * @brief Initialise a vector
+   */
+  void setup(HighsInt size_  //!< Dimension of the vector to be initialised
+  );
+
+  /**
+   * @brief Clear the vector - or just its scalars
+   *
+   */
+  void clear();
+  void clearScalars();
+
+  HighsInt size;           //!< Dimension of the vector
+  HighsInt count;          //!< Number of nonzeros
+  vector<HighsInt> index;  //!< Packed indices of nonzeros
+  vector<Real> array;      //!< Full-length array of values
+
+  double synthetic_tick;  //!< Synthetic clock for operations with this vector
+
+  // For update
+  vector<char> cwork;       //!< char working buffer for UPDATE
+  vector<HighsInt> iwork;   //!< integer working buffer for UPDATE
+  HVectorBase<Real>* next;  //!< Allows vectors to be linked for PAMI
+
+  /*
+   * Zero values in Vector.array that exceed kHighsTiny in magnitude
+   */
+  void tight();
+
+  /**
+   * @brief Packing (if packFlag set): Pack values/indices in Vector.array into
+   * packValue/Index
+   *
+   */
+  void pack();
+
+  /**
+   * @brief Possibly determine the indices from scratch by passing
+   * through the array
+   *
+   */
+  void reIndex();
+
+  bool packFlag;               //!< Flag to indicate whether to pack or not
+  HighsInt packCount;          //!< Number of nonzeros packed
+  vector<HighsInt> packIndex;  //!< Packed indices
+  vector<Real> packValue;      //!< Packed values
+
+  /**
+   * @brief Copy from another HVector structure to this instanc
+   */
+  template <typename FromReal>
+  void copy(const HVectorBase<FromReal>*
+                from  //!< Source of HVector structure to be copied
+  );
+
+  /**
+   * @brief Compute the squared 2-norm of the vector
+   */
+  Real norm2() const;
+
+  /**
+   * @brief Add a multiple pivotX of *pivot into this vector,
+   * maintaining indices of nonzeros but not tracking cancellation
+   */
+  template <typename RealPivX, typename RealPiv>
+  void saxpy(const RealPivX pivotX,  //!< The multiple of *pivot to be added
+             const HVectorBase<RealPiv>*
+                 pivot  //!< The vector whose multiple is to be added
+  );
+
+  bool isEqual(const HVectorBase<Real>& v0);
+};
+
+#endif /* UTIL_HVECTOR_BASE_H_ */

casadi/include/highs/util/HighsCDouble.h

@@ -0,0 +1,310 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+/**@file util/HighsCDouble.h
+ * @brief Quad precision type implemented with two standard double precision
+ *        representing the value and a compensation term
+ */
+#ifndef UTIL_HIGHSCDOUBLE_H_
+#define UTIL_HIGHSCDOUBLE_H_
+
+#include <cmath>
+#include <cstdint>
+
+/// A compensated double number achieving roughly quad precision on the
+/// supported operations
+
+class HighsCDouble {
+ private:
+  double hi;
+  double lo;
+
+  // The following functions are implemented as described in:
+  // Rump, Siegfried M. "High precision evaluation of nonlinear functions."
+  // 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).
+  static void two_sum(double& x, double& y, double a, double b) {
+    x = a + b;
+    double z = x - a;
+    y = (a - (x - z)) + (b - z);
+  }
+
+  /// splits a 53 bit double precision number into two 26 bit parts
+  /// such that x + y = a holds exactly
+  static void split(double& x, double& y, double a) {
+    constexpr double factor = double((1 << 27) + 1);
+    double c = factor * a;
+    x = c - (c - a);
+    y = a - x;
+  }
+
+  /// 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.
+  static void two_product(double& x, double& y, double a, double b) {
+    x = a * b;
+    double a1, a2, b1, b2;
+    split(a1, a2, a);
+    split(b1, b2, b);
+    y = a2 * b2 - (((x - a1 * b1) - a2 * b1) - a1 * b2);
+  }
+
+  HighsCDouble(double hi_, double lo_) : hi(hi_), lo(lo_) {}
+
+ public:
+  HighsCDouble() = default;
+
+  HighsCDouble(double val) : hi(val), lo(0.0) {}
+
+  explicit operator double() const { return hi + lo; }
+
+  HighsCDouble& operator+=(double v) {
+    double c;
+    two_sum(hi, c, v, hi);
+    lo += c;
+    return *this;
+  }
+
+  HighsCDouble& operator+=(const HighsCDouble& v) {
+    (*this) += v.hi;
+    lo += v.lo;
+    return *this;
+  }
+
+  HighsCDouble& operator-=(double v) {
+    (*this) += -v;
+    return *this;
+  }
+
+  HighsCDouble& operator-=(const HighsCDouble& v) {
+    (*this) -= v.hi;
+    lo -= v.lo;
+    return *this;
+  }
+
+  HighsCDouble& operator*=(double v) {
+    double c = lo * v;
+    two_product(hi, lo, hi, v);
+    *this += c;
+    return *this;
+  }
+
+  HighsCDouble& operator*=(const HighsCDouble& v) {
+    double c1 = hi * v.lo;
+    double c2 = lo * v.hi;
+    two_product(hi, lo, hi, v.hi);
+    *this += c1;
+    *this += c2;
+    return *this;
+  }
+
+  HighsCDouble& operator/=(double v) {
+    HighsCDouble d(hi / v, lo / v);
+    HighsCDouble c = d * v - (*this);
+    c.hi /= v;
+    c.lo /= v;
+    *this = d - c;
+    return *this;
+  }
+
+  HighsCDouble& operator/=(const HighsCDouble& v) {
+    double vdbl = v.hi + v.lo;
+    HighsCDouble d(hi / vdbl, lo / vdbl);
+    HighsCDouble c = d * v - (*this);
+    c.hi /= vdbl;
+    c.lo /= vdbl;
+    *this = d - c;
+    return *this;
+  }
+
+  HighsCDouble operator-() const { return HighsCDouble(-hi, -lo); }
+
+  HighsCDouble operator+(double v) const {
+    HighsCDouble res;
+
+    two_sum(res.hi, res.lo, hi, v);
+    res.lo += lo;
+
+    return res;
+  }
+
+  HighsCDouble operator+(const HighsCDouble& v) const {
+    HighsCDouble res = (*this) + v.hi;
+    res.lo += v.lo;
+
+    return res;
+  }
+
+  friend HighsCDouble operator+(double a, const HighsCDouble& b) {
+    return b + a;
+  }
+
+  HighsCDouble operator-(double v) const {
+    HighsCDouble res;
+
+    two_sum(res.hi, res.lo, hi, -v);
+    res.lo += lo;
+
+    return res;
+  }
+
+  HighsCDouble operator-(const HighsCDouble& v) const {
+    HighsCDouble res = (*this) - v.hi;
+    res.lo -= v.lo;
+
+    return res;
+  }
+
+  friend HighsCDouble operator-(double a, const HighsCDouble& b) {
+    return -b + a;
+  }
+
+  HighsCDouble operator*(double v) const {
+    HighsCDouble res;
+
+    two_product(res.hi, res.lo, hi, v);
+    res += lo * v;
+
+    return res;
+  }
+
+  HighsCDouble operator*(const HighsCDouble& v) const {
+    HighsCDouble res = (*this) * v.hi;
+    res += hi * v.lo;
+
+    return res;
+  }
+
+  friend HighsCDouble operator*(double a, const HighsCDouble& b) {
+    return b * a;
+  }
+
+  HighsCDouble operator/(double v) const {
+    HighsCDouble res = *this;
+
+    res /= v;
+
+    return res;
+  }
+
+  HighsCDouble operator/(const HighsCDouble& v) const {
+    HighsCDouble res = (*this);
+
+    res /= v;
+
+    return res;
+  }
+
+  friend HighsCDouble operator/(double a, const HighsCDouble& b) {
+    return HighsCDouble(a) / b;
+  }
+
+  bool operator>(const HighsCDouble& other) const {
+    return double(*this) > double(other);
+  }
+
+  bool operator>(double other) const { return double(*this) > other; }
+
+  friend bool operator>(double a, const HighsCDouble& b) {
+    return a > double(b);
+  }
+
+  bool operator<(const HighsCDouble& other) const {
+    return double(*this) < double(other);
+  }
+
+  bool operator<(double other) const { return double(*this) < other; }
+
+  friend bool operator<(double a, const HighsCDouble& b) {
+    return a < double(b);
+  }
+
+  bool operator>=(const HighsCDouble& other) const {
+    return double(*this) >= double(other);
+  }
+
+  bool operator>=(double other) const { return double(*this) >= other; }
+
+  friend bool operator>=(double a, const HighsCDouble& b) {
+    return a >= double(b);
+  }
+
+  bool operator<=(const HighsCDouble& other) const {
+    return double(*this) <= double(other);
+  }
+
+  bool operator<=(double other) const { return double(*this) <= other; }
+
+  friend bool operator<=(double a, const HighsCDouble& b) {
+    return a <= double(b);
+  }
+
+  bool operator==(const HighsCDouble& other) const {
+    return double(*this) == double(other);
+  }
+
+  bool operator==(double other) const { return double(*this) == other; }
+
+  friend bool operator==(double a, const HighsCDouble& b) {
+    return a == double(b);
+  }
+
+  bool operator!=(const HighsCDouble& other) const {
+    return double(*this) != double(other);
+  }
+
+  bool operator!=(double other) const { return double(*this) != other; }
+
+  friend bool operator!=(double a, const HighsCDouble& b) {
+    return a != double(b);
+  }
+
+  void renormalize() { two_sum(hi, lo, hi, lo); }
+
+  friend HighsCDouble abs(const HighsCDouble& v) { return v < 0 ? -v : v; }
+
+  friend HighsCDouble sqrt(const HighsCDouble& v) {
+    double c = std::sqrt(v.hi + v.lo);
+
+    // guard against division by zero
+    if (c == 0.0) return 0.0;
+
+    // calculate precise square root by newton step
+    HighsCDouble res = v / c;
+    res += c;
+    // multiplication by 0.5 is exact
+    res.hi *= 0.5;
+    res.lo *= 0.5;
+    return res;
+  }
+
+  friend HighsCDouble floor(const HighsCDouble& x) {
+    double floor_x = std::floor(double(x));
+    HighsCDouble res;
+
+    two_sum(res.hi, res.lo, floor_x, std::floor(double(x - floor_x)));
+    return res;
+  }
+
+  friend HighsCDouble ceil(const HighsCDouble& x) {
+    double ceil_x = std::ceil(double(x));
+    HighsCDouble res;
+
+    two_sum(res.hi, res.lo, ceil_x, std::ceil(double(x - ceil_x)));
+    return res;
+  }
+
+  friend HighsCDouble round(const HighsCDouble& x) { return floor(x + 0.5); }
+};
+
+#endif

casadi/include/highs/util/HighsComponent.h

@@ -0,0 +1,56 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/**@file HighsComponent.h
+ * @brief The HiGHS class
+ */
+#ifndef UTIL_HIGHS_COMPONENT_H_
+#define UTIL_HIGHS_COMPONENT_H_
+
+#include "lp_data/HighsOptions.h"
+
+// HighsComponentData is a placeholder for structs which we will keep after
+// run() is done, internally.
+struct HighsComponentData {
+  bool is_valid = false;
+};
+
+// HighsComponentInfo is a placeholder for details we want to query from outside
+// of HiGHS like execution information.
+struct HighsComponentInfo {
+  bool is_valid = false;
+};
+
+// HighsComponentOptions is a placeholder for options specific to this component
+struct HighsComponentOptions {
+  bool is_valid = false;
+};
+
+class HighsComponent {
+ public:
+  virtual void clear() = 0;
+  HighsStatus run();
+  HighsStatus setOptions(const HighsOptions& options);
+
+  const HighsComponentInfo& getInfo() { return info_; }
+  const HighsComponentData& getData() { return data_; }
+  const HighsComponentOptions& getOptions() { return options_; }
+
+  virtual ~HighsComponent() = default;
+
+ private:
+  //  bool has_run_ = false;
+
+  HighsComponentInfo info_;
+  HighsComponentData data_;
+  HighsComponentOptions options_;
+};
+
+#endif

casadi/include/highs/util/HighsDataStack.h

@@ -0,0 +1,86 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/**@file util/HighsDataStack.h
+ * @brief A stack of unstructured data stored as bytes
+ */
+
+#ifndef UTIL_HIGHS_DATA_STACK_H_
+#define UTIL_HIGHS_DATA_STACK_H_
+
+#include <cstring>
+#include <type_traits>
+#include <vector>
+
+#include "util/HighsInt.h"
+
+#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
+#endif
+
+class HighsDataStack {
+  std::vector<char> data;
+  HighsInt position;
+
+ public:
+  void resetPosition() { position = data.size(); }
+
+  template <typename T,
+            typename std::enable_if<IS_TRIVIALLY_COPYABLE(T), int>::type = 0>
+  void push(const T& r) {
+    std::size_t dataSize = data.size();
+    data.resize(dataSize + sizeof(T));
+    std::memcpy(data.data() + dataSize, &r, sizeof(T));
+  }
+
+  template <typename T,
+            typename std::enable_if<IS_TRIVIALLY_COPYABLE(T), int>::type = 0>
+  void pop(T& r) {
+    position -= sizeof(T);
+    std::memcpy(&r, data.data() + position, sizeof(T));
+  }
+
+  template <typename T>
+  void push(const std::vector<T>& r) {
+    std::size_t offset = data.size();
+    std::size_t numData = r.size();
+    // store the data
+    data.resize(offset + numData * sizeof(T) + sizeof(std::size_t));
+    if (!r.empty())
+      std::memcpy(data.data() + offset, r.data(), numData * sizeof(T));
+    // store the vector size
+    offset += numData * sizeof(T);
+    std::memcpy(data.data() + offset, &numData, sizeof(std::size_t));
+  }
+
+  template <typename T>
+  void pop(std::vector<T>& r) {
+    // pop the vector size
+    position -= sizeof(std::size_t);
+    std::size_t numData;
+    std::memcpy(&numData, &data[position], sizeof(std::size_t));
+    // pop the data
+    if (numData == 0) {
+      r.clear();
+    } else {
+      r.resize(numData);
+      position -= numData * sizeof(T);
+      std::memcpy(r.data(), data.data() + position, numData * sizeof(T));
+    }
+  }
+
+  void setPosition(HighsInt position_) { this->position = position_; }
+
+  HighsInt getCurrentDataSize() const { return data.size(); }
+};
+
+#endif