casadi 3.6.4__cp310-none-macosx_11_0_arm64.whl → 3.6.6__cp310-none-macosx_11_0_arm64.whl

casadi/include/include/highs/util/HighsSort.h

@@ -1,134 +0,0 @@
-/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
-/*                                                                       */
-/*    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/HighsSort.h
- * @brief Sorting routines for HiGHS
- */
-#ifndef UTIL_HIGHSSORT_H_
-#define UTIL_HIGHSSORT_H_
-
-#include <vector>
-
-#include "lp_data/HConst.h"
-
-using std::vector;
-
-void addToDecreasingHeap(HighsInt& n, HighsInt mx_n, vector<double>& heap_v,
-                         vector<HighsInt>& heap_ix, double v, HighsInt ix);
-void sortDecreasingHeap(const HighsInt n, vector<double>& heap_v,
-                        vector<HighsInt>& heap_ix);
-/**
- * @brief Sort values[1..n] of an array by increasing value
- */
-void maxheapsort(HighsInt* heap_v,  //!< HighsInt values to be sorted
-                 HighsInt n         //!< Number of values to be sorted
-);
-/**
- * @brief Sort values[1..n] of an array by increasing value with corresponding
- * indices
- */
-void maxheapsort(
-    HighsInt* heap_v,  //!< Values to be sorted
-    HighsInt* heap_i,  //!< Indices corrresponding to (sorted) values
-    HighsInt n         //!< Number of values to be sorted
-);
-/**
- * @brief Sort values[1..n] of an array by increasing value with corresponding
- * indices
- */
-void maxheapsort(
-    double* heap_v,    //!< Values to be sorted
-    HighsInt* heap_i,  //!< Indices corrresponding to (sorted) values
-    HighsInt n         //!< Number of values to be sorted
-);
-/**
- * @brief Build a value heap for sorting values[1..n] of an array by increasing
- * value
- */
-void buildMaxheap(HighsInt* heap_v,  //!< HighsInt values to be sorted
-                  HighsInt n         //!< Number of values to be sorted
-);
-/**
- * @brief Build a value-index heap for sorting values[1..n] of an array by
- * increasing value
- */
-void buildMaxheap(
-    HighsInt* heap_v,  //!< Values to be sorted
-    HighsInt* heap_i,  //!< Indices corrresponding to (sorted) values
-    HighsInt n         //!< Number of values to be sorted
-);
-/**
- * @brief Build a value-index heap for sorting values[1..n] of an array by
- * increasing value
- */
-void buildMaxheap(
-    double* heap_v,    //!< Values to be sorted
-    HighsInt* heap_i,  //!< Indices corrresponding to (sorted) values
-    HighsInt n         //!< Number of values to be sorted
-);
-/**
- * @brief Sort by increasing value a heap built with buildMaxheap
- */
-void maxHeapsort(HighsInt* heap_v,  //!< HighsInt values to be sorted
-                 HighsInt n         //!< Number of values to be sorted
-);
-/**
- * @brief Sort by increasing value a heap built with buildMaxheap
- */
-void maxHeapsort(
-    HighsInt* heap_v,  //!< Values to be sorted
-    HighsInt* heap_i,  //!< Indices corrresponding to (sorted) values
-    HighsInt n         //!< Number of values to be sorted
-);
-/**
- * @brief Sort by increasing value a heap built with buildMaxheap
- */
-void maxHeapsort(
-    double* heap_v,    //!< Values to be sorted
-    HighsInt* heap_i,  //!< Indices corrresponding to (sorted) values
-    HighsInt n         //!< Number of values to be sorted
-);
-/**
- * @brief Heapify function for sorting by increasing value
- */
-void maxHeapify(HighsInt* heap_v, HighsInt i, HighsInt n);
-
-/**
- * @brief Heapify function for sorting by increasing value
- */
-void maxHeapify(HighsInt* heap_v, HighsInt* heap_i, HighsInt i, HighsInt n);
-
-/**%
- * @brief Heapify function for sorting by increasing value
- */
-void maxHeapify(double* heap_v, HighsInt* heap_i, HighsInt i, HighsInt n);
-
-/**
- * @brief Check that a set of integers is in increasing order and in bounds
- */
-bool increasingSetOk(const vector<HighsInt>& set,
-                     const HighsInt set_entry_lower,
-                     const HighsInt set_entry_upper, bool strict);
-
-/**
- * @brief Check that a set of doubles is in increasing order and in bounds
- */
-bool increasingSetOk(const vector<double>& set, const double set_entry_lower,
-                     const double set_entry_upper, bool strict);
-
-void sortSetData(const HighsInt num_entries, vector<HighsInt>& set,
-                 const double* data0, const double* data1, const double* data2,
-                 double* sorted_data0, double* sorted_data1,
-                 double* sorted_data2);
-
-void sortSetData(const HighsInt num_entries, vector<HighsInt>& set,
-                 const HighsVarType* data0, HighsVarType* sorted_data0);
-
-#endif /* UTIL_HIGHSSORT_H_ */

casadi/include/include/highs/util/HighsSparseMatrix.h

@@ -1,144 +0,0 @@
-/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
-/*                                                                       */
-/*    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/HighsSparseMatrix.h
- * @brief
- */
-#ifndef LP_DATA_HIGHS_SPARSE_MATRIX_H_
-#define LP_DATA_HIGHS_SPARSE_MATRIX_H_
-
-#include <vector>
-
-#include "lp_data/HConst.h"
-#include "lp_data/HStruct.h"  //For  HighsScale
-#include "lp_data/HighsStatus.h"
-#include "simplex/SimplexStruct.h"  //For SimplexScale until scaling is HighsScale
-#include "util/HVector.h"
-#include "util/HVectorBase.h"
-#include "util/HighsSparseVectorSum.h"
-#include "util/HighsUtils.h"
-
-const double kHyperPriceDensity = 0.1;
-const HighsInt kDebugReportOff = -2;
-const HighsInt kDebugReportAll = -1;
-
-class HighsSparseMatrix {
- public:
-  HighsSparseMatrix() { clear(); }
-  MatrixFormat format_;
-  HighsInt num_col_;
-  HighsInt num_row_;
-  std::vector<HighsInt> start_;
-  std::vector<HighsInt> p_end_;
-  std::vector<HighsInt> index_;
-  std::vector<double> value_;
-
-  bool operator==(const HighsSparseMatrix& matrix) const;
-  void clear();
-  void exactResize();
-  bool formatOk() const { return (this->isColwise() || this->isRowwise()); };
-  bool isRowwise() const;
-  bool isColwise() const;
-  HighsInt numNz() const;
-  void range(double& min_value, double& max_value) const;
-  void setFormat(const MatrixFormat desired_format);
-  void ensureColwise();
-  void ensureRowwise();
-
-  void addVec(const HighsInt num_nz, const HighsInt* index, const double* value,
-              const double multiple = 1);
-  void addCols(const HighsSparseMatrix new_cols,
-               const int8_t* in_partition = NULL);
-  void addRows(const HighsSparseMatrix new_rows,
-               const int8_t* in_partition = NULL);
-
-  void deleteCols(const HighsIndexCollection& index_collection);
-  void deleteRows(const HighsIndexCollection& index_collection);
-  HighsStatus assessDimensions(const HighsLogOptions& log_options,
-                               const std::string matrix_name);
-  HighsStatus assess(const HighsLogOptions& log_options,
-                     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);
-  void considerRowScaling(const HighsInt max_scale_factor_exponent,
-                          double* row_scale);
-  void scaleCol(const HighsInt col, const double colScale);
-  void scaleRow(const HighsInt row, const double rowScale);
-  void applyScale(const HighsScale& scale);
-  void applyRowScale(const HighsScale& scale);
-  void applyColScale(const HighsScale& scale);
-  void unapplyScale(const HighsScale& scale);
-  void createSlice(const HighsSparseMatrix& matrix, const HighsInt from_col,
-                   const HighsInt to_col);
-  void createColwise(const HighsSparseMatrix& matrix);
-  void createRowwise(const HighsSparseMatrix& matrix);
-  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& 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,
-                                const int8_t* in_partition = NULL);
-  bool debugPartitionOk(const int8_t* in_partition) const;
-  void priceByColumn(const bool quad_precision, HVector& result,
-                     const HVector& column,
-                     const HighsInt debug_report = kDebugReportOff) const;
-  void priceByRow(const bool quad_precision, HVector& result,
-                  const HVector& column,
-                  const HighsInt debug_report = kDebugReportOff) const;
-  void priceByRowWithSwitch(
-      const bool quad_precision, HVector& result, const HVector& column,
-      const double expected_density, const HighsInt from_index,
-      const double switch_density,
-      const HighsInt debug_report = kDebugReportOff) const;
-  void update(const HighsInt var_in, const HighsInt var_out,
-              const HighsSparseMatrix& matrix);
-  double computeDot(const HVector& column, const HighsInt use_col) const {
-    return computeDot(column.array, use_col);
-  }
-
-  double computeDot(const std::vector<double>& array,
-                    const HighsInt use_col) const;
-  void collectAj(HVector& column, const HighsInt use_col,
-                 const double multiplier) const;
-
- private:
-  void priceByRowDenseResult(
-      std::vector<double>& result, const HVector& column,
-      const HighsInt from_index,
-      const HighsInt debug_report = kDebugReportOff) const;
-  void priceByRowDenseResult(
-      std::vector<HighsCDouble>& result, const HVector& column,
-      const HighsInt from_index,
-      const HighsInt debug_report = kDebugReportOff) const;
-  void debugReportRowPrice(const HighsInt iRow, const double multiplier,
-                           const HighsInt to_iEl,
-                           const vector<double>& result) const;
-  void debugReportRowPrice(const HighsInt iRow, const double multiplier,
-                           const HighsInt to_iEl,
-                           const vector<HighsCDouble>& result) const;
-  void debugReportRowPrice(const HighsInt iRow, const double multiplier,
-                           const HighsInt to_iEl,
-                           HighsSparseVectorSum& sum) const;
-};
-
-#endif

casadi/include/include/highs/util/HighsSparseVectorSum.h

@@ -1,98 +0,0 @@
-/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
-/*                                                                       */
-/*    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                     */
-/*                                                                       */
-/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
-#ifndef HIGHS_SPARSE_VECTOR_SUM_H_
-#define HIGHS_SPARSE_VECTOR_SUM_H_
-
-#include <algorithm>
-#include <cassert>
-#include <limits>
-#include <vector>
-
-#include "util/HighsCDouble.h"
-#include "util/HighsInt.h"
-
-class HighsSparseVectorSum {
- public:
-  std::vector<HighsCDouble> values;
-  std::vector<HighsInt> nonzeroinds;
-  HighsSparseVectorSum() = default;
-
-  HighsSparseVectorSum(HighsInt dimension) { setDimension(dimension); }
-
-  void setDimension(HighsInt dimension) {
-    values.resize(dimension);
-    nonzeroinds.reserve(dimension);
-  }
-
-  void add(HighsInt index, double value) {
-    assert(index >= 0 && index < (HighsInt)values.size());
-    if (values[index] != 0.0) {
-      values[index] += value;
-    } else {
-      values[index] = value;
-      nonzeroinds.push_back(index);
-    }
-
-    if (values[index] == 0.0)
-      values[index] = std::numeric_limits<double>::min();
-  }
-
-  void add(HighsInt index, HighsCDouble value) {
-    if (values[index] != 0.0) {
-      values[index] += value;
-    } else {
-      values[index] = value;
-      nonzeroinds.push_back(index);
-    }
-
-    if (values[index] == 0.0)
-      values[index] = std::numeric_limits<double>::min();
-  }
-
-  const std::vector<HighsInt>& getNonzeros() const { return nonzeroinds; }
-
-  double getValue(HighsInt index) const { return double(values[index]); }
-
-  void clear() {
-    if (nonzeroinds.size() < 0.3 * values.size())
-      for (HighsInt i : nonzeroinds) values[i] = 0.0;
-    else
-      values.assign(values.size(), false);
-
-    nonzeroinds.clear();
-  }
-
-  template <typename Pred>
-  HighsInt partition(Pred&& pred) {
-    return std::partition(nonzeroinds.begin(), nonzeroinds.end(), pred) -
-           nonzeroinds.begin();
-  }
-
-  template <typename IsZero>
-  void cleanup(IsZero&& isZero) {
-    HighsInt numNz = nonzeroinds.size();
-
-    for (HighsInt i = numNz - 1; i >= 0; --i) {
-      HighsInt pos = nonzeroinds[i];
-      double val = double(values[pos]);
-
-      if (isZero(pos, val)) {
-        values[pos] = 0.0;
-        --numNz;
-        std::swap(nonzeroinds[numNz], nonzeroinds[i]);
-      }
-    }
-
-    nonzeroinds.resize(numNz);
-  }
-};
-
-#endif

casadi/include/include/highs/util/HighsSplay.h

@@ -1,138 +0,0 @@
-/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
-/*                                                                       */
-/*    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                     */
-/*                                                                       */
-/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
-#ifndef HIGHS_SPLAY_H_
-#define HIGHS_SPLAY_H_
-
-#include <cassert>
-
-#include "util/HighsInt.h"
-
-/// top down splay operation to maintain a binary search tree. The search tree
-/// is assumed to be stored in an array/vector and therefore uses integers
-/// instead of pointers to link nodes. The splay operation on a given key will
-/// return the new root node index. The new root node will be the node with the
-/// given key, if it exists in the tree, and otherwise it is the node traversed
-/// last in a binary tree search for the key.
-///
-/// The GetLeft/GetRight lambdas receive an index of a node and must
-/// return references to an integer holding the left and the right child node
-/// indices. The GetKey lambda must return a type that is comparable
-/// to KeyT.
-template <typename KeyT, typename GetLeft, typename GetRight, typename GetKey>
-HighsInt highs_splay(const KeyT& key, HighsInt root, GetLeft&& get_left,
-                     GetRight&& get_right, GetKey&& get_key) {
-  if (root == -1) return -1;
-
-  HighsInt Nleft = -1;
-  HighsInt Nright = -1;
-  HighsInt* lright = &Nright;
-  HighsInt* rleft = &Nleft;
-
-  while (true) {
-    if (key < get_key(root)) {
-      HighsInt left = get_left(root);
-      if (left == -1) break;
-      if (key < get_key(left)) {
-        HighsInt y = left;
-        get_left(root) = get_right(y);
-        get_right(y) = root;
-        root = y;
-        if (get_left(root) == -1) break;
-      }
-
-      *rleft = root;
-      rleft = &get_left(root);
-      root = get_left(root);
-    } else if (key > get_key(root)) {
-      HighsInt right = get_right(root);
-      if (right == -1) break;
-      if (key > get_key(right)) {
-        HighsInt y = right;
-        get_right(root) = get_left(y);
-        get_left(y) = root;
-        root = y;
-        if (get_right(root) == -1) break;
-      }
-
-      *lright = root;
-      lright = &get_right(root);
-      root = get_right(root);
-    } else
-      break;
-  }
-
-  *lright = get_left(root);
-  *rleft = get_right(root);
-  get_left(root) = Nright;
-  get_right(root) = Nleft;
-
-  return root;
-}
-
-/// links a new node into the binary tree rooted at the given reference to the
-/// root node. Lambdas must behave as described in highs_splay above.
-/// Equal keys are put to the right subtree.
-template <typename GetLeft, typename GetRight, typename GetKey>
-void highs_splay_link(HighsInt linknode, HighsInt& root, GetLeft&& get_left,
-                      GetRight&& get_right, GetKey&& get_key) {
-  if (root == -1) {
-    get_left(linknode) = -1;
-    get_right(linknode) = -1;
-    root = linknode;
-    return;
-  }
-
-  root = highs_splay(get_key(linknode), root, get_left, get_right, get_key);
-
-  if (get_key(linknode) < get_key(root)) {
-    get_left(linknode) = get_left(root);
-    get_right(linknode) = root;
-    get_left(root) = -1;
-  } else {
-    assert(get_key(linknode) > get_key(root));
-    get_right(linknode) = get_right(root);
-    get_left(linknode) = root;
-    get_right(root) = -1;
-  }
-
-  root = linknode;
-}
-
-/// unlinks a new node into the binary tree rooted at the given reference to the
-/// root node. Lambdas must behave as described in highs_splay above.
-template <typename GetLeft, typename GetRight, typename GetKey>
-void highs_splay_unlink(HighsInt unlinknode, HighsInt& root, GetLeft&& get_left,
-                        GetRight&& get_right, GetKey&& get_key) {
-  assert(root != -1);
-  root = highs_splay(get_key(unlinknode), root, get_left, get_right, get_key);
-  assert(get_key(root) == get_key(unlinknode));
-
-  // in case keys can be equal it might happen that we did not splay the correct
-  // node to the top since equal keys are put to the right subtree, we recurse
-  // into that part of the tree
-  if (root != unlinknode) {
-    highs_splay_unlink(unlinknode, get_right(root), get_left, get_right,
-                       get_key);
-    return;
-  }
-
-  assert(root == unlinknode);
-
-  if (get_left(unlinknode) == -1) {
-    root = get_right(unlinknode);
-  } else {
-    root = highs_splay(get_key(unlinknode), get_left(unlinknode), get_left,
-                       get_right, get_key);
-    get_right(root) = get_right(unlinknode);
-  }
-}
-
-#endif