lpsolver 0.1.0 → 0.2.1

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

data/ext/lpsolver-highs/highs/ipm/ipx/splitted_normal_matrix.cc

@@ -0,0 +1,117 @@
+#include "ipm/ipx/splitted_normal_matrix.h"
+#include <cassert>
+#include <cmath>
+#include "ipm/ipx/timer.h"
+#include "ipm/ipx/utils.h"
+
+namespace ipx {
+
+SplittedNormalMatrix::SplittedNormalMatrix(const Model& model) : model_(model) {
+    Int m = model_.rows();
+    colperm_.resize(m);
+    rowperm_inv_.resize(m);
+    work_.resize(m);
+}
+
+void SplittedNormalMatrix::Prepare(const Basis& basis, const double* colscale) {
+    const Int m = model_.rows();
+    const Int n = model_.cols();
+    const SparseMatrix& AI = model_.AI();
+    assert(colscale);
+    prepared_ = false;
+    N_.clear();                 // deallocate old memory
+
+    basis.GetLuFactors(&L_, &U_, rowperm_inv_.data(), colperm_.data());
+    rowperm_inv_ = InversePerm(rowperm_inv_);
+
+    // Scale columns of U.
+    for (Int k = 0; k < m; k++) {
+        Int p = colperm_[k];
+        Int j = basis[p];
+        // Nothing to do for BASIC_FREE variables.
+        if (basis.StatusOf(j) == Basis::BASIC) {
+            double d = colscale[j];
+            assert(std::isfinite(d) && d > 0.0);
+            ScaleColumn(U_, k, d);
+        }
+    }
+
+    // Build N with permuted row indices.
+    std::vector<Int> nonbasic_vars;
+    for (Int j = 0; j < n+m; j++)
+        if (basis.StatusOf(j) == Basis::NONBASIC)
+            nonbasic_vars.push_back(j);
+    N_ = CopyColumns(AI, nonbasic_vars);
+    PermuteRows(N_, rowperm_inv_);
+
+    // Scale columns of N.
+    for (size_t k = 0; k < nonbasic_vars.size(); k++) {
+        Int j = nonbasic_vars[k];
+        double d = colscale[j];
+        assert(std::isfinite(d));
+        ScaleColumn(N_, (Int)k, d);
+    }
+
+    // Build list of free variables.
+    free_positions_.clear();
+    for (Int k = 0; k < m; k++) {
+        Int p = colperm_[k];
+        Int j = basis[p];
+        if (basis.StatusOf(j) == Basis::BASIC_FREE)
+            free_positions_.push_back(k);
+    }
+    prepared_ = true;
+}
+
+const Int* SplittedNormalMatrix::colperm() const {
+    return colperm_.data();
+}
+
+double SplittedNormalMatrix::time_B() const {
+    return time_B_;
+}
+
+double SplittedNormalMatrix::time_Bt() const {
+    return time_Bt_;
+}
+
+double SplittedNormalMatrix::time_NNt() const {
+    return time_NNt_;
+}
+
+void SplittedNormalMatrix::reset_time() {
+    time_B_ = 0.0;
+    time_Bt_ = 0.0;
+    time_NNt_ = 0.0;
+}
+
+void SplittedNormalMatrix::_Apply(const Vector& rhs, Vector& lhs,
+                                  double* rhs_dot_lhs) {
+    assert(prepared_);
+    Timer timer;
+
+    // Compute work = inverse(B') * rhs.
+    work_ = rhs;
+    timer.Reset();
+    BackwardSolve(L_, U_, work_);
+    time_Bt_ += timer.Elapsed();
+
+    // Compute lhs = N*N' * work.
+    lhs = 0.0;
+    timer.Reset();
+    AddNormalProduct(N_, nullptr, work_, lhs);
+    time_NNt_ += timer.Elapsed();
+
+    // Compute lhs := inverse(B) * lhs.
+    timer.Reset();
+    ForwardSolve(L_, U_, lhs);
+    time_B_ += timer.Elapsed();
+
+    lhs += rhs;
+    for (Int i : free_positions_)
+        lhs[i] = 0.0;
+    if (rhs_dot_lhs)
+        *rhs_dot_lhs = Dot(rhs,lhs);
+}
+
+}  // namespace ipx

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

data/ext/lpsolver-highs/highs/ipm/ipx/starting_basis.cc

@@ -0,0 +1,182 @@
+#include "ipm/ipx/starting_basis.h"
+#include <cassert>
+#include <cmath>
+#include <vector>
+#include "ipm/ipx/timer.h"
+
+namespace ipx {
+
+// Asserts that variables have a state and basic status that is consistent with
+// their bounds in the model.
+static void AssertConsistency(const Iterate& iterate, const Basis& basis) {
+    const Model& model = basis.model();
+    const Int m = model.rows();
+    const Int n = model.cols();
+    const Vector& lb = model.lb();
+    const Vector& ub = model.ub();
+
+    for (Int j = 0; j < n+m; j++) {
+        if (lb[j] == ub[j]) {
+            switch (iterate.StateOf(j)) {
+            case Iterate::State::fixed:
+                assert(basis.StatusOf(j) == Basis::NONBASIC_FIXED);
+                break;
+            case Iterate::State::free:
+                assert(j >= n); // must be slack variable
+                assert(basis.StatusOf(j) == Basis::BASIC_FREE);
+                break;
+            default:
+                assert(0);
+            }
+        } else if (std::isinf(lb[j]) && std::isinf(ub[j])) {
+            switch (iterate.StateOf(j)) {
+            case Iterate::State::fixed:
+                assert(basis.StatusOf(j) == Basis::NONBASIC_FIXED);
+                break;
+            case Iterate::State::free:
+                assert(basis.StatusOf(j) == Basis::BASIC_FREE);
+                break;
+            default:
+                assert(0);
+            }
+        } else {
+            assert(iterate.StateOf(j) == Iterate::State::barrier);
+            assert(basis.StatusOf(j) == Basis::NONBASIC ||
+                   basis.StatusOf(j) == Basis::BASIC);
+        }
+    }
+}
+
+static void PostprocessDependencies(Iterate* iterate, Basis* p_basis,
+                                    Info* info) {
+    const Model& model = iterate->model();
+    const Int m = model.rows();
+    const Int n = model.cols();
+    const SparseMatrix& AI = model.AI();
+    const Vector& lb = model.lb();
+    const Vector& ub = model.ub();
+    const Vector& x = iterate->x();
+    const Vector& y = iterate->y();
+    const Vector& zl = iterate->zl();
+    const Vector& zu = iterate->zu();
+    Basis& basis = *p_basis;
+    std::vector<Int> dependent_rows, dependent_cols;
+    Vector dx(n+m), dy(m);
+
+    // Postprocess linearly dependent columns. If a free variable could not be
+    // made basic, then the variable is redundant and can be fixed at an
+    // arbitrary value. We fix it at zero and adapt the basic variables to keep
+    // AI*x unchanged.
+    if (info->dependent_cols > 0) {
+        Vector dxbasic(m);
+        for (Int j = 0; j < n; j++) {
+            if (std::isinf(lb[j]) && std::isinf(ub[j]) && basis.IsNonbasic(j)) {
+                assert(iterate->StateOf(j) == Iterate::State::free);
+                assert(basis.StatusOf(j) == Basis::NONBASIC_FIXED);
+                dx[j] = -x[j];
+                ScatterColumn(AI, j, x[j], dxbasic);
+                dependent_cols.push_back(j);
+            }
+        }
+        basis.SolveDense(dxbasic, dxbasic, 'N');
+        for (Int p = 0; p < m; p++)
+            dx[basis[p]] = dxbasic[p];
+    }
+
+    // Postprocess linearly dependent rows. If the slack variable to an equality
+    // constraint cannot be made nonbasic, then the constraint is redundant. We
+    // move its dual variable y[i] to zero without altering A'*y and make the
+    // constraint "implied" (i.e. the slack variable is treated as free by the
+    // interior point solver).
+    if (info->dependent_rows > 0) {
+        for (Int p = 0; p < m; p++) {
+            Int j = basis[p];
+            // The starting basis is constructed such that structural variables
+            // with weight zero will always be nonbasic.
+            if (lb[j] == ub[j])
+                assert(j >= n);
+            if (j >= n && lb[j] == ub[j]) {
+                assert(basis.StatusOf(j) == Basis::BASIC_FREE);
+                assert(iterate->has_barrier_lb(j));
+                assert(iterate->has_barrier_ub(j));
+                dy[p] = -y[j-n];
+                dependent_rows.push_back(j-n);
+            }
+        }
+        basis.SolveDense(dy, dy, 'T');
+        for (Int i : dependent_rows)
+            dy[i] = -y[i];      // would be already in exact arithmetic
+    }
+
+    // Now adjust the iterate.
+    iterate->Update(1.0, &dx[0], nullptr, nullptr, 1.0, &dy[0], nullptr,
+                    nullptr);
+
+    for (Int j : dependent_cols) {
+        assert(x[j] == 0.0);
+        iterate->make_fixed(j, 0.0);
+    }
+    for (Int i : dependent_rows) {
+        assert(y[i] == 0.0);
+        iterate->make_implied_eq(n+i); // sets zl[n+i] = zu[n+i] = 0
+        assert(zl[n+i] == 0.0);
+        assert(zu[n+i] == 0.0);
+    }
+}
+
+void StartingBasis(Iterate* iterate, Basis* p_basis, Info* info) {
+    const Model& model = iterate->model();
+    const Int m = model.rows();
+    const Int n = model.cols();
+    const Vector& lb = model.lb();
+    const Vector& ub = model.ub();
+    Vector colscale(n+m);
+    Basis& basis = *p_basis;
+    info->errflag = 0;
+    Timer timer;
+
+    // Construct starting basis. The column weights for the crash procedure are
+    // the interior point scaling factors from the current iterate, except that
+    // fixed variables get weight zero.
+    for (Int j = 0; j < n+m; j++) {
+        colscale[j] = iterate->ScalingFactor(j);
+        if (std::isinf(lb[j]) && std::isinf(ub[j]))
+            assert(colscale[j] == INFINITY);
+        else
+            assert(std::isfinite(colscale[j]));
+        if (lb[j] == ub[j])
+            colscale[j] = 0.0;
+    }
+    basis.ConstructBasisFromWeights(&colscale[0], info);
+    if (info->errflag)
+        return;
+
+    // Change status of free variables either to BASIC_FREE or NONBASIC_FIXED.
+    // Change status of fixed variables either to NONBASIC_FIXED or BASIC_FREE.
+    for (Int j = 0; j < n+m; j++) {
+        if (colscale[j] == 0.0 || std::isinf(colscale[j])) {
+            if (basis.IsBasic(j))
+                basis.FreeBasicVariable(j);
+            else
+                basis.FixNonbasicVariable(j);
+        }
+    }
+
+    // Variables with equal lower and upper bounds can be removed from the
+    // interior point solve if their basic status is NONBASIC_FIXED. Setting
+    // x[j] to its bound alters the residual in AI*x=b; this can be ignored
+    // because the iterate has not been primal feasible if x[j] was
+    // significantly away from its bound.
+    for (Int j = 0; j < n+m; j++) {
+        if (lb[j] == ub[j] && basis.StatusOf(j) == Basis::NONBASIC_FIXED)
+            iterate->make_fixed(j, lb[j]);
+    }
+
+    // Linearly dependent rows and columns require adjusting the iterate.
+    PostprocessDependencies(iterate, p_basis, info);
+
+    AssertConsistency(*iterate, basis);
+    info->time_starting_basis += timer.Elapsed();
+}
+
+}  // namespace ipx

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

data/ext/lpsolver-highs/highs/ipm/ipx/symbolic_invert.cc

@@ -0,0 +1,183 @@
+#include "ipm/ipx/symbolic_invert.h"
+#include <algorithm>
+#include <cassert>
+#include <random>
+#include "ipm/ipx/sparse_matrix.h"
+#include "ipm/ipx/sparse_utils.h"
+
+namespace ipx {
+
+static std::vector<Int> RandomPermute(const std::vector<Int>& basis) {
+    const Int m = basis.size();
+    std::default_random_engine re;
+    std::uniform_int_distribution<Int> dist(0,m-1);
+    std::vector<Int> permuted_basis(basis);
+    for (Int k = 0; k < m; k++)
+        std::swap(permuted_basis[k], permuted_basis[dist(re)]);
+    return permuted_basis;
+}
+
+static std::vector<Int> Matching(const Model& model,
+                                 const std::vector<Int>& basis) {
+    const Int m = model.rows();
+    const Int n = model.cols();
+    const SparseMatrix& AI = model.AI();
+    const Int* Ap = AI.colptr();
+    const Int* Ai = AI.rowidx();
+    std::vector<Int> jmatch(m, -1);
+    std::vector<Int> cheap(Ap, Ap+n+m);
+    std::vector<Int> marked(n+m, -1);
+    std::vector<Int> work(m), work2(m+1), work3(m+1);
+
+    // Match singletons first, since then they are all cheap matches.
+    for (Int j : basis) {
+        if (Ap[j+1] == Ap[j]+1) {
+            bool matched = AugmentingPath(j, Ap, Ai, jmatch.data(),
+                                          cheap.data(), marked.data(),
+                                          work.data(), work2.data(),
+                                          work3.data());
+            assert(matched);
+        }
+    }
+    for (Int j : basis) {
+        if (Ap[j+1] != Ap[j]+1) {
+            bool matched = AugmentingPath(j, Ap, Ai, jmatch.data(),
+                                          cheap.data(), marked.data(),
+                                          work.data(), work2.data(),
+                                          work3.data());
+            assert(matched);
+        }
+    }
+    return jmatch;
+}
+
+static std::vector<std::vector<Int> >
+Blockperm(const SparseMatrix& AI, const std::vector<Int>& jmatch,
+          const SparseMatrix& BT) {
+    const Int m = AI.rows();
+    const Int* Ap = AI.colptr();
+    const Int* Ai = AI.rowidx();
+    const Int* BTp = BT.colptr();
+    const Int* BTi = BT.rowidx();
+
+    // Put row indices into istack, working from the bottom of the stack (m-1)
+    // to the top (0), so that indices whose depth-first search finished first
+    // appear further down the stack.
+    std::vector<Int> istack(m), marked(m), work(m);
+    Int top = m;
+    for (Int i = 0; i < m; i++) {
+        if (marked[i] != 1)
+            top = DepthFirstSearch(i, Ap, Ai, jmatch.data(), top, istack.data(),
+                                   marked.data(), 1, work.data());
+    }
+    assert(top == 0);
+
+    std::vector<std::vector<Int> > blocks;
+    std::vector<Int> rowperm(m);
+    top = m;
+    for (Int i : istack) {
+        if (marked[i] != 2) {
+            // Node i is not part of any block yet.
+            Int end = top;
+            top = DepthFirstSearch(i, BTp, BTi, nullptr, top, rowperm.data(),
+                                   marked.data(), 2, work.data());
+            assert(top < end);
+            blocks.push_back(std::vector<Int>(rowperm.begin() + top,
+                                              rowperm.begin() + end));
+        }
+    }
+    assert(top == 0);
+    std::reverse(blocks.begin(), blocks.end());
+    return blocks;
+}
+
+static SparseMatrix
+CoarsenedGraph(const SparseMatrix& BT,
+               const std::vector<std::vector<Int> >& blocks) {
+    const Int m = BT.rows();
+    const Int nb = blocks.size();
+
+    std::vector<Int> map2block(m, -1);
+    for (Int b = 0; b < nb; b++) {
+        for (Int i : blocks[b]) {
+            assert(map2block[i] == -1);
+            map2block[i] = b;
+        }
+    }
+    for (Int i = 0; i < m; i++)
+        assert(map2block[i] >= 0);
+
+    SparseMatrix C(nb, 0);
+    std::vector<Int> marked(m, -1);
+    for (Int k = 0; k < nb; k++) {
+        for (Int i : blocks[k]) {
+            for (Int p = BT.begin(i); p < BT.end(i); p++) {
+                Int b = map2block[BT.index(p)];
+                if (marked[b] != k) {
+                    marked[b] = k;
+                    C.push_back(b, 1.0);
+                    assert(b >= k);
+                }
+            }
+        }
+        C.add_column();
+    }
+    return C;
+}
+
+void SymbolicInvert(const Model& model, const std::vector<Int>& basis,
+                    Int* rowcounts, Int* colcounts) {
+    const SparseMatrix& AI = model.AI();
+    const Int m = AI.rows();
+    assert((Int)basis.size() == m);
+
+    // jmatch is a permutation of basis such that B = AI[:,jmatch] has a
+    // zero-free diagonal.
+    std::vector<Int> jmatch = Matching(model, RandomPermute(basis));
+    SparseMatrix BT = CopyColumns(AI, jmatch);
+    BT = Transpose(BT);
+
+    std::vector<std::vector<Int> > blocks = Blockperm(AI, jmatch, BT);
+    SparseMatrix C = CoarsenedGraph(BT, blocks);
+
+    const Int nb = blocks.size();
+    std::vector<Int> stack(nb), marked(nb), work(nb);
+
+    if (rowcounts) {
+        std::vector<Int> jcount(AI.cols(), -1);
+        std::fill(marked.begin(), marked.end(), -1);
+        const Int* Cp = C.colptr();
+        const Int* Ci = C.rowidx();
+        for (Int b = 0; b < nb; b++) {
+            Int top = DepthFirstSearch(b, Cp, Ci, nullptr, nb, stack.data(),
+                                       marked.data(), b, work.data());
+            Int nz = 0;
+            for (Int t = top; t < nb; t++)
+                nz += blocks[stack[t]].size();
+            for (Int i : blocks[b])
+                jcount[jmatch[i]] = nz;
+        }
+        for (Int p = 0; p < m; p++) {
+            rowcounts[p] = jcount[basis[p]];
+            assert(rowcounts[p] >= 0);
+        }
+    }
+
+    if (colcounts) {
+        C = Transpose(C);
+        std::fill(marked.begin(), marked.end(), -1);
+        const Int* Cp = C.colptr();
+        const Int* Ci = C.rowidx();
+        for (Int b = 0; b < nb; b++) {
+            Int top = DepthFirstSearch(b, Cp, Ci, nullptr, nb, stack.data(),
+                                       marked.data(), b, work.data());
+            Int nz = 0;
+            for (Int t = top; t < nb; t++)
+                nz += blocks[stack[t]].size();
+            for (Int i : blocks[b])
+                colcounts[i] = nz;
+        }
+    }
+}
+
+}  // namespace ipx

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

data/ext/lpsolver-highs/highs/ipm/ipx/timer.cc

@@ -0,0 +1,16 @@
+#include "ipm/ipx/timer.h"
+#include <cstdio>
+namespace ipx {
+
+Timer::Timer(const double offset)
+    : offset_(offset) {
+    Reset(true);
+}
+
+void Timer::Reset(const bool first) {
+  if (!first) offset_ -= t0_;
+  t0_ = read();
+  if (!first) offset_ += t0_;
+}
+
+}  // namespace ipx