lpsolver 0.1.0 → 0.2.1

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

@@ -0,0 +1,382 @@
+#include "ipm/ipx/sparse_matrix.h"
+#include <algorithm>
+#include <cassert>
+#include <cmath>
+#include <utility>
+#include "ipm/ipx/utils.h"
+#include "../extern/pdqsort/pdqsort.h"
+
+namespace ipx {
+
+SparseMatrix::SparseMatrix() {
+    resize(0,0);
+}
+
+SparseMatrix::SparseMatrix(Int nrow, Int ncol) {
+    resize(nrow, ncol);
+}
+
+SparseMatrix::SparseMatrix(Int nrow, Int ncol, Int min_capacity) {
+    resize(nrow, ncol, min_capacity);
+}
+
+void SparseMatrix::reserve(Int min_capacity) {
+    if (min_capacity > capacity()) {
+        rowidx_.resize(min_capacity);
+        values_.resize(min_capacity);
+    }
+}
+
+void SparseMatrix::resize(Int nrow, Int ncol, Int min_capacity) {
+    assert(nrow >= 0);
+    assert(ncol >= 0);
+    assert(min_capacity >= 0);
+    nrow_ = nrow;
+    colptr_.resize(ncol+1);
+    colptr_.shrink_to_fit();
+    std::fill(colptr_.begin(), colptr_.end(), 0);
+    rowidx_.resize(min_capacity);
+    rowidx_.shrink_to_fit();
+    values_.resize(min_capacity);
+    values_.shrink_to_fit();
+}
+
+void SparseMatrix::clear() {
+    resize(0,0);
+}
+
+void SparseMatrix::LoadFromArrays(Int nrow, Int ncol, const Int* Abegin,
+                                  const Int* Aend, const Int* Ai,
+                                  const double* Ax) {
+    Int nz = 0;
+    for (Int j = 0; j < ncol; j++)
+        nz += Aend[j]-Abegin[j];
+    resize(nrow, ncol, nz);
+    Int put = 0;
+    for (Int j = 0; j < ncol; j++) {
+        colptr_[j] = put;
+        for (Int p = Abegin[j]; p < Aend[j]; p++) {
+            if (Ax[p] != 0.0) {
+                rowidx_[put] = Ai[p];
+                values_[put] = Ax[p];
+                put++;
+            }
+        }
+    }
+    colptr_[ncol] = put;
+    SortIndices();
+}
+
+void SparseMatrix::SortIndices() {
+    if (IsSorted())
+        return;
+    std::vector<std::pair<Int,double>> work(rows());
+    for (Int j = 0; j < cols(); j++) {
+        Int nz = 0;             // # entries in column j
+        for (Int p = begin(j); p < end(j); p++) {
+            work[nz].first = index(p);
+            work[nz].second = value(p);
+            nz++;
+        }
+        pdqsort(work.begin(), work.begin() + nz);
+        for (Int k = 0, p = begin(j); p < end(j); k++, p++) {
+            index(p) = work[k].first;
+            value(p) = work[k].second;
+        }
+    }
+}
+
+void SparseMatrix::add_column() {
+    Int nz = entries();
+    Int nznew = nz + queue_size();
+    reserve(nznew);
+    std::copy(rowidx_queue_.begin(), rowidx_queue_.end(), rowidx_.begin() + nz);
+    std::copy(values_queue_.begin(), values_queue_.end(), values_.begin() + nz);
+    colptr_.push_back(nznew);
+    clear_queue();
+}
+
+void SparseMatrix::clear_queue() {
+    rowidx_queue_.clear();
+    values_queue_.clear();
+}
+
+bool SparseMatrix::IsSorted() const {
+    for (Int j = 0; j < cols(); j++) {
+        for (Int p = begin(j); p < end(j)-1; p++)
+            if (index(p) > index(p+1))
+                return false;
+    }
+    return true;
+}
+
+SparseMatrix Transpose(const SparseMatrix& A) {
+    SparseMatrix AT;
+    Transpose(A, AT);
+    return AT;
+}
+
+void Transpose(const SparseMatrix& A, SparseMatrix& AT) {
+    const Int m = A.rows();
+    const Int n = A.cols();
+    const Int nz = A.entries();
+    AT.resize(n, m, nz);
+
+    // Compute row counts of A in workspace.
+    std::vector<Int> work(m);
+    for (Int p = 0; p < nz; p++)
+        work[A.index(p)]++;
+
+    // Set column pointers for AT.
+    Int* ATp = AT.colptr();
+    Int sum = 0;
+    for (Int i = 0; i < m; i++) {
+        ATp[i] = sum;
+        sum += work[i];
+        work[i] = ATp[i];
+    }
+    assert(sum == nz);
+    ATp[m] = sum;
+
+    // Fill AT with one column of A at a time.
+    // work[i] is the next free slot in column i of AT.
+    for (Int j = 0; j < n; j++) {
+        for (Int p = A.begin(j); p < A.end(j); p++) {
+            Int put = work[A.index(p)]++;
+            AT.index(put) = j;
+            AT.value(put) = A.value(p);
+        }
+    }
+}
+
+SparseMatrix CopyColumns(const SparseMatrix& A, const std::vector<Int>& cols) {
+    SparseMatrix A2(A.rows(), 0);
+    for (Int j : cols) {
+        for (Int p = A.begin(j); p < A.end(j); p++)
+            A2.push_back(A.index(p), A.value(p));
+        A2.add_column();
+    }
+    return A2;
+}
+
+void PermuteRows(SparseMatrix& A, const std::vector<Int>& perm) {
+    for (Int p = 0; p < A.entries(); p++)
+        A.index(p) = perm[A.index(p)];
+}
+
+Int RemoveDiagonal(SparseMatrix& A, double* diag) {
+    Int ncol = A.cols();
+    Int* Ap = A.colptr();
+    Int* Ai = A.rowidx();
+    double* Ax = A.values();
+    Int get = 0;
+    Int put = 0;
+    for (Int j = 0; j < ncol; j++) {
+        if (diag)
+            diag[j] = 0.0;      // if no diagonal entry in column j
+        Ap[j] = put;
+        for (; get < Ap[j+1]; get++) {
+            if (Ai[get] == j) {
+                if (diag)
+                    diag[j] = Ax[get];
+            } else {
+                Ai[put] = Ai[get];
+                Ax[put] = Ax[get];
+                put++;
+            }
+        }
+    }
+    Ap[ncol] = put;
+    return get-put;
+}
+
+void MultiplyAdd(const SparseMatrix& A, const Vector& rhs, double alpha,
+                 Vector& lhs, char trans) {
+    const Int m = A.rows();
+    const Int n = A.cols();
+    if (trans == 't' || trans == 'T') {
+        assert((Int)rhs.size() == m);
+        assert((Int)lhs.size() == n);
+        for (Int j = 0; j < n; j++)
+            lhs[j] += alpha * DotColumn(A, j, rhs);
+    } else {
+        assert((Int)rhs.size() == n);
+        assert((Int)lhs.size() == m);
+        for (Int j = 0; j < n; j++)
+            ScatterColumn(A, j, alpha*rhs[j], lhs);
+    }
+}
+
+void AddNormalProduct(const SparseMatrix& A, const double* D, const Vector& rhs,
+                      Vector& lhs) {
+    const Int m = A.rows();
+    const Int n = A.cols();
+    assert((Int)rhs.size() == m);
+    assert((Int)lhs.size() == m);
+    for (Int j = 0; j < n; j++) {
+        double temp = DotColumn(A, j, rhs);
+        if (D) temp *= D[j]*D[j];
+        ScatterColumn(A, j, temp, lhs);
+    }
+}
+
+Int TriangularSolve(const SparseMatrix& A, Vector& x, char trans,
+                    const char* uplo, int unitdiag) {
+    const Int ncol = A.cols();
+    const Int* Ap = A.colptr();
+    const Int* Ai = A.rowidx();
+    const double* Ax = A.values();
+    Int nz = 0;
+    if (trans == 't' || trans == 'T') {
+        if (*uplo == 'u' || *uplo == 'U') {
+            // transposed solve with upper triangular matrix
+            for (Int i = 0; i < ncol; i++) {
+                Int begin = Ap[i];
+                Int end = Ap[i+1] - (unitdiag ? 0 : 1);
+                double d = 0.0;
+                for (Int p = begin; p < end; p++)
+                    d += x[Ai[p]] * Ax[p];
+                x[i] -= d;
+                if (!unitdiag) {
+                    assert(Ai[end] == i);
+                    x[i] /= Ax[end];
+                }
+                if (x[i] != 0.0)
+                    nz++;
+            }
+        } else {
+            // transposed solve with lower triangular matrix
+            for (Int i = ncol-1; i >= 0; i--) {
+                Int begin = Ap[i] + (unitdiag ? 0 : 1);
+                Int end = Ap[i+1];
+                double d = 0.0;
+                for (Int p = begin; p < end; p++)
+                    d += x[Ai[p]] * Ax[p];
+                x[i] -= d;
+                if (!unitdiag) {
+                    assert(Ai[begin-1] == i);
+                    x[i] /= Ax[begin-1];
+                }
+                if (x[i] != 0.0)
+                    nz++;
+            }
+        }
+    } else {
+        if (*uplo == 'u' || *uplo == 'U') {
+            // forward solve with upper triangular matrix
+            for (Int j = ncol-1; j >= 0; j--) {
+                Int begin = Ap[j];
+                Int end = Ap[j+1] - (unitdiag ? 0 : 1);
+                if (!unitdiag) {
+                    assert(Ai[end] == j);
+                    x[j] /= Ax[end];
+                }
+                double temp = x[j];
+                if (temp != 0.0) {
+                    for (Int p = begin; p < end; p++)
+                        x[Ai[p]] -= Ax[p] * temp;
+                    nz++;
+                }
+            }
+        } else {
+            // forward solve with lower triangular matrix
+            for (Int j = 0; j < ncol; j++) {
+                Int begin = Ap[j] + (unitdiag ? 0 : 1);
+                Int end = Ap[j+1];
+                if (!unitdiag) {
+                    assert(Ai[begin-1] == j);
+                    x[j] /= Ax[begin-1];
+                }
+                double temp = x[j];
+                if (temp != 0.0) {
+                    for (Int p = begin; p < end; p++)
+                        x[Ai[p]] -= Ax[p] * temp;
+                    nz++;
+                }
+            }
+        }
+    }
+    return nz;
+}
+
+void ForwardSolve(const SparseMatrix& L, const SparseMatrix& U, Vector& x) {
+    TriangularSolve(L, x, 'n', "lower", 1);
+    TriangularSolve(U, x, 'n', "upper", 0);
+}
+
+void BackwardSolve(const SparseMatrix& L, const SparseMatrix& U, Vector& x) {
+    TriangularSolve(U, x, 't', "upper", 0);
+    TriangularSolve(L, x, 't', "lower", 1);
+}
+
+double Onenorm(const SparseMatrix& A) {
+    double norm = 0.0;
+    for (Int j = 0; j < A.cols(); j++) {
+        double colsum = 0.0;
+        for (Int p = A.begin(j); p < A.end(j); p++)
+            colsum += std::abs(A.value(p));
+        norm = std::max(norm, colsum);
+    }
+    return norm;
+}
+
+double Infnorm(const SparseMatrix& A) {
+    Vector rowsum(A.rows());
+    for (Int j = 0; j < A.cols(); j++) {
+        for (Int p = A.begin(j); p < A.end(j); p++)
+            rowsum[A.index(p)] += std::abs(A.value(p));
+    }
+    return Infnorm(rowsum);
+}
+
+double NormestInverse(const SparseMatrix& A, const char* uplo, int unitdiag) {
+    const Int m = A.rows();
+    Vector x(m);
+    assert(A.rows() == A.cols());
+
+    // Solve A'x=b, where the entries of b are +/-1 chosen dynamically to make x
+    // large.
+    if (*uplo == 'u' || *uplo == 'U') {
+        for (Int j = 0; j < m; j++) {
+            Int begin = A.begin(j);
+            Int end = A.end(j);
+            if (!unitdiag)
+                end--;
+            double temp = 0.0;
+            for (Int p = begin; p < end; p++)
+                temp -= x[A.index(p)] * A.value(p);
+            temp += temp >= 0.0 ? 1.0 : -1.0; // choose b[j] = 1 or b[j] = -1
+            if (!unitdiag) {
+                assert(A.index(end) == j);
+                temp /= A.value(end);
+            }
+            x[j] = temp;
+        }
+    } else {
+        for (Int j = m-1; j >= 0; j--) {
+            Int begin = A.begin(j);
+            Int end = A.end(j);
+            if (!unitdiag)
+                begin++;
+            double temp = 0.0;
+            for (Int p = begin; p < end; p++)
+                temp -= x[A.index(p)] * A.value(p);
+            temp += temp >= 0.0 ? 1.0 : -1.0; // choose b[j] = 1 or b[j] = -1
+            if (!unitdiag) {
+                assert(A.index(begin-1) == j);
+                temp /= A.value(begin-1);
+            }
+            x[j] = temp;
+        }
+    }
+    double x1norm = Onenorm(x);
+    double xinfnorm = Infnorm(x);
+
+    // Solve Ay=x, solution overwrites x.
+    TriangularSolve(A, x, 'n', uplo, unitdiag);
+    double y1norm = Onenorm(x);
+
+    return std::max(y1norm/x1norm, xinfnorm);
+}
+
+} // namespace ipx

data/ext/lpsolver-highs/highs/ipm/ipx/sparse_matrix.h

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

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

@@ -0,0 +1,92 @@
+#include "ipm/ipx/sparse_utils.h"
+#include <cassert>
+
+namespace ipx {
+
+Int DepthFirstSearch(Int istart, const Int* Ap, const Int* Ai,
+                     const Int* colmap, Int top, Int* istack, Int* marked,
+                     Int marker, Int* work) {
+    assert(marked[istart] != marker);
+    Int* pstack = work;
+    Int head = 0;
+    istack[head] = istart;
+    while (head >= 0) {
+        const Int i = istack[head];
+        const Int j = colmap ? colmap[i] : i;
+        if (marked[i] != marker) {
+            marked[i] = marker;
+            pstack[head] = j >= 0 ? Ap[j] : 0;
+        }
+        bool done = true;
+        const Int pbeg = pstack[head];
+        const Int pend = j >= 0 ? Ap[j+1] : 0;
+        for (Int p = pbeg; p < pend; p++) {
+            Int inext = Ai[p];
+            if (marked[inext] == marker)
+                continue;
+            pstack[head] = p+1;
+            istack[++head] = inext;
+            done = false;
+            break;
+        }
+        if (done) {
+            head--;
+            istack[--top] = i;
+        }
+    }
+    return top;
+}
+
+bool AugmentingPath(Int jstart, const Int* Ap, const Int* Ai, Int* jmatch,
+                    Int* cheap, Int* marked, Int* work, Int* work2, Int* work3){
+    // istack holds row indices without duplicates.
+    // jstack holds jstart and up to m indices from jmatch.
+    // pstack holds the corresponding column pointers.
+    Int* istack = work;
+    Int* jstack = work2;
+    Int* pstack = work3;
+    bool found = false;
+    Int head = 0;
+    jstack[head] = jstart;
+    while (head >= 0) {
+        const Int j = jstack[head];
+        if (marked[j] != jstart) { // first time j visited in this path
+            marked[j] = jstart;
+            Int i, p;
+            for (p = cheap[j]; p < Ap[j+1] && !found; p++) {
+                i = Ai[p];
+                found = jmatch[i] == -1;
+            }
+            cheap[j] = p;
+            if (found) {
+                istack[head] = i;
+                break;
+            }
+            pstack[head] = Ap[j]; // start depth-first search from j
+        }
+        const Int pbeg = pstack[head];
+        const Int pend = Ap[j+1];
+        Int p;
+        for (p = pbeg; p < pend; p++) {
+            Int i = Ai[p];
+            if (jmatch[i] < -1) // row to be ignored
+                continue;
+            assert(jmatch[i] >= 0);
+            if (marked[jmatch[i]] == jstart)
+                continue;
+            pstack[head] = p+1;
+            istack[head] = i;
+            jstack[++head] = jmatch[i]; // continue augmenting path here
+            break;
+        }
+        if (p == Ap[j+1])
+            head--;
+    }
+    if (found) {
+        for (Int p = head; p >= 0; p--)
+            jmatch[istack[p]] = jstack[p];
+    }
+    return found;
+}
+
+}  // namespace ipx