casadi 3.6.4__cp312-none-win_amd64.whl → 3.6.7__cp312-none-win_amd64.whl

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

@@ -0,0 +1,70 @@
+#ifndef IPX_KKT_SOLVER_H_
+#define IPX_KKT_SOLVER_H_
+
+#include "ipm/ipx/basis.h"
+#include "ipm/ipx/iterate.h"
+
+namespace ipx {
+
+// Interface to KKT solver implementations. A KKT solver implements a direct or
+// iterative method for solving
+//
+//   [ G   AI' ] (x) = (a) ,                        (1)
+//   [ AI   0  ] (y)   (b)
+//
+// where AI is the m-by-(n+m) matrix defined by a model and G is a positive
+// semidefinite diagonal matrix. The solver may add regularization to G and/or
+// the zero block.
+//
+// An iterative solver must compute an approximate solution of the form
+//
+//   [ G   AI' ] (x) = (a) + (res)                  (2)
+//   [ AI   0  ] (y)   (b)   ( 0 )
+//
+// that satisfies Infnorm(D*res) <= tol, where D is the diagonal matrix with
+// entries D[i,i] = sqrt(1/G[i,i]) if G[i,i] != 0 and D[i,i] = 1 otherwise.
+
+class KKTSolver {
+public:
+    KKTSolver& operator=(const KKTSolver&) = delete;
+    KKTSolver& operator=(KKTSolver&&) = delete;
+    virtual ~KKTSolver() {}
+
+    // Factorizes the KKT matrix (direct solver) or prepares preconditioner
+    // (iterative solver). The diagonal matrix G is built from @iterate.
+    // The implementation is allowed to change variable statuses to eliminate
+    // close-to-converged variables from the IPM solve. Some implementations
+    // allow @iterate to be NULL, in which case G is assumed to be the identity
+    // matrix.
+    void Factorize(Iterate* iterate, Info* info);
+
+    // Solves KKT system. If an iterative method is used, @tol is the required
+    // tolerance for the residual in (2) as specified above.
+    void Solve(const Vector& a, const Vector& b, double tol,
+               Vector& x, Vector& y, Info* info);
+
+    // If an iterative method is used, returns the # iterations in all Solve()
+    // calls since the last call to Factorize(). A direct solver returns the #
+    // iterative refinement steps.
+    Int iter() const;
+
+    // If a basis matrix is maintained, returns the # basis changes in the last
+    // call to Factorize(). Otherwise returns 0.
+    Int basis_changes() const;
+
+    // If a basis matrix is maintained, returns a pointer to it.
+    // Otherwise returns NULL.
+    const Basis* basis() const;
+
+private:
+    virtual void _Factorize(Iterate* iterate, Info* info) = 0;
+    virtual void _Solve(const Vector& a, const Vector& b, double tol,
+                         Vector& x, Vector& y, Info* info) = 0;
+    virtual Int _iter() const = 0;
+    virtual Int _basis_changes() const { return 0; }
+    virtual const Basis* _basis() const { return nullptr; }
+};
+
+}  // namespace ipx
+
+#endif  // IPX_KKT_SOLVER_H_

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

@@ -0,0 +1,66 @@
+#ifndef IPX_KKT_SOLVER_BASIS_H_
+#define IPX_KKT_SOLVER_BASIS_H_
+
+#include "ipm/ipx/basis.h"
+#include "ipm/ipx/control.h"
+#include "ipm/ipx/kkt_solver.h"
+#include "ipm/ipx/model.h"
+#include "ipm/ipx/splitted_normal_matrix.h"
+
+namespace ipx {
+
+// KKTSolverBasis implements a KKT solver using the CR method with basis
+// preconditioning. Maintaining a basis matrix allows to remove degenerate
+// variables from the optimization process. This technique is applied in
+// Factorize() if parameter ipm_drop_primal or ipm_drop_dual is positive.
+//
+// In the call to Factorize() @iterate must not be NULL.
+
+class KKTSolverBasis : public KKTSolver {
+public:
+    // Constructor wraps a Basis object into a KKTSolverBasis object. The basis
+    // must have been initialized to a starting basis and must be valid as long
+    // as the KKT solver is used. Its associated model defines the LP data.
+    KKTSolverBasis(const Control& control, Basis& basis);
+
+    Int maxiter() const { return maxiter_; }
+    void maxiter(Int new_maxiter) { maxiter_ = new_maxiter; }
+
+private:
+    // DropPrimal() and DropDual() do not choose entries as pivots that are <=
+    static constexpr double kPivotZeroTol = 1e-7;
+
+    void _Factorize(Iterate* iterate, Info* info) override;
+    void _Solve(const Vector& a, const Vector& b, double tol,
+                Vector& x, Vector& y, Info* info) override;
+    Int _iter() const override { return iter_; }
+    Int _basis_changes() const override { return basis_changes_; }
+    const Basis* _basis() const override { return &basis_; }
+
+    // Processes basic variables that are close to a bound by either pivoting
+    // them out of the basis or making them "implied"; i.e. the dual is fixed at
+    // its current value and the variable is treated as free by the interior
+    // point solver. After the LP solve finished, the primal is set to its
+    // bound.
+    void DropPrimal(Iterate* iterate, Info* info);
+
+    // Processes nonbasic variables whose dual is close to zero by either
+    // pivoting them into the basis or "fixing" the primal; i.e. the variable is
+    // removed from optimization and the primal remains at its current value.
+    // The dual is set to zero.
+    void DropDual(Iterate* iterate, Info* info);
+
+    const Control& control_;
+    const Model& model_;
+    Basis& basis_;
+    SplittedNormalMatrix splitted_normal_matrix_;
+    Vector colscale_;           // interior point column scaling factors
+    bool factorized_{false};    // preconditioner prepared?
+    Int maxiter_{-1};
+    Int iter_{0};
+    Int basis_changes_{0};
+};
+
+}  // namespace ipx
+
+#endif  // IPX_KKT_SOLVER_BASIS_H_

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

@@ -0,0 +1,48 @@
+// Copyright (c) 2018-2019 ERGO-Code. See license.txt for license.
+
+#ifndef IPX_KKT_SOLVER_DIAG_H_
+#define IPX_KKT_SOLVER_DIAG_H_
+
+#include "ipm/ipx/control.h"
+#include "ipm/ipx/diagonal_precond.h"
+#include "ipm/ipx/kkt_solver.h"
+#include "ipm/ipx/model.h"
+#include "ipm/ipx/normal_matrix.h"
+
+namespace ipx {
+
+// KKTSolverDiag implements a KKT solver that applies the Conjugate Residuals
+// method with diagonal preconditioning to the normal equations. If the (1,1)
+// block of the KKT matrix is not positive definite, regularization is applied.
+//
+// In the call to Factorize() @iterate is allowed to be NULL, in which case the
+// (1,1) block of the KKT matrix is the identity matrix.
+
+class KKTSolverDiag : public KKTSolver {
+public:
+    KKTSolverDiag(const Control& control, const Model& model);
+
+    Int maxiter() const { return maxiter_; }
+    void maxiter(Int new_maxiter) { maxiter_ = new_maxiter; }
+
+private:
+    void _Factorize(Iterate* iterate, Info* info) override;
+    void _Solve(const Vector& a, const Vector& b, double tol,
+                Vector& x, Vector& y, Info* info) override;
+    Int _iter() const override { return iter_; };
+
+    const Control& control_;
+    const Model& model_;
+    NormalMatrix normal_matrix_;
+    DiagonalPrecond precond_;
+
+    Vector W_;               // diagonal matrix in AI*W*AI'
+    Vector resscale_;        // residual scaling factors for CR termination test
+    bool factorized_{false}; // KKT matrix factorized?
+    Int maxiter_{-1};
+    Int iter_{0};               // # CR iterations since last Factorize()
+};
+
+}  // namespace ipx
+
+#endif  // IPX_KKT_SOLVER_DIAG_H_

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

@@ -0,0 +1,26 @@
+#ifndef IPX_LINEAR_OPERATOR_H_
+#define IPX_LINEAR_OPERATOR_H_
+
+#include "ipm/ipx/ipx_internal.h"
+
+namespace ipx {
+
+class LinearOperator {
+public:
+    LinearOperator& operator=(const LinearOperator&) = delete;
+    LinearOperator& operator=(LinearOperator&&) = delete;
+    virtual ~LinearOperator() {}
+
+    // Computes lhs = F(rhs), where F is a linear function. If rhs_dot_lhs is
+    // not NULL, then the argument returns dot(rhs,lhs). The implementation can
+    // assume that rhs and lhs do not refer to the same object.
+    void Apply(const Vector& rhs, Vector& lhs, double* rhs_dot_lhs);
+
+private:
+    virtual void _Apply(const Vector& rhs, Vector& lhs, double* rhs_dot_lhs)
+        = 0;
+};
+
+}  // namespace ipx
+
+#endif  // IPX_LINEAR_OPERATOR_H_

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

@@ -0,0 +1,201 @@
+#ifndef IPX_LP_SOLVER_H_
+#define IPX_LP_SOLVER_H_
+
+#include <memory>
+#include "ipm/ipx/basis.h"
+#include "ipm/ipx/control.h"
+#include "ipm/ipx/ipm.h"
+#include "ipm/ipx/iterate.h"
+#include "ipm/ipx/model.h"
+#include "lp_data/HighsCallback.h"
+
+namespace ipx {
+
+class LpSolver {
+public:
+    // Loads an LP model in the form given in the reference documentation.
+    // @num_var: number of variables, must be > 0.
+    // @obj: size num_var array of objective coefficients.
+    // @lb: size num_var array of variable lower bounds, can have -INFINITY.
+    // @lb: size num_var array of variable upper bounds, can have +INFINITY.
+    // @num_constr: number of constraints, must be >= 0.
+    // @Ap, @Ai, @Ax: constraint matrix in CSC format; indices can be unsorted.
+    // @rhs: size num_constr array of right-hand side entries.
+    // @constr_type: size num_constr array of entries '>', '<' and '='.
+    // Returns:
+    //  0
+    //  IPX_ERROR_argument_null
+    //  IPX_ERROR_invalid_dimension
+    //  IPX_ERROR_invalid_matrix
+    //  IPX_ERROR_invalid_vector
+    Int LoadModel(Int num_var, const double* obj, const double* lb,
+                  const double* ub, Int num_constr, const Int* Ap,
+                  const Int* Ai, const double* Ax, const double* rhs,
+                  const char* constr_type);
+
+    // Loads a primal-dual point as starting point for the IPM.
+    // @x: size num_var array
+    // @xl: size num_var array, must satisfy xl[j] >= 0 for all j and
+    //      xl[j] == INFINITY iff lb[j] == -INFINITY.
+    // @xu: size num_var array, must satisfy xu[j] >= 0 for all j and
+    //      xu[j] == INFINITY iff ub[j] == INFINITY.
+    // @slack: size num_constr array, must satisfy
+    //         slack[i] == 0 if constr_type[i] == '='
+    //         slack[i] >= 0 if constr_type[i] == '<'
+    //         slack[i] <= 0 if constr_type[i] == '>'
+    // @y: size num_constr array, must satisfy
+    //     y[i] >= 0 if constr_type[i] == '>'
+    //     y[i] <= 0 if constr_type[i] == '<'
+    // @zl: size num_var array, must satsify zl[j] >= 0 for all j and
+    //      zl[j] == 0 if lb[j] == -INFINITY
+    // @zu: size num_var array, must satsify zu[j] >= 0 for all j and
+    //      zu[j] == 0 if ub[j] == INFINITY
+    // When a starting point was loading successfully (return value 0), then
+    // the next call to Solve() will start the IPM from that point, except that
+    // primal and dual slacks with value 0 are made positive if necessary. The
+    // IPM will skip the initial iterations and start directly with basis
+    // preconditioning.
+    // At the moment loading a starting point is not possible when the model was
+    // dualized during preprocessing. See parameters to turn dualization off.
+    // Returns:
+    // 0                            success
+    // IPX_ERROR_argument_null      an argument was NULL
+    // IPX_ERROR_invalid_vector     a sign condition was violated
+    // IPX_ERROR_not_implemented    the model was dualized during preprocessing
+    Int LoadIPMStartingPoint(const double* x, const double* xl,
+                             const double* xu, const double* slack,
+                             const double* y, const double* zl,
+                             const double* zu);
+
+    // Solves the model that is currently loaded in the object.
+    // Returns GetInfo().status.
+    Int Solve();
+
+    // Returns the solver info from the last call to Solve(). See the reference
+    // documentation for the meaning of Info values.
+    Info GetInfo() const;
+
+    // Returns the final IPM iterate from the last call to Solve() into user
+    // arrays. An iterate is available if GetInfo().status_ipm !=
+    // IPX_STATUS_not_run. If no iterate is available, the method does nothing.
+    // Each of the pointer arguments must either be NULL or an array of
+    // appropriate dimension. If NULL, the quantity is not returned.
+    // Returns -1 if no IPM iterate was available and 0 otherwise.
+    Int GetInteriorSolution(double* x, double* xl, double* xu, double* slack,
+                            double* y, double* zl, double* zu) const;
+
+    // Returns the basic solution and basis from the last call to Solve() into
+    // user arrays. A basic solution and basis are available if
+    // GetInfo().status_crossover == IPX_STATUS_optimal ||
+    // GetInfo().status_crossover == IPX_STATUS_imprecise. Otherwise the method
+    // does nothing. Each of the pointer arguments must either be NULL or an
+    // array of appropriate dimension. If NULL, the quantity is not returned.
+    // Returns -1 if no basic solution was available and 0 otherwise.
+    Int GetBasicSolution(double* x, double* slack, double* y, double* z,
+                         Int* cbasis, Int* vbasis) const;
+
+    // Returns/sets all paramters. Without calling SetParameters(), the solver
+    // uses the default values of a Parameters object.
+    Parameters GetParameters() const;
+    void SetParameters(Parameters new_parameters);
+
+    // Sets the callback in control
+    void SetCallback(HighsCallback* callback);
+
+    // Discards the model and solution (if any) but keeps the parameters.
+    void ClearModel();
+
+    // Discards the starting point (if any).
+    void ClearIPMStartingPoint();
+
+    // Runs crossover for the given starting point. The starting point must be
+    // complementary and satisfy bound and sign conditions; i.e. a dual variable
+    // must be non-positive (non-negative) when its primal is not at lower
+    // (upper) bound. Each of the pointer arguments can be NULL, in which case
+    // all elements of the vector are assumed to be zero.
+    // Returns:
+    // 0                            starting point OK
+    // IPX_ERROR_invalid_vector     starting point not complementary or violates
+    //                              bound or sign conditions
+    Int CrossoverFromStartingPoint(const double* x_start,
+                                   const double* slack_start,
+                                   const double* y_start,
+                                   const double* z_start);
+
+    // -------------------------------------------------------------------------
+    // The remaining methods are for debugging.
+    // -------------------------------------------------------------------------
+
+    // Returns the current IPM iterate without postsolve. The method does
+    // nothing when no iterate is available (i.e. when IPM was not started).
+    // @x, @xl, @xu, @zl, @zu: either NULL or size num_cols_solver arrays.
+    // @y: either NULL or size num_rows_solver array.
+    // Returns -1 if no IPM iterate was available and 0 otherwise.
+    Int GetIterate(double* x, double* y, double* zl, double* zu, double* xl,
+                   double* xu);
+
+    // Returns the current basis postsolved.
+    // - If crossover terminated successfully, this is the basis returned by
+    //   GetBasicSolution().
+    // - If crossover failed, this is the basis at which failure occured.
+    // - If crossover was not called, this is the basis from the IPM
+    //   preconditioner.
+    // - If no basis is available, the method does nothing.
+    // @cbasis: either NULL or size num_constr array.
+    // @vbasis: either NULL or size num_var array.
+    // Returns -1 if no basis was available and 0 otherwise.
+    Int GetBasis(Int* cbasis, Int* vbasis);
+
+    // Returns the constraint matrix from the solver (including slack columns)
+    // and the diagonal from the (1,1) block of the KKT matrix corresponding to
+    // the current IPM iterate. The method does nothing when no IPM iterate is
+    // available (i.e. when IPM was not started).
+    // @AIp: either NULL or size num_cols_solver + 1 array.
+    // @AIi, @AIx: either NULL or size num_entries_solver arrays.
+    // (If any of the three arguments is NULL, the matrix is not returned.)
+    // @g: either NULL or size num_cols_solver array.
+    // Returns -1 if no IPM iterate was available and 0 otherwise.
+    Int GetKKTMatrix(Int* AIp, Int* AIi, double* AIx, double* g);
+
+    // (Efficiently) computes the number of nonzeros per row and column of the
+    // symbolic inverse of the basis matrix.
+    // @rowcounts, @colcounts: either NULL or size num_rows_solver arrays.
+    // Returns -1 if no basis was available and 0 otherwise.
+    Int SymbolicInvert(Int* rowcounts, Int* colcounts);
+
+private:
+    void ClearSolution();
+    void InteriorPointSolve();
+    void RunIPM();
+    void MakeIPMStartingPointValid();
+    void ComputeStartingPoint(IPM& ipm);
+    void RunInitialIPM(IPM& ipm);
+    void BuildStartingBasis();
+    void RunMainIPM(IPM& ipm);
+    void BuildCrossoverStartingPoint();
+    void RunCrossover();
+    void PrintSummary();
+
+    Control control_;
+    Info info_;
+    Model model_;
+    std::unique_ptr<Iterate> iterate_;
+    std::unique_ptr<Basis> basis_;
+
+    // Basic solution computed by crossover and basic status of each variable
+    // (one of IPX_nonbasic_lb, IPX_nonbasic_ub, IPX_basic, IPX_superbasic).
+    // If crossover was not run or failed, then basic_statuses_ is empty.
+    // If crossover_weights_ is non-empty at call to RunCrossover(), then it
+    // contains model_.cols() + model_.rows() weights that define the order of
+    // primal and dual pushes.
+    Vector x_crossover_, y_crossover_, z_crossover_;
+    Vector crossover_weights_;
+    std::vector<Int> basic_statuses_;
+
+    // IPM starting point provided by user (presolved).
+    Vector x_start_, xl_start_, xu_start_, y_start_, zl_start_, zu_start_;
+};
+
+}  // namespace ipx
+
+#endif  // IPX_LP_SOLVER_H_

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

@@ -0,0 +1,79 @@
+#ifndef IPX_LU_FACTORIZATION_H_
+#define IPX_LU_FACTORIZATION_H_
+
+#include <vector>
+#include "ipm/ipx/ipx_internal.h"
+#include "ipm/ipx/sparse_matrix.h"
+
+namespace ipx {
+
+// Interface class for LU factorization. Implementations perform the
+// factorization and immediately return the factors. They do not preserve any
+// memory in their object.
+
+class LuFactorization {
+public:
+    virtual ~LuFactorization() {}
+    LuFactorization& operator=(const LuFactorization&) = delete;
+    LuFactorization& operator=(LuFactorization&&) = delete;
+
+    // Computes the factorization
+    //
+    //   B[rowperm,colperm] = (L+I)*U
+    //
+    // into a strict lower triangular matrix L and an upper triangular matrix U.
+    // If B is singular, the dependent columns are replaced by unit columns in
+    // the product (L+I)*U.
+    //
+    // @dim: dimension of matrix B
+    // @Bbegin, @Bend, @Bi, @Bx: matrix B in sparse column format. The row
+    //                           indices and nonzero values of column j are in
+    //                           Bi[Bbegin[j]..Bend[j]-1] and
+    //                           Bx[Bbegin[j]..Bend[j]-1].
+    //                           Indices need not be sorted, but there must be
+    //                           no duplicates or invalid entries (need not be
+    //                           checked by the implementation).
+    // @pivottol: tolerance for partial threshold pivoting, from (0,1].
+    // @strict_abs_pivottol: If true, then the implementation is asked to use
+    //                       kLuDependencyTol as absolute pivot tolerance and to
+    //                       remove columns from the active submatrix
+    //                       immediately when all entries became smaller than
+    //                       the absolute pivot tolerance. Need not be supported
+    //                       by the implementation.
+    // @L, @U: return the matrix factors with sorted indices. The objects are
+    //         resized as necessary.
+    // @rowperm, @colperm: return the row and column permutation. The objects
+    //                     are resized for dim entries.
+    // @dependent_cols: returns the column indices of B[:,colperm] in which
+    //                  no pivot was found.
+    //
+    // Factorize() cannot fail other than out of memory, in which case
+    // std::bad_alloc is thrown.
+    void Factorize(Int dim, const Int* Bbegin, const Int* Bend,
+                   const Int* Bi, const double* Bx, double pivottol,
+                   bool strict_abs_pivottol,
+                   SparseMatrix* L, SparseMatrix* U,
+                   std::vector<Int>* rowperm, std::vector<Int>* colperm,
+                   std::vector<Int>* dependent_cols);
+
+    // Returns a stability measure for the factorization computed in the last
+    // call to Factorize(). 0.0 means ultimately stable; a value >> machine
+    // precision means that the factorization was numerically unstable, i.e.
+    // the relative pivot tolerance was too small.
+    double stability() const;
+
+private:
+    virtual void _Factorize(Int dim, const Int* Bbegin, const Int* Bend,
+                            const Int* Bi, const double* Bx, double pivottol,
+                            bool strict_abs_pivottol,
+                            SparseMatrix* L, SparseMatrix* U,
+                            std::vector<Int>* rowperm,
+                            std::vector<Int>* colperm,
+                            std::vector<Int>* dependent_cols) = 0;
+
+    double stability_{0.0};
+};
+
+}  // namespace ipx
+
+#endif  // IPX_LU_FACTORIZATION_H_

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

@@ -0,0 +1,129 @@
+#ifndef IPX_LU_UPDATE_H_
+#define IPX_LU_UPDATE_H_
+
+#include <vector>
+#include "ipm/ipx/indexed_vector.h"
+#include "ipm/ipx/sparse_matrix.h"
+
+namespace ipx {
+
+// Interface class for LU factorization + update implementations.
+
+class LuUpdate {
+public:
+    virtual ~LuUpdate() {}
+    LuUpdate& operator=(const LuUpdate&) = delete;
+    LuUpdate& operator=(LuUpdate&&) = delete;
+
+    // Factorizes matrix given in compressed column format (4-array notation).
+    // The matrix dimension (denoted dim in the documentation of the following
+    // methods) is set by the constructor of the derived class. If during the
+    // course of the factorization a column of the active submatrix becomes
+    // (numerically) zero, it is replaced by a unit column in L*U.
+    //
+    // @strict_abs_pivottol: If true, then the implementation is asked to use
+    //                       kLuDependencyTol as absolute pivot tolerance and to
+    //                       remove columns from the active submatrix
+    //                       immediately when all entries became smaller than
+    //                       the absolute pivot tolerance. Need not be supported
+    //                       by the implementation.
+    //
+    // Factorize() cannot fail other than for out of memory, in which case
+    // std::bad_alloc is thrown. Returns
+    // 0 OK
+    // 1 OK, but the factorization is numerically unstable; suggests tightening
+    //   the pivot tolerance (see below) and to refactorize.
+    // 2 OK, but singularities occured and were replaced by unit columns.
+    // 3 = 1 and 2
+    Int Factorize(const Int* Bbegin, const Int* Bend, const Int* Bi,
+                  const double* Bx, bool strict_abs_pivottol);
+
+    // Exports LU factors. The method can only be called after a fresh
+    // factorization. (Otherwise an assertion will fail.) It returns L, U and
+    // permutations such that
+    //
+    //   B[rowperm,colperm] = (L+I)*U,
+    //
+    // where B is the matrix given to Factorize() after replacing dependent
+    // columns by unit columns. The indices in L and U are sorted. Any of the
+    // arguments can be NULL, in which case the quantity is not returned.
+    //
+    // @L: returns matrix L, will be resized as necessary.
+    // @U: returns matrix U, will be resized as necessary.
+    // @rowperm: size dim array, returns row permutation.
+    // @colperm: size dim array, returns column permutation.
+    // @dependent_cols: returns indices k for which U[:,k] was replaced by a
+    //                  unit column in Factorize().
+    void GetFactors(SparseMatrix* L, SparseMatrix* U, Int* rowperm,
+                    Int* colperm, std::vector<Int>* dependent_cols);
+
+    // Solves linear system with dense right-hand side and solution.
+    // @rhs, @lhs: size dim vectors, may refer to the same object.
+    // @trans: 't' or 'T' for transposed system
+    void SolveDense(const Vector& rhs, Vector& lhs, char trans);
+
+    // Solves B*x=b in preparation for replacing a column of B by b.
+    // @nz, @bi, @bx: b as compressed sparse vector.
+    // @lhs: size dim vector returning x.
+    // The 3-argument version can save the triangular solve with U.
+    void FtranForUpdate(Int nz, const Int* bi, const double* bx);
+    void FtranForUpdate(Int nz, const Int* bi, const double* bx,
+                        IndexedVector& lhs);
+
+    // Solves B'*y=ej in preparation for replacing column j of B, where ej
+    // denotes the j-th unit vector.
+    // @lhs: size dim vector returning y.
+    // The 1-argument version can save the triangular solve with L.
+    void BtranForUpdate(Int j);
+    void BtranForUpdate(Int j, IndexedVector& lhs);
+
+    // Updates factorization. The column to be replaced was defined in the last
+    // call to BtranForUpdate(). The new column was given in the last call to
+    // FtranForUpdate(). Both methods must have been called prior to Update().
+    // (Otherwise an assertion will fail.)
+    // @pivot: p-th entry of B^{-1}*b, if column p of B is to be replaced by b.
+    // Returns: < 0 if the updated matrix is (numerically) singular. The update
+    //              may or may not have been performed. The behaviour is
+    //              undefined if any of the solve routines is called before
+    //              computing a fresh factorization.
+    //          > 0 if the updated factorization looks numerically unstable.
+    //            0 otherwise
+    Int Update(double pivot);
+
+    // Returns true if refactorization is required or recommended for memory
+    // or speed. No stability test is done.
+    bool NeedFreshFactorization();
+
+    // Returns (nnz(L)+nnz(U))/nnz(B) from the last factorization.
+    double fill_factor() const;
+
+    // Gets/sets the tolerance for partial threshold pivoting in Factorize().
+    double pivottol() const;
+    void pivottol(double new_pivottol);
+
+    // Returns the number of updates since the last factorization.
+    Int updates() const;
+
+private:
+    virtual Int _Factorize(const Int* Bbegin, const Int* Bend, const Int* Bi,
+                           const double* Bx, bool strict_abs_pivottol) = 0;
+    virtual void _GetFactors(SparseMatrix* L, SparseMatrix* U, Int* rowperm,
+                             Int* colperm, std::vector<Int>* dep_cols) = 0;
+    virtual void _SolveDense(const Vector& rhs, Vector& lhs, char trans) = 0;
+    virtual void _FtranForUpdate(Int nz, const Int* bi, const double* bx) = 0;
+    virtual void _FtranForUpdate(Int nz, const Int* bi, const double* bx,
+                                IndexedVector& lhs) = 0;
+    virtual void _BtranForUpdate(Int p) = 0;
+    virtual void _BtranForUpdate(Int p, IndexedVector& lhs) = 0;
+    virtual Int _Update(double pivot) = 0;
+    virtual bool _NeedFreshFactorization() = 0;
+    virtual double _fill_factor() const = 0;
+    virtual double _pivottol() const = 0;
+    virtual void _pivottol(double new_pivottol) = 0;
+
+    Int updates_{0};            // counts updates since factorization
+};
+
+}  // namespace ipx
+
+#endif  // IPX_LU_UPDATE_H_

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

@@ -0,0 +1,54 @@
+#ifndef IPX_MAXVOLUME_H_
+#define IPX_MAXVOLUME_H_
+
+#include "ipm/ipx/basis.h"
+#include "ipm/ipx/control.h"
+
+namespace ipx {
+
+class Maxvolume {
+public:
+    explicit Maxvolume(const Control& control);
+    Int RunSequential(const double* colscale, Basis& basis);
+    Int RunHeuristic(const double* colscale, Basis& basis);
+
+    Int updates() const;        // # basis updates
+    Int skipped() const;        // # columns computed but basis not updated
+    Int passes() const;         // # passes over tblmatrix (-1 for heuristic)
+    Int slices() const;         // # slices of tblmatrix formed (heuristic only)
+    double volinc() const;      // log2 of volume increase
+    double time() const;        // runtime
+
+    // The remaining statistics are only set by RunSequential() and count the
+    // final pass over the tableau matrix. They are meaningful only if no
+    // updates occured in the final pass; this is guaranteed if parameter
+    // max_passes was larger than passes().
+
+    Int tblnnz() const;              // nnz of tableau matrix
+    double tblmax() const;           // max entry of scaled tableau matrix
+    double frobnorm_squared() const; // Frob.norm squared of scaled tableau
+
+private:
+    static constexpr double kPivotZeroTol = 1e-7;
+
+    struct Slice;
+    void Reset();
+    Int Driver(Basis& basis, Slice& slice);
+    Int ScaleFtran(double colscale_jn, const Vector& invscale_basic,
+                   IndexedVector& ftran);
+
+    const Control& control_;
+    Int updates_{0};
+    Int skipped_{0};
+    Int passes_{0};
+    Int slices_{0};
+    double volinc_{0.0};
+    double time_{0.0};
+    Int tblnnz_{0};
+    double tblmax_{0.0};
+    double frobnorm_squared_{0.0};
+};
+
+}  // namespace ipx
+
+#endif  // IPX_MAXVOLUME_H_