casadi 3.6.7__cp313-none-macosx_10_13_x86_64.macosx_10_13_intel.whl

casadi/include/highs/ipm/ipx/sparse_matrix.h

@@ -0,0 +1,195 @@
+#ifndef IPX_SPARSE_MATRIX_H_
+#define IPX_SPARSE_MATRIX_H_
+
+#include <vector>
+#include "ipm/ipx/ipx_internal.h"
+
+namespace ipx {
+
+// Sparse matrix in CSC format.
+
+class SparseMatrix {
+public:
+    SparseMatrix();
+    SparseMatrix(Int nrow, Int ncol);
+    SparseMatrix(Int nrow, Int ncol, Int min_capacity);
+
+    Int rows() const { return nrow_; }
+    Int cols() const { return colptr_.size()-1; }
+    Int entries() const { return colptr_.back(); }
+
+    // # entries in column j
+    Int entries(Int j) const { return end(j)-begin(j); }
+
+    // Maximum # entries that can be stored in the matrix.
+    Int capacity() const { return rowidx_.size(); }
+
+    // Increases capacity if necessary such that capacity() >= min_capacity.
+    // Matrix remains unchanged, pointers are invalidated.
+    void reserve(Int min_capacity);
+
+    // Changes matrix dimensions. Matrix becomes empty, pointers are
+    // invalidated.
+    void resize(Int nrow, Int ncol, Int min_capacity = 0);
+
+    // Identical to resize(0,0).
+    void clear();
+
+    // Builds matrix from data in compressed column format. The matrix data must
+    // be valid (no duplicates, no out of range indices, no inf/nan values);
+    // this is not checked. The row indices in the input matrix need not be
+    // sorted, but those in the output matrix will be.
+    void LoadFromArrays(Int nrow, Int ncol, const Int* Abegin, const Int* Aend,
+                        const Int* Ai, const double* Ax);
+
+    Int begin(Int j) const { return colptr_[j]; }
+    Int end(Int j) const { return colptr_[j+1]; }
+
+    // Accesses entry at position @pos by value.
+    Int index(Int pos) const { return rowidx_[pos]; }
+    double value(Int pos) const { return values_[pos]; }
+
+    // Accesses entry at position @pos by reference.
+    Int& index(Int pos) { return rowidx_[pos]; }
+    double& value(Int pos) { return values_[pos]; }
+
+    // Accesses underlying arrays.
+    const Int *colptr() const { return colptr_.data(); }
+    const Int *rowidx() const { return rowidx_.data(); }
+    const double *values() const { return values_.data(); }
+    Int *colptr() { return colptr_.data(); }
+    Int *rowidx() { return rowidx_.data(); }
+    double *values() { return values_.data(); }
+
+    // Stores the entries in each column in increasing order of index.
+    void SortIndices();
+
+    // The following methods provide a queue for adding new columns to the
+    // matrix. Entries in the queue are not part of the matrix (so do not
+    // contribute to entries()).
+
+    // Appends an entry to the end of the queue.
+    void push_back(Int i, double x) {
+        rowidx_queue_.push_back(i);
+        values_queue_.push_back(x);
+    }
+
+    // Returns # entries in the queue.
+    Int queue_size() const { return rowidx_queue_.size(); }
+
+    // Accesses entry at position @pos in the queue by value.
+    Int qindex(Int pos) const { return rowidx_queue_[pos]; }
+    double qvalue(Int pos) const { return values_queue_[pos]; }
+
+    // Accesses entry at position @pos in the queue by reference.
+    Int& qindex(Int pos) { return rowidx_queue_[pos]; }
+    double& qvalue(Int pos) { return values_queue_[pos]; }
+
+    // Makes new column from queue. The queue becomes empty and cols()
+    // increases by 1.
+    void add_column();
+
+    // Discards queue.
+    void clear_queue();
+
+private:
+    // Returns true if row indices are sorted.
+    bool IsSorted() const;
+
+    Int nrow_;
+    std::vector<Int> colptr_;
+    std::vector<Int> rowidx_;
+    std::vector<double> values_;
+    std::vector<Int> rowidx_queue_;
+    std::vector<double> values_queue_;
+};
+
+// Builds transpose of matrix.
+SparseMatrix Transpose(const SparseMatrix& A);
+
+// Resizes @AT as necessary and fills with the tranpose of A.
+void Transpose(const SparseMatrix& A, SparseMatrix& AT);
+
+// Returns a copy of A[:,cols].
+SparseMatrix CopyColumns(const SparseMatrix& A, const std::vector<Int>& cols);
+
+// Permutes rows in place so that row i becomes row perm[i].
+void PermuteRows(SparseMatrix& A, const std::vector<Int>& perm);
+
+// Multiplies column j by s.
+inline void ScaleColumn(SparseMatrix& A, Int j, double s) {
+    Int p1 = A.begin(j);
+    Int p2 = A.end(j);
+    for (Int p = p1; p < p2; p++)
+        A.value(p) *= s;
+}
+
+// Removes diagonal entries from A. If @diag is not NULL, then it must be an
+// array of dimension A.cols() that holds the diagonal of A on return. Diagonal
+// entries that are not present in A are set to zero in @diag. Returns the #
+// entries removed from A.
+Int RemoveDiagonal(SparseMatrix& A, double* diag);
+
+// Returns dot(A[:,j], rhs).
+inline double DotColumn(const SparseMatrix& A, Int j, const Vector& rhs) {
+    Int p1 = A.begin(j);
+    Int p2 = A.end(j);
+    double d = 0.0;
+    for (Int p = p1; p < p2; p++)
+        d += rhs[A.index(p)] * A.value(p);
+    return d;
+}
+
+// Updates lhs := lhs + alpha * A[:,j].
+inline void ScatterColumn(const SparseMatrix& A, Int j, double alpha,
+                          Vector& lhs) {
+    Int p1 = A.begin(j);
+    Int p2 = A.end(j);
+    for (Int p = p1; p < p2; p++)
+        lhs[A.index(p)] += alpha * A.value(p);
+}
+
+// Updates lhs := lhs + alpha*A*rhs or lhs := lhs + alpha*A'*rhs.
+// @trans: 't' or 'T' for transposed product.
+void MultiplyAdd(const SparseMatrix& A, const Vector& rhs, double alpha,
+                 Vector& lhs, char trans);
+
+// Updates lhs := lhs + A*A'*rhs or lhs := lhs + A*D*D*A'*rhs,
+// where D is diagonal matrix if @D != NULL.
+void AddNormalProduct(const SparseMatrix& A, const double* D, const Vector& rhs,
+                      Vector& lhs);
+
+// Triangular solve with sparse matrix.
+// @x: right-hand side on entry, left-hand side on return.
+// @trans: 't' or 'T' for transposed system.
+// @uplo: must have *uplo == 'u' or *uplo == 'U' if A is upper triangular;
+//        otherwise A is lower triangular.
+// @unitdiag: nonzero if A has a unit diagonal that is not stored.
+// Returns the # nonzeros in the solution.
+Int TriangularSolve(const SparseMatrix& A, Vector& x, char trans,
+                    const char* uplo, int unitdiag);
+
+// Solves (L*U) x = x.
+// L unit lower triangular, stored without diagonal.
+// U upper triangular, diagonal element at end of column.
+void ForwardSolve(const SparseMatrix& L, const SparseMatrix& U, Vector& x);
+
+// Solves (L*U)' x = x.
+// L unit lower triangular, stored without diagonal.
+// U upper triangular, diagonal element at end of column.
+void BackwardSolve(const SparseMatrix& L, const SparseMatrix& U, Vector& x);
+
+// Returns the 1-norm and infinity-norm of A.
+double Onenorm(const SparseMatrix& A);
+double Infnorm(const SparseMatrix& A);
+
+// Estimates the 1-norm of inverse(A).
+// @A must be square and lower or upper triangular.
+// @uplo: must have *uplo == 'u' or *uplo == 'U' if A is upper triangular;
+//        otherwise A is lower triangular.
+// @unitdiag: nonzero if A has a unit diagonal that is not stored.
+double NormestInverse(const SparseMatrix& A, const char* uplo, int unitdiag);
+
+}  // namespace ipx
+
+#endif  // IPX_SPARSE_MATRIX_H_

casadi/include/highs/ipm/ipx/sparse_utils.h

@@ -0,0 +1,58 @@
+#ifndef IPX_SPARSE_UTILS_H_
+#define IPX_SPARSE_UTILS_H_
+
+#include "ipm/ipx/ipx_internal.h"
+
+namespace ipx {
+
+// Depth-first search in the graph of matrix A.
+//
+// @istart starting node, must be unmarked on entry.
+// @Ap, @Ai pattern of matrix A in CSC format.
+// @colmap The neighbours of node i are the entries in col j = @colmap[i] of A.
+//         If j is negative, node i has no neighbours. @colmap can be NULL, in
+//         which case the identity mapping is assumed.
+// @top, @istack On return @istack[newtop..@top-1] holds the reached nodes that
+//               have previously been unmarked; they are marked now and newtop
+//               is returned.
+// @marked, @marker Node i is "marked" iff @marked[i] == @marker.
+// @work workspace of size # rows of A.
+//
+// The code has been copied and adapted from cs_dfs.c, included in the CSPARSE
+// package [1].
+//
+// [1] T. Davis, "Direct methods for sparse linear systems" (2006)
+//
+Int DepthFirstSearch(Int istart, const Int* Ap, const Int* Ai,
+                     const Int* colmap, Int top, Int* istack, Int* marked,
+                     Int marker, Int* work);
+
+// Alternating augmenting path for extending a matching for an m-by-n matrix A.
+//
+// @jstart column of matrix A that should be matched.
+// @Ap, @Ai pattern of matrix A in CSC format.
+// @jmatch array of size m.
+//         Row i is matched to column j if @jmatch[i] = j >= 0.
+//         Row i is yet unmatched if @jmatch[i] == -1.
+//         Row i is unmatched and excluded from being matched if jmatch[i] < -1.
+// @cheap array of size n. On the first call, @cheap must hold @Ap[0..n-1].
+//        It must be unchanged between subsequent calls.
+// @marked array of size n. On entry @marked[j] != @jstart for all j.
+//         On return some entries were set to @jstart.
+// @work size m workspace.
+// @work2 size m+1 workspace.
+// @work3 size m+1 workspace.
+//
+// Returns true if the matching was extended.
+//
+// The code has been copied and adapted from cs_augment.c, included in the
+// CSPARSE package [1].
+//
+// [1] T. Davis, "Direct methods for sparse linear systems" (2006)
+//
+bool AugmentingPath(Int jstart, const Int* Ap, const Int* Ai, Int* jmatch,
+                    Int* cheap, Int* marked, Int* work, Int* work2, Int* work3);
+
+}  // namespace ipx
+
+#endif // IPX_SPARSE_UTILS_H_

casadi/include/highs/ipm/ipx/splitted_normal_matrix.h

@@ -0,0 +1,63 @@
+#ifndef IPX_SPLITTED_NORMAL_MATRIX_H_
+#define IPX_SPLITTED_NORMAL_MATRIX_H_
+
+#include <vector>
+#include "ipm/ipx/basis.h"
+#include "ipm/ipx/linear_operator.h"
+#include "ipm/ipx/model.h"
+#include "ipm/ipx/sparse_matrix.h"
+
+namespace ipx {
+
+// SplittedNormalMatrix provides matrix-vector products with
+//
+//   C = inv(B)*AI*AI'*inv(B') = I + inv(B)*N*N'*inv(B'),
+//
+// where AI is the m-by-(n+m) matrix defined by the model and [B N] is the
+// partitioning of AI into basic and nonbasic columns defined by the basis.
+// The columns of B and N are scaled by the interior point scaling factors
+// provided in the call to Prepare().
+//
+// When a variable has status BASIC_FREE, the row and column of C become a unit
+// vector. When a variable has status NONBASIC_FIXED, it is dropped from N.
+
+class SplittedNormalMatrix : public LinearOperator {
+public:
+    // Constructor stores a reference to the model. No data is copied. The model
+    // must be valid as long as the object is used.
+    explicit SplittedNormalMatrix(const Model& model);
+
+    // Prepares object for subsequent calls to Apply(). @colscale must hold n+m
+    // scaling factors for the columns of AI. The scaling factors are copied.
+    void Prepare(const Basis& basis, const double* colscale);
+
+    // Returns the column permutation from the LU factorization of the basis
+    // matrix. The permutation was stored in the object by Prepare().
+    const Int* colperm() const;
+
+    // Returns computation times for operations since last call to reset_time().
+    double time_B() const;
+    double time_Bt() const;
+    double time_NNt() const;
+    void reset_time();
+
+private:
+    void _Apply(const Vector& rhs, Vector& lhs, double* rhs_dot_lhs) override;
+
+    const Model& model_;
+    SparseMatrix L_;           // lower triangular factor without unit diagonal
+    SparseMatrix U_;           // upper triangular factor with scaled columns
+    SparseMatrix N_;           // N with scaled columns and permuted row indices
+    std::vector<Int> free_positions_; // positions corresponding to free vars
+    std::vector<Int> colperm_;        // column permutation from LU factor
+    std::vector<Int> rowperm_inv_;    // inverse row permutation from LU factor
+    Vector work_;                     // size m workspace
+    bool prepared_{false};            // operator prepared?
+    double time_B_{0.0};              // time solves with B
+    double time_Bt_{0.0};             // time solves with B'
+    double time_NNt_{0.0};            // time matrix-vector products with NN'
+};
+
+}  // namespace ipx
+
+#endif  // IPX_SPLITTED_NORMAL_MATRIX_H_

casadi/include/highs/ipm/ipx/starting_basis.h

@@ -0,0 +1,39 @@
+#ifndef IPX_STARTING_BASIS_H_
+#define IPX_STARTING_BASIS_H_
+
+#include "ipm/ipx/basis.h"
+#include "ipm/ipx/iterate.h"
+
+namespace ipx {
+
+// Constructs a basis with the following properties:
+//
+// If lb[j]=-inf and ub[j]=inf, then the variable becomes either
+// - basic with status BASIC_FREE, or
+// - nonbasic with status NONBASIC_FIXED.                         (1)
+//
+// If lb[j]==ub[j] and j is a slack variable, then it becomes either
+// - basic with status BASIC_FREE, or                             (2)
+// - nonbasic with status NONBASIC_FIXED.
+//
+// If lb[j]==ub[j] and j is not a slack variable, then it becomes
+// - nonbasic with status NONBASIC_FIXED.
+//
+// All other variables get status BASIC or NONBASIC.
+//
+// In case (1) the columns corresponding to free variables are linearly
+// dependent. In case (2) the rows to equality constraints are linearly
+// dependent. In each case the dependent variables are moved to zero without
+// altering the primal or dual residual.
+// TODO: we need to check for primal/dual infeasibility here.
+//
+// The method calls ConstructBasisFromWeights() using the interior point
+// scaling factors as column weights. If a variable gets status BASIC_FREE or
+// NONBASIC_FIXED, then its state in @iterate is changed accordingly to free or
+// fixed. On return info->errflag is nonzero if an error occured.
+//
+void StartingBasis(Iterate* iterate, Basis* basis, Info* info);
+
+}  // namespace ipx
+
+#endif  // IPX_STARTING_BASIS_H_

casadi/include/highs/ipm/ipx/symbolic_invert.h

@@ -0,0 +1,29 @@
+#ifndef IPX_SYMBOLIC_INVERT_H_
+#define IPX_SYMBOLIC_INVERT_H_
+
+#include <vector>
+#include "ipm/ipx/ipx_internal.h"
+#include "ipm/ipx/model.h"
+
+namespace ipx {
+
+// Computes the # structural nonzeros per row and column of inverse(B), where
+// B = AI[:,basis] is the m-by-m matrix defined by the model and basis.
+//
+// @basis must have size m and be such that B is structurally nonsingular.
+//        (Otherwise an assertion will fail.)
+// @rowcounts must either be NULL or an integer array of size m.
+//            If not NULL, then on return rowcounts[p], 0 <= p < m, holds the
+//            number of nonzeros in row p of inverse(B). Notice that row p of
+//            inverse(B) corresponds to column p of B.
+// @colcounts must either be NULL or an integer array of size m.
+//            If not NULL, then on return colcounts[i], 0 <= i < m, holds the
+//            number of nonzeros in column i of inverse(B). Notice that column
+//            i of inverse(B) corresponds to row p of B.
+//
+void SymbolicInvert(const Model& model, const std::vector<Int>& basis,
+                    Int* rowcounts, Int* colcounts);
+
+}  // namespace ipx
+
+#endif  // IPX_SYMBOLIC_INVERT_H_

casadi/include/highs/ipm/ipx/timer.h

@@ -0,0 +1,24 @@
+#ifndef IPX_TIMER_H_
+#define IPX_TIMER_H_
+
+#include <chrono>
+
+namespace ipx {
+
+class Timer {
+public:
+    Timer();
+    double Elapsed() const;
+    void Reset();
+
+private:
+    typedef std::chrono::time_point<std::chrono::high_resolution_clock>
+        TimePoint;
+    static TimePoint tic();
+    static double toc(TimePoint start);
+    TimePoint t0_;
+};
+
+}  // namespace ipx
+
+#endif  // IPX_TIMER_H_

casadi/include/highs/ipm/ipx/utils.h

@@ -0,0 +1,39 @@
+#ifndef IPX_UTILS_H_
+#define IPX_UTILS_H_
+
+#include <vector>
+#include "ipm/ipx/ipx_internal.h"
+
+const bool kTerminationLogging = false;
+
+namespace ipx {
+
+bool AllFinite(const Vector& x);
+
+double Onenorm(const Vector& x);
+double Twonorm(const Vector& x);
+double Infnorm(const Vector& x);
+double Dot(const Vector& x, const Vector& y);
+
+// Returns the index of an entry of maximum absolute value.
+Int FindMaxAbs(const Vector& x);
+
+// lhs[permuted_index] = rhs
+void Permute(const std::vector<Int>& permuted_index, const Vector& rhs,
+             Vector& lhs);
+
+// lhs = rhs[permuted_index]
+void PermuteBack(const std::vector<Int>& permuted_index, const Vector& rhs,
+                 Vector& lhs);
+
+// Returns the inverse permutation to @perm.
+std::vector<Int> InversePerm(const std::vector<Int>& perm);
+
+// Returns the permutation that puts values[0..m-1] in increasing (if reverse is
+// false) or in decreasing (if reverse is true) order. If values==NULL, returns
+// the identity permutation.
+std::vector<Int> Sortperm(Int m, const double* values, bool reverse);
+
+}  // namespace ipx
+
+#endif  // IPX_UTILS_H_