lpsolver 0.1.0 → 0.2.1

data/ext/lpsolver-highs/build/include/highs/ipm/ipx/control.h

@@ -0,0 +1,167 @@
+#ifndef IPX_CONTROL_H_
+#define IPX_CONTROL_H_
+
+#include <fstream>
+#include <ostream>
+#include <sstream>
+#include <string>
+#include "io/HighsIO.h"
+#include "ipm/ipx/ipx_internal.h"
+#include "ipm/ipx/multistream.h"
+#include "ipm/ipx/timer.h"
+
+namespace ipx {
+
+// Class Control handles
+// (1) accessing user parameters,
+// (2) solver output,
+// (3) solver interruption.
+// Currently the solver is interrupted only by time limit. The interrupt
+// mechanism could also be used if we run IPX and a simplex code concurrently
+// and want to interrupt IPX when the simplex finished. For that reason a
+// Control object cannot be copied; assuming that one thread sets an interrupt
+// signal (not implemented yet), a call to control.InterruptCheck() from any
+// part of the solver must return nonzero. Hence we must only have references or
+// pointers to a single Control object in the whole of IPX.
+
+class Control {
+public:
+    Control();
+
+    // disallow copy and copy construction
+    Control& operator=(const Control&) = delete;
+    Control(const Control&) = delete;
+
+    // disallow move and move construction
+    Control& operator=(Control&&) = delete;
+    Control(const Control&&) = delete;
+
+    // Returns IPX_ERROR_* if interrupt is requested, 0 otherwise.
+    Int InterruptCheck(const Int ipm_iteration_count = -1) const;
+
+    // Returns output streams for log and debugging messages. The streams
+    // evaluate to false if they discard output, so that we can write
+    //
+    //   if (control.Debug(3))
+    //     control.Debug(3) << expensive_computation(...) << '\n';
+    //
+    // If the debug level is < 3, expensive_computation() is not performed.
+    void hLog(std::stringstream& logging) const;
+    void hLog(std::string str) const;
+    void hDebug(std::stringstream& logging, Int level=1) const;
+    std::ostream& Debug(Int level=1) const;
+
+    // Sends logging to HiGHS logging or the log stream according to
+    // parameters.highs_logging, if >= parameters.print_interval
+    // seconds have been elapsed since the last call to IntervalLog()
+    // or to ResetPrintInterval().
+    void hIntervalLog(std::stringstream& logging) const;
+    void ResetPrintInterval() const;
+
+    double Elapsed() const;     // total runtime
+
+    ipxint dualize() const { return parameters_.dualize; }
+    ipxint scale() const { return parameters_.scale; }
+    ipxint ipm_maxiter() const { return parameters_.ipm_maxiter; }
+    double ipm_feasibility_tol() const {
+        return parameters_.ipm_feasibility_tol; }
+    double ipm_optimality_tol() const { return parameters_.ipm_optimality_tol; }
+    double ipm_drop_primal() const { return parameters_.ipm_drop_primal; }
+    double ipm_drop_dual() const { return parameters_.ipm_drop_dual; }
+    double kkt_tol() const { return parameters_.kkt_tol; }
+    ipxint crash_basis() const { return parameters_.crash_basis; }
+    double dependency_tol() const { return parameters_.dependency_tol; }
+    double volume_tol() const { return parameters_.volume_tol; }
+    ipxint rows_per_slice() const { return parameters_.rows_per_slice; }
+    ipxint maxskip_updates() const { return parameters_.maxskip_updates; }
+    ipxint lu_kernel() const { return parameters_.lu_kernel; }
+    double lu_pivottol() const { return parameters_.lu_pivottol; }
+    ipxint run_crossover() const { return parameters_.run_crossover; }
+    double start_crossover_tol() const { return parameters_.start_crossover_tol; }
+    double pfeasibility_tol() const { return parameters_.pfeasibility_tol; }
+    double dfeasibility_tol() const { return parameters_.dfeasibility_tol; }
+    ipxint switchiter() const { return parameters_.switchiter; }
+    ipxint stop_at_switch() const { return parameters_.stop_at_switch; }
+    ipxint update_heuristic() const { return parameters_.update_heuristic; }
+    ipxint maxpasses() const { return parameters_.maxpasses; }
+    bool reportBasisData() const { return parameters_.analyse_basis_data; }
+    ipxint runCentring() const{return parameters_.run_centring; }
+    ipxint maxCentringSteps() const{return parameters_.max_centring_steps; }
+    double centringRatioTolerance() const{return parameters_.centring_ratio_tolerance; }
+    double centringRatioReduction() const {return parameters_.centring_ratio_reduction; }
+    double centringAlphaScaling() const{return parameters_.centring_alpha_scaling; }
+    ipxint badProductsTolerance() const{return parameters_.bad_products_tolerance; }
+    bool timelessLog() const{return parameters_.timeless_log; }
+    void setTimerOffset(const double offset) { this->timer_.offset_ = offset; }
+
+
+    const Parameters& parameters() const;
+    void parameters(const Parameters& new_parameters);
+    void callback(HighsCallback* callback);
+
+    // Opens the log file defined in parameters.logfile, if any.
+    // Ignores if an error occurs; in this case no file log is written.
+    void OpenLogfile();
+
+    // Closes an opened log file, if any.
+    void CloseLogfile();
+
+    // Resets the total runtime counter.
+    void ResetTimer();
+
+private:
+    void MakeStream();           // composes output_
+    Parameters parameters_;
+    HighsCallback* callback_ = nullptr;
+    std::ofstream logfile_;
+    Timer timer_;                // total runtime
+    mutable Timer interval_;     // time since last interval log
+    mutable Multistream output_; // forwards to logfile and/or console
+    mutable Multistream dummy_;  // discards everything
+};
+
+// Formats integer, string literal or floating point value into a string of
+// size at least @width. So we can put formatted output into a stream without
+// altering the stream's state.
+std::string Format(Int i, int width);
+std::string Format(const char* c, int width);
+std::string Format(double d, int width, int prec,
+                   std::ios_base::fmtflags floatfield);
+
+// shortcuts
+inline std::string Scientific(double d, int width, int prec) {
+    return Format(d, width, prec, std::ios_base::scientific);
+}
+inline std::string Fixed(double d, int width, int prec) {
+    return Format(d, width, prec, std::ios_base::fixed);
+}
+inline std::string sci2(double d) { return Scientific(d,0,2); }
+inline std::string sci8(double d) { return Scientific(d,0,8); }
+inline std::string fix2(double d) { return Fixed(d,0,2); }
+inline std::string fix8(double d) { return Fixed(d,0,8); }
+inline std::string time(double d) { return Fixed(d,8,1); }
+
+// Formats @text into a line of fixed width and indentation.
+// This is used to print messages like
+//
+//     Number of variables:                                1464
+//     Number of constraints:                              696
+//
+// consistently via control.hLog(h_logging_stream) using 
+//
+//   h_logging_stream << Textline("Number of variables:") << 1464 << '\n'
+//                    << Textline("Number of constraints:") << 696 << '\n';
+//
+template <typename T>
+std::string Textline(const T& text) {
+    std::ostringstream s;
+    s << "    ";
+    s.setf(std::ios_base::left);
+    s.width(52);
+    s << text;
+    return s.str();
+}
+
+}  // namespace ipx
+
+#endif  // IPX_CONTROL_H_

data/ext/lpsolver-highs/build/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_

data/ext/lpsolver-highs/build/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_

data/ext/lpsolver-highs/build/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_

data/ext/lpsolver-highs/build/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_

data/ext/lpsolver-highs/build/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_

data/ext/lpsolver-highs/build/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_