casadi 3.6.4__cp39-none-manylinux2014_x86_64.whl → 3.6.6__cp39-none-manylinux2014_x86_64.whl

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

@@ -0,0 +1,157 @@
+#ifndef IPX_CROSSOVER_H_
+#define IPX_CROSSOVER_H_
+
+// Crossover method
+//
+// Given a basis and (x,y,z) that satisfies
+//
+//   lb[j] <= x[j] <= ub[j],                    (1)
+//    z[j] <= 0    if x[j] > lb[j],             (2a)
+//    z[j] >= 0    if x[j] < ub[j]              (2b)
+//
+// for all j, the crossover method updates the basis and (x,y,z) such that
+// z[j]=0 for all basic variables and x[j]=lb[j] or x[j]=ub[j] for all nonbasic
+// variables (or x[j]=0 if the variable is free). Hereby (1) and (2) are
+// maintained. The textbook method also keeps Ax and A'y+z unchanged.
+//
+// Nonbasic variables for which lb[j]<x[j]<ub[j] are called "primal superbasic"
+// and basic variables for which z[j]!=0 are called "dual superbasic". The
+// crossover algorithm removes superbasic variables in two push phases.
+//
+// Each iteration of the primal push phase chooses a primal superbasic variable
+// jn, moves x[jn] toward a bound (we choose the nearer one if jn has two finite
+// bounds and zero if it has none) and updates x[basic] to keep Ax unchanged. If
+// jn reaches its bound, then the push is complete. Otherwise a basic variable
+// jb reached its bound and blocked the step. In this case a basis update
+// exchanges jb by jn.
+//
+// Each iteration of the dual push phase chooses a dual superbasic variable jb,
+// moves z[jb] toward zero and updates z[nonbasic] to keep A'y+z unchanged. If
+// jb reaches zero, then the push is complete. Otherwise a nonbasic variable jn
+// became zero and blocked the step. In this case a basis update exchanges jb by
+// jn.
+
+#include <vector>
+#include "ipm/ipx/basis.h"
+#include "ipm/ipx/control.h"
+#include "ipm/ipx/indexed_vector.h"
+
+namespace ipx {
+
+class Crossover {
+public:
+    // Constructor stores a reference to the Control object, which must be valid
+    // as long as the Crossover object is used.
+    Crossover(const Control& control);
+
+    // First runs the dual push phase; if this was successful, then runs the
+    // primal push phase.
+    //
+    // weights: Must either be NULL or an array of size n+m.
+    //          If given, then primal pushes are executed in decreasing order of
+    //          weights and dual pushes in increasing order.
+    //          If NULL, then both phases push variables in increasing order of
+    //          index.
+    //
+    // On return info->status_crossover and info->errflag have been set by
+    // PushPrimal() or PushDual().
+    //
+    void PushAll(Basis* basis, Vector& x, Vector& y, Vector& z,
+                 const double* weights, Info* info);
+
+    // Pushes a set of primal variables to one of their bounds.
+    //
+    // basis:           the basis to be updated; also provides the LP model.
+    // x:               size n+m vector, satisfying (1) on entry and return.
+    //                  x is updated while A*x (ideally) remains unchanged.
+    // variables:       indices of nonbasic variables (without duplicates) to be
+    //                  pushed to a bound.
+    // fixed_at_bound:  NULL or size n+m array. If fixed_at_bound[j] = true,
+    //                  then x[j] must be at a bound on entry and remains at
+    //                  this bound. If NULL, then no variable is fixed.
+    // info:            on return info->status_crossover is one of
+    //                  * IPX_STATUS_optimal      if terminated successfully,
+    //                  * IPX_STATUS_time_limit   if interrupted,
+    //                  * IPX_STATUS_failed       if failed.
+    //                  In the latter case info->errflag is set.
+    //
+    // If a variable to be pushed has two finite bounds, then the nearer one is
+    // chosen. If it has no finite bound, then it is pushed to zero.
+    //
+    void PushPrimal(Basis* basis, Vector& x, const std::vector<Int>& variables,
+                    const bool* fixed_at_bound, Info* info);
+
+    // As above, but with fixed_at_bound defined through z.
+    // Variable j is fixed at its bound if z[j]!=0.
+    void PushPrimal(Basis* basis, Vector& x, const std::vector<Int>& variables,
+                    const Vector& z, Info* info);
+
+    // Pushes a set of dual variables to zero.
+    //
+    // basis:           the basis to be updated; also provides the LP model.
+    // y, z:            size m and n+m vectors that are updated while A'y+z
+    //                  (ideally) remains unchanged.
+    // variables:       indices of basic variables (without duplicates) to be
+    //                  pushed to zero.
+    // sign_restrict:   size n+m array. z[j] is restricted to be
+    //                  * non-negative iff (sign_restrict[j] & 1) != 0,
+    //                  * non-positive iff (sign_restrict[j] & 2) != 0.
+    //                  The sign restriction must be satisfied on entry and is
+    //                  satisfied on return.
+    // info:            on return info->status_crossover is one of
+    //                  * IPX_STATUS_optimal      if terminated successfully,
+    //                  * IPX_STATUS_time_limit   if interrupted,
+    //                  * IPX_STATUS_failed       if failed.
+    //                  In the latter case info->errflag is set.
+    //
+    void PushDual(Basis* basis, Vector& y, Vector& z,
+                  const std::vector<Int>& variables,
+                  const int sign_restrict[], Info* info);
+
+    // As above, but with the sign restriction on z defined through x.
+    // z[j] is restricted to be
+    // * non-negative iff x[j] < ub[j],
+    // * non-positive iff x[j] > lb[j].
+    void PushDual(Basis* basis, Vector& y, Vector& z,
+                  const std::vector<Int>& variables,
+                  const Vector& x, Info* info);
+
+    // Number of pushes in last call to PushPrimal() and PushDual().
+    Int primal_pushes() const { return primal_pushes_; }
+    Int dual_pushes() const { return dual_pushes_; }
+
+    // Number of basis updates in last call to PushPrimal() and PushDual().
+    Int primal_pivots() const { return primal_pivots_; }
+    Int dual_pivots() const { return dual_pivots_; }
+
+    // Runtime of last call to PushPrimal() and PushDual().
+    double time_primal() const { return time_primal_; }
+    double time_dual() const { return time_dual_; }
+
+private:
+    // An entry of the tableau row/column is eligible as pivot only if it is
+    // larger than kPivotZeroTol in absolute value.
+    static constexpr double kPivotZeroTol = 1e-5;
+
+    // Two-pass ratio tests that allow infeasibilities up to feastol in order
+    // to choose a larger pivot.
+    Int PrimalRatioTest(const Vector& xbasic, const IndexedVector& ftran,
+                        const Vector& lbbasic, const Vector& ubbasic,
+                        double step, double feastol, bool* block_at_lb);
+    Int DualRatioTest(const Vector& z, const IndexedVector& row,
+                      const int sign_restrict[], double step,
+                      double feastol);
+
+    const Control& control_;
+
+    Int primal_pushes_{0};
+    Int dual_pushes_{0};
+    Int primal_pivots_{0};
+    Int dual_pivots_{0};
+    double time_primal_{0.0};
+    double time_dual_{0.0};
+};
+
+}  // namespace ipx
+
+#endif  // IPX_CROSSOVER_H_

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

@@ -0,0 +1,45 @@
+// Copyright (c) 2018-2019 ERGO-Code. See license.txt for license.
+
+#ifndef IPX_DIAGONAL_PRECOND_H_
+#define IPX_DIAGONAL_PRECOND_H_
+
+#include "ipm/ipx/linear_operator.h"
+#include "ipm/ipx/model.h"
+#include "ipm/ipx/sparse_matrix.h"
+
+namespace ipx {
+
+// DiagonalPrecond provides inverse operations with the diagonal matrix
+//
+//   diag(AI*W*AI').                                (1)
+//
+// Here AI is the m-by-(n+m) matrix defined by the model, and W is a diagonal
+// (weight) matrix that is provided by the user.
+
+class DiagonalPrecond : public LinearOperator {
+public:
+    // Constructor stores a reference to the model. No data is copied. The model
+    // must be valid as long as the preconditioner is used.
+    explicit DiagonalPrecond(const Model& model);
+
+    // Factorizes the preconditioner. W must either hold n+m entries, or be
+    // NULL, in which case the first n entries are assumed 1.0 and the last
+    // m entries are assumed 0.0.
+    void Factorize(const double* W, Info* info);
+
+    // Returns computation time for calls to Apply() since last reset_time().
+    double time() const;
+    void reset_time();
+
+private:
+    void _Apply(const Vector& rhs, Vector& lhs, double* rhs_dot_lhs) override;
+
+    const Model& model_;
+    bool factorized_{false};    // preconditioner factorized?
+    Vector diagonal_;           // diagonal of normal matrix
+    double time_{0.0};
+};
+
+}  // namespace ipx
+
+#endif  // IPX_DIAGONAL_PRECOND_H_

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

@@ -0,0 +1,102 @@
+#ifndef IPX_FORREST_TOMLIN_H_
+#define IPX_FORREST_TOMLIN_H_
+
+#include <memory>
+#include <vector>
+#include "ipm/ipx/control.h"
+#include "ipm/ipx/lu_factorization.h"
+#include "ipm/ipx/lu_update.h"
+
+namespace ipx {
+
+// Generic implementation of the Forrest-Tomlin update [1] that can be used with
+// any LU factorization. The implementation does not exploit hypersparsity,
+// which excludes its use for such problems. For non-hypersparse problems the
+// implementation is better suited than BASICLU, however, because it stores L
+// and U in compressed form with permuted indices; hence solving triangular
+// systems with a dense rhs/lhs accesses memory contiguously. BASICLU could not
+// be implemented in that form due to re-permuting U to triangular form in the
+// updates. Hypersparsity support could be added to the present implementation
+// when required.
+//
+// [1] J.J.H. Forrest and J.A. Tomlin, "Updated triangular factors of the basis
+//     to maintain sparsity in the product form simplex method", Math.
+//     Programming 2 (1972)
+
+class ForrestTomlin : public LuUpdate {
+public:
+    // Constructor takes ownership of the LuFactorization object by a move from
+    // @lu.
+    ForrestTomlin(const Control& control, Int dim,
+                  std::unique_ptr<LuFactorization>& lu);
+    ~ForrestTomlin() = default;
+
+private:
+    Int _Factorize(const Int* Bbegin, const Int* Bend, const Int* Bi,
+                   const double* Bx, bool strict_abs_pivottol) override;
+    void _GetFactors(SparseMatrix* L, SparseMatrix* U, Int* rowperm,
+                     Int* colperm, std::vector<Int>* dependent_cols) override;
+    void _SolveDense(const Vector& rhs, Vector& lhs, char trans) override;
+    void _FtranForUpdate(Int nz, const Int* bi, const double* bx) override;
+    void _FtranForUpdate(Int nz, const Int* bi, const double* bx,
+                         IndexedVector& lhs) override;
+    void _BtranForUpdate(Int j) override;
+    void _BtranForUpdate(Int j, IndexedVector& lhs) override;
+    Int _Update(double pivot) override;
+    bool _NeedFreshFactorization() override;
+    double _fill_factor() const override;
+    double _pivottol() const override;
+    void _pivottol(double new_pivottol) override;
+
+    // Maximum # updates before refactorization is required.
+    static constexpr Int kMaxUpdates = 5000;
+
+    // Solves a linear system with the basis matrix. On entry @x holds the
+    // permuted right-hand side, on return it holds the permuted solution.
+    // @x must have dimension at least dim_ + # computed updates; the additional
+    // components are used as workspace.
+    // @trans: 't' or 'T' for transposed system.
+    void SolvePermuted(Vector& x, char trans);
+
+    // Computes the spike column for the FT update from
+    //   R_k^{-1} * ... * R_1^{-1} * L^{-1} * b
+    // and stores it in compressed form at the end of U. The spike is also
+    // returned as a full vector in work_.
+    // @nb, @bi, @bx: b in compressed form.
+    void ComputeSpike(Int nb, const Int* bi, const double* bx);
+
+    // Computes the partial BTRAN solution r = ep' * U^{-1}, where ep is the
+    // p-th unit vector and p the position of column @j in the pivot sequence.
+    // The row eta vector -r/r[p] without the unit diagonal entry is stored in
+    // compressed form at end of R. r is returned as a full vector in work_.
+    void ComputeEta(Int j);
+
+    const Control& control_;
+    const Int dim_;
+    std::unique_ptr<LuFactorization> lu_;
+
+    std::vector<Int> rowperm_;     // row permutation from factorization
+    std::vector<Int> colperm_;     // col permutation from factorization
+    std::vector<Int> rowperm_inv_; // inverse permutation of rowperm_
+    std::vector<Int> colperm_inv_; // inverse permutation of colperm_
+    std::vector<Int> dependent_cols_;
+                             // passed trough from _Factorize() to _GetFactors()
+
+    SparseMatrix L_;            // L from factorization
+    SparseMatrix U_;            // U from factorization with spike cols appended
+    SparseMatrix R_;            // cols of R build row eta matrices from updates
+
+    // replaced_[k] == p if update k replaced position p in pivot sequence.
+    // replaced_.size() is the # updates performed.
+    std::vector<Int> replaced_;
+    Int replace_next_;          // position to be replaced in next update
+    bool have_btran_{false};    // true if row eta has been computed
+    bool have_ftran_{false};    // true if spike has been computed
+    double fill_factor_{0.0};   // fill factor from last factorization
+    double pivottol_{0.1};      // LU pivot tolerance for next factorization
+    Vector work_;               // size dim_ + kMaxUpdates workspace
+};
+
+}  // namespace ipx
+
+#endif  // IPX_FORREST_TOMLIN_H_

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

@@ -0,0 +1,21 @@
+#ifndef IPX_GUESS_BASIS_H_
+#define IPX_GUESS_BASIS_H_
+
+#include "ipm/ipx/control.h"
+#include "ipm/ipx/model.h"
+
+namespace ipx {
+
+// Returns a vector of m column indices (m = model.rows()) as a guess for a
+// basis. Columns with a larger weight are chosen preferably. The basis can be
+// singular (and usually is).
+//
+// @colweights size n+m array (n = model.cols()) with entries in the closed
+//             interval [0,INFINITY].
+//
+std::vector<Int> GuessBasis(const Control& control, const Model& model,
+                            const double* colweights);
+
+}  // namespace ipx
+
+#endif // IPX_GUESS_BASIS_H_

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

@@ -0,0 +1,113 @@
+#ifndef IPX_INDEXED_VECTOR_H_
+#define IPX_INDEXED_VECTOR_H_
+
+#include <vector>
+#include "ipm/ipx/ipx_internal.h"
+
+namespace ipx {
+
+// IndexedVector stores a vector and optionally the indices of its nonzero
+// entries (its pattern). To iterate over the entries in an IndexedVector v:
+//
+//   double vmax = 0.0;
+//   Int imax = 0;
+//   auto update_max = [&vmax,&imax](Int i, double x) {
+//       if (x > vmax) {
+//           vmax = x;
+//           imax = i;
+//       }
+//   };
+//   for_each_nonzero(v, update_max);
+//
+// The loop iterates with indirect addressing over the nonzero entries if the
+// pattern is known and sparse, and with direct addressing over the whole vector
+// otherwise.
+//
+// When modifying the vector changes its pattern (e.g. by writing to v[i] for an
+// arbitrary index i), you have to invalidate the pattern or provide the new one.
+
+class IndexedVector {
+public:
+    // Constructs a vector of dimension @dim. Entries are initialized to zero
+    // and pattern becomes empty.
+    explicit IndexedVector(Int dim = 0);
+
+    Int dim() const { return elements_.size(); }
+
+    // Accesses entry 0 <= @i < dim() by value or reference.
+    double operator[](Int i) const { return elements_[i]; }
+    double& operator[](Int i) { return elements_[i]; }
+
+    // Returns true if pattern is known and sparse.
+    bool sparse() const;
+
+    // Returns # nonzeros, or a negative value if the pattern is unknown.
+    Int nnz() const { return nnz_; }
+
+    // Invalidates the pattern.
+    void InvalidatePattern() { nnz_ = -1; }
+
+    // Changes the # indices in the pattern to new_nnz <= dim(). A negative
+    // value invalidates the pattern.
+    void set_nnz(Int new_nnz) { nnz_ = new_nnz; }
+
+    // Returns the underlying array that stores the vector.
+    const double* elements() const { return &elements_[0]; }
+    double* elements() { return &elements_[0]; }
+
+    // Returns the underlying array that stores the pattern.
+    const Int* pattern() const { return pattern_.data(); }
+    Int* pattern() { return pattern_.data(); }
+
+    // Sets all entries to zero and the pattern to empty.
+    void set_to_zero();
+
+private:
+    Vector elements_;
+    std::vector<Int> pattern_;
+    // If nnz_ >= 0, then pattern_[0..nnz_-1] are the indices of (possible)
+    // nonzeros in elements_. If nnz_ < 0, then the pattern is unknown.
+    Int nnz_{0};
+};
+
+template <typename C>
+void for_each_nonzero(IndexedVector& v, C& c) {
+    if (v.sparse()) {
+        const Int* pattern = v.pattern();
+        Int nnz = v.nnz();
+        for (Int p = 0; p < nnz; p++) {
+            const Int i = pattern[p];
+            c(i, v[i]);
+        }
+    } else {
+        Int dim = v.dim();
+        for (Int i = 0; i < dim; i++) {
+            const Int ii = i;   // make sure that caller does not change i
+            c(ii, v[i]);
+        }
+    }
+}
+
+template <typename C>
+void for_each_nonzero(const IndexedVector& v, C& c) {
+    if (v.sparse()) {
+        const Int* pattern = v.pattern();
+        Int nnz = v.nnz();
+        for (Int p = 0; p < nnz; p++) {
+            const Int i = pattern[p];
+            c(i, v[i]);
+        }
+    } else {
+        Int dim = v.dim();
+        for (Int i = 0; i < dim; i++) {
+            const Int ii = i;   // make sure that caller does not change i
+            c(ii, v[i]);
+        }
+    }
+}
+
+double Dot(const IndexedVector& x, const Vector& y);
+
+}  // namespace ipx
+
+#endif  // IPX_INDEXED_VECTOR_H_

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

@@ -0,0 +1,27 @@
+#ifndef IPX_INFO_CPP_H_
+#define IPX_INFO_CPP_H_
+
+#include <ostream>
+#include <string>
+#include "ipm/ipx/ipx_internal.h"
+
+namespace ipx {
+
+// Formatted output of Info. For each member one line is printed in the form
+//  info.status                                         1000
+//  info.status_ipm                                     1
+//  info.status_crossover                               1
+//  info.errflag                                        0
+//  info.num_var                                        89346
+//  info.num_constr                                     39855
+//  ...
+// The result can be parsed using the Julia function ParseInfo(), which recovers
+// an object of a Julia type analogue to struct ipx_info.
+std::ostream& operator<<(std::ostream&, const Info&);
+
+// Returns a text representation of each status code.
+std::string StatusString(Int status);
+
+}  // namespace ipx
+
+#endif  // IPX_INFO_CPP_H_

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

@@ -0,0 +1,94 @@
+#ifndef IPX_IPM_H_
+#define IPX_IPM_H_
+
+#include "ipm/ipx/control.h"
+#include "ipm/ipx/kkt_solver.h"
+#include "ipm/ipx/iterate.h"
+
+namespace ipx {
+
+// IPM implements an interior point method based on KKTSolver and Iterate.
+// The algorithm is a variant of Mehrotra's [1] predictor-corrector method
+// that requires two linear system solves per iteration.
+//
+// [1] S. Mehrotra, "On the implementation of a primal-dual interior point
+//     method", SIAM J. Optim., 2 (1992).
+
+class IPM {
+public:
+    explicit IPM(const Control& control);
+
+    // Initializes @iterate with a starting point for Driver(). The KKT solver
+    // must allow Factorize(NULL, info) (see kkt_solver.h).
+    // On return info->status_ipm is
+    // IPX_STATUS_not_run    if successful,
+    // IPX_STATUS_time_limit if the KKT solver was interrupted by time limit,
+    // IPX_STATUS_failed     if the KKT solver failed with info->errflag.
+    // If the method did not terminate successfully, @iterate is unchanged.
+    void StartingPoint(KKTSolver* kkt, Iterate* iterate, Info* info);
+
+    // Updates @iterate by interior point iterations. On return ipm_status is
+    // IPX_STATUS_optimal       if iterate->term_crit_reached() is true,
+    // IPX_STATUS_iter_limit    if info->iter >= maxiter(),
+    // IPX_STATUS_no_progress   if no progress over a number of iterations,
+    // IPX_STATUS_time_limit    if interrupted by time limit,
+    // IPX_STATUS_failed        if the KKT solver failed with info->errflag.
+    void Driver(KKTSolver* kkt, Iterate* iterate, Info* info);
+
+    Int maxiter() const { return maxiter_; }
+    void maxiter(Int i) { maxiter_ = i; }
+
+private:
+    struct Step;
+    // IPM terminates when the complementarity gap of the current iterate
+    // exceeds kDivergeTol times the smallest complementarity gap of all
+    // iterates so far.
+    static constexpr double kDivergeTol = 1e6;
+
+    void ComputeStartingPoint();
+    void Predictor(Step& step);
+    void AddCorrector(Step& step);
+    void Centring(Step& step, double mu_to_use);
+    void AssessCentrality(const Vector& xl, const Vector& xu, const Vector& zl, 
+                          const Vector& zu,double mu, bool print = true);
+    bool EvaluateCentringStep(const Step& step, double prev_ratio, Int prev_bad);
+    void StepSizes(const Step& step, bool isCentring = false);
+    void MakeStep(const Step& step, bool isCentring = false);
+    // Reduces the following linear system to KKT form:
+    //  [ AI                 ] [dx ]    [rb]
+    //  [ I  -I              ] [dxl] =  [rl]
+    //  [ I      I           ] [dxu]    [ru]
+    //  [          AI'  I -I ] [dy ]    [rc]
+    //  [    Zl        Xl    ] [dzl]    [sl]
+    //  [       Zu        Xu ] [dzu]    [su]
+    // Each of @rb, @rc, @rl and @ru can be NULL, in which case its entries are
+    // assumed to be 0.0. This is currently not used, but was implemented for
+    // computing centrality correctors.
+    void SolveNewtonSystem(const double* rb, const double* rc,
+                           const double* rl, const double* ru,
+                           const double* sl, const double* su, Step& lhs);
+    void PrintHeader();
+    void PrintOutput();
+
+    const Control& control_;
+    KKTSolver* kkt_{nullptr};
+    Iterate* iterate_{nullptr};
+    Info* info_{nullptr};
+
+    double step_primal_{0.0}, step_dual_{0.0};
+    // Counts the # bad iterations since the last good iteration. An iteration
+    // is bad if the primal or dual step size is < 0.05.
+    Int num_bad_iter_{0};
+    // Smallest complementarity gap of all iterates so far.
+    double best_complementarity_{0.0};
+
+    Int maxiter_{-1};
+
+    // indicators of centrality for centring steps
+    double centring_ratio{0.0};
+    Int bad_products{0};
+};
+
+}  // namespace ipx
+
+#endif  // IPX_IPM_H_

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

@@ -0,0 +1,47 @@
+#ifndef IPX_C_H_
+#define IPX_C_H_
+
+#include "ipm/ipx/ipx_config.h"
+#include "ipm/ipx/ipx_info.h"
+#include "ipm/ipx/ipx_parameters.h"
+#include "ipm/ipx/ipx_status.h"
+
+#ifdef __cplusplus
+extern "C"{
+#endif
+    /* These functions call their equivalent method of LpSolver for
+       the object pointed to by @self. See src/lp_solver.h for
+       documentation of the methods. */
+    ipxint ipx_load_model(void* self, ipxint num_var, const double* obj,
+                          const double* lb, const double* ub, ipxint num_constr,
+                          const ipxint* Ap, const ipxint* Ai, const double* Ax,
+                          const double* rhs, const char* constr_type);
+    ipxint ipx_load_ipm_starting_point(void* self, const double* x,
+                                       const double* xl, const double* xu,
+                                       const double* slack, const double* y,
+                                       const double* zl, const double* zu);
+    ipxint ipx_solve(void* self);
+    struct ipx_info ipx_get_info(void* self);
+    ipxint ipx_get_interior_solution(void* self, double* x, double* xl,
+                                     double* xu, double* slack, double* y,
+                                     double* zl, double* zu);
+    ipxint ipx_get_basic_solution(void* self, double* x, double* slack,
+                                  double* y, double* z,
+                                  ipxint* cbasis, ipxint* vbasis);
+    struct ipx_parameters ipx_get_parameters(void* self);
+    void ipx_set_parameters(void* self, struct ipx_parameters);
+    void ipx_clear_model(void* self);
+
+    /* for debugging */
+    ipxint ipx_get_iterate(void* self, double* x, double* y, double* zl,
+                           double* zu, double* xl, double* xu);
+    ipxint ipx_get_basis(void* self, ipxint* cbasis, ipxint* vbasis);
+    ipxint ipx_get_kktmatrix(void* self, ipxint* AIp, ipxint* AIi, double* AIx,
+                             double* g);
+    ipxint ipx_symbolic_invert(void* self, ipxint* rowcounts,
+                               ipxint* colcounts);
+#ifdef __cplusplus
+}
+#endif
+
+#endif  /* IPX_C_H_ */

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

@@ -0,0 +1,9 @@
+#ifndef IPX_CONFIG_H_
+#define IPX_CONFIG_H_
+
+#include <stdint.h>
+
+#include "util/HighsInt.h"
+typedef HighsInt ipxint;
+
+#endif /* IPX_CONFIG_H_ */