lpsolver 0.1.0 → 0.2.1

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

@@ -0,0 +1,233 @@
+#include "ipm/ipx/guess_basis.h"
+#include <algorithm>
+#include <cassert>
+#include <cmath>
+#include "ipm/ipx/sparse_utils.h"
+#include "ipm/ipx/utils.h"
+
+namespace ipx {
+
+// Computes the pattern of L\AI[:,j] in topological order in pattern[top..m-1].
+static Int ComputePattern(const SparseMatrix& L, const SparseMatrix& AI,
+                          Int j, const Int* rownumber, Int* pattern,
+                          Int* pstack, Int* marked, Int marker) {
+    const Int m = L.rows();
+    const Int* Lp = L.colptr();
+    const Int* Li = L.rowidx();
+    Int top = m;
+    for (Int p = AI.begin(j); p < AI.end(j); p++) {
+        Int i = AI.index(p);
+        if (marked[i] != marker)
+            top = DepthFirstSearch(i, Lp, Li, rownumber, top, pattern, marked,
+                                   marker, pstack);
+    }
+    return top;
+}
+
+// Computes the values of L\AI[:,j] scattered into lhs. Positions that are not
+// in the pattern are not accessed. Returns the position of the maximum entry
+// in lhs that has not been pivotal yet (-1 if no such nonzero).
+static Int ComputeValues(const SparseMatrix& L, const SparseMatrix& AI,
+                         Int j, const Int* rownumber, const Int* pattern,
+                         Int top, Vector& lhs){
+    const Int m = L.rows();
+    const Int* Lp = L.colptr();
+    const Int* Li = L.rowidx();
+    const double* Lx = L.values();
+    for (Int t = top; t < m; t++)
+        lhs[pattern[t]] = 0.0;
+    for (Int p = AI.begin(j); p < AI.end(j); p++) // scatter RHS into lhs
+        lhs[AI.index(p)] = AI.value(p);
+    double lhsmax = 0.0;        // maximum entry that has not been pivotal
+    Int imax = -1;              // corresponding position in lhs
+    for (Int t = top; t < m; t++) {
+        Int i = pattern[t];
+        double temp = lhs[i];
+        Int k = rownumber[i];
+        if (temp != 0.0) {
+            if (k >= 0) {
+                // Row i has been pivotal; update lhs.
+                for (Int p = Lp[k]; p < Lp[k+1]; p++)
+                    lhs[Li[p]] -= Lx[p] * temp;
+            } else if (std::abs(temp) > lhsmax) {
+                // Row i has not been pivotal; update lhsmax.
+                lhsmax = std::abs(temp);
+                imax = i;
+            }
+        }
+    }
+    return imax;
+}
+
+// Performs incomplete left-looking LU factorization of columns with infinite
+// weight. If a candidate column has a sufficiently large entry after being
+// updated by the columns in L, it is added to the basis. The row with maximum
+// entry is chosen as pivot row.
+static void ProcessFreeColumns(const Control& control, const Model& model,
+                               const double* weights, std::vector<Int>* basis,
+                               Int* rownumber, int* active) {
+    const Int m = model.rows();
+    const Int n = model.cols();
+    const SparseMatrix& AI = model.AI();
+
+    // Workspace and output of left-looking incomplete LU factorization.
+    // L is stored without the unit diagonal, row indices are (unpermuted) row
+    // indices from AI. The upper triangular factor is not stored.
+    std::vector<Int> pattern(m), work(m), marked(m, -1);
+    Vector lhs(m);
+    SparseMatrix L(m,0);
+
+    Int num_free = 0;
+    for (Int j = 0; j < n+m; j++) {
+        if (weights[j] != INFINITY)
+            continue;
+        Int top = ComputePattern(L, AI, j, rownumber, pattern.data(),
+                                 work.data(), marked.data(), j);
+        Int imax = ComputeValues(L, AI, j, rownumber, pattern.data(), top, lhs);
+        double pivot = imax >= 0 ? lhs[imax] : 0.0;
+        if (std::abs(pivot) > kLuDependencyTol) {
+            assert(rownumber[imax] == -1);
+            rownumber[imax] = basis->size();
+            basis->push_back(j);
+            // Add new column to L. Discard off-diagonal entries that were not
+            // in the pattern of AI[:,j].
+            for (Int t = AI.begin(j); t < AI.end(j); t++) {
+                Int i = AI.index(t);
+                if (rownumber[i] < 0 && lhs[i] != 0.0)
+                    L.push_back(i, lhs[i]/pivot);
+            }
+            L.add_column();
+            num_free++;
+        }
+        active[j] = false;
+    }
+    control.Debug()
+        << Textline("Number of free variables in starting basis:")
+        << num_free << '\n';
+}
+
+// Adds singleton columns to the basis if their entry is maximum up to a factor
+// 2.0 in its row.
+static void ProcessSingletons(const Control& control, const Model& model,
+                              const double* weights, std::vector<Int>* basis,
+                              Int* rownumber, int* active) {
+    const Int m = model.rows();
+    const SparseMatrix& AI = model.AI();
+    const SparseMatrix& AT = model.AIt();
+    Int num_singletons = 0;
+    for (Int i = 0; i < m; i++) {
+        if (rownumber[i] >= 0)
+            continue;
+        double rowmax = 0.0;
+        double max_singleton = 0.0;
+        Int jsingleton = -1;
+        for (Int p = AT.begin(i); p < AT.end(i); p++) {
+            Int j = AT.index(p);
+            if (!active[j])
+                continue;
+            double a = std::abs(AT.value(p)) * weights[j];
+            rowmax = std::max(rowmax, a);
+            if (a > max_singleton && AI.end(j) == AI.begin(j)+1) {
+                max_singleton = a;
+                jsingleton = j;
+            }
+        }
+        if (max_singleton > 0.0 && max_singleton >= 0.5*rowmax) {
+            rownumber[i] = basis->size();
+            basis->push_back(jsingleton);
+            active[jsingleton] = false;
+            num_singletons++;
+        }
+    }
+    control.Debug()
+        << Textline("Number of singletons in starting basis:")
+        << num_singletons << '\n';
+}
+
+// Computes a matching of active columns with rows that have not been pivotal.
+// Each matched column is added to the basis. Columns are processed in
+// decreasing order of their weight.
+static void ProcessRemaining(const Control& control, const Model& model,
+                             const double* weights, std::vector<Int>* basis,
+                             Int* rownumber, int* active) {
+    const Int m = model.rows();
+    const Int n = model.cols();
+    const SparseMatrix& AI = model.AI();
+    const std::vector<Int> colperm = Sortperm(n+m, weights, true);
+
+    // jmatch[i] == -1  if row i is unmatched but eligible for matching
+    // jmatch[i] == -2  if row i is excluded from being matched
+    // jmatch[i] == j >= 0 if row i is matched to column j
+    std::vector<Int> jmatch(m, -1);
+    for (Int i = 0; i < m; i++) {
+        if (rownumber[i] >= 0)
+            jmatch[i] = -2;
+    }
+    std::vector<Int> marked(n+m, -1);
+    const Int* Ap = AI.colptr();
+    const Int* Ai = AI.rowidx();
+    std::vector<Int> cheap(Ap, Ap+n+m);
+    std::vector<Int> work(m), work2(m+1), work3(m+1);
+    Int num_matched = 0;
+    Int num_failed = 0;
+
+    for (Int j : colperm) {
+        if (!active[j])
+            continue;
+        if (weights[j] == 0.0)
+            break;
+        bool matched = AugmentingPath(j, Ap, Ai, jmatch.data(), cheap.data(),
+                                      marked.data(), work.data(), work2.data(),
+                                      work3.data());
+        if (matched) {
+            basis->push_back(j);
+            num_matched++;
+        } else {
+            num_failed++;
+        }
+        if (num_failed >= 10*(m-(Int)basis->size()))
+            break;
+    }
+    for (Int i = 0; i < m; i++) {
+        if (jmatch[i] >= 0) {
+            // rownumber[i] = m indicates that row i was matched
+            assert(rownumber[i] < 0);
+            rownumber[i] = m;
+        }
+    }
+    control.Debug()
+        << Textline("Number of other columns matched:")
+        << num_matched << '\n'
+        << Textline("Number of other columns failed:")
+        << num_failed << '\n';
+}
+
+std::vector<Int> GuessBasis(const Control& control, const Model& model,
+                            const double* colweights) {
+    const Int m = model.rows();
+    const Int n = model.cols();
+
+    // basis starts empty and is filled one index at a time. rownumber[i] >= 0
+    // iff row i was pivot row when a column was added to the basis. (The
+    // specific value has a different meaning in each method.) A column is
+    // "active" if it is eligible for being added to the basis.
+    std::vector<Int> basis, rownumber(m, -1);
+    std::vector<int> active(n+m, 1);
+
+    ProcessFreeColumns(control, model, colweights, &basis, rownumber.data(),
+                       active.data());
+    ProcessSingletons(control, model, colweights, &basis, rownumber.data(),
+                      active.data());
+    ProcessRemaining(control, model, colweights, &basis, rownumber.data(),
+                     active.data());
+
+    // Complete basis with unit columns.
+    for (Int i = 0; i < m; i++) {
+        if (rownumber[i] < 0)
+            basis.push_back(n+i);
+    }
+    assert((Int)basis.size() == m);
+    return basis;
+}
+
+}  // namespace ipx

data/ext/lpsolver-highs/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/highs/ipm/ipx/indexed_vector.cc

@@ -0,0 +1,30 @@
+#include "ipm/ipx/indexed_vector.h"
+
+namespace ipx {
+
+IndexedVector::IndexedVector(Int dim) : elements_(dim), pattern_(dim) { }
+
+bool IndexedVector::sparse() const {
+    return nnz() >= 0 && nnz() <= kHypersparseThreshold * dim();
+}
+
+void IndexedVector::set_to_zero() {
+    if (sparse()) {
+        for (Int p = 0; p < nnz_; p++)
+            elements_[pattern_[p]] = 0.0;
+    } else {
+        elements_ = 0.0;
+    }
+    nnz_ = 0;
+}
+
+double Dot(const IndexedVector& x, const Vector& y) {
+    double d = 0.0;
+    auto add = [&](Int p, double f) {
+        d += y[p] * f;
+    };
+    for_each_nonzero(x, add);
+    return d;
+}
+
+}  // namespace ipx

data/ext/lpsolver-highs/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/highs/ipm/ipx/info.cc

@@ -0,0 +1,124 @@
+#include "ipm/ipx/info.h"
+#include <cstring>              // for memset
+#include <map>
+#include <string>
+#include "ipm/ipx/control.h"
+namespace ipx {
+
+template <typename T>
+static void dump(std::ostream& os, const char* name, T value) {
+    os << Textline(std::string("info.")+name) << value << '\n';
+}
+
+std::ostream& operator<<(std::ostream& os, const Info& info) {
+    dump(os, "status", info.status);
+    dump(os, "status_ipm", info.status_ipm);
+    dump(os, "status_crossover", info.status_crossover);
+    dump(os, "errflag", info.errflag);
+
+    dump(os, "num_var", info.num_var);
+    dump(os, "num_constr", info.num_constr);
+    dump(os, "num_entries", info.num_entries);
+
+    dump(os, "num_rows_solver", info.num_rows_solver);
+    dump(os, "num_cols_solver", info.num_cols_solver);
+    dump(os, "num_entries_solver", info.num_entries_solver);
+
+    dump(os, "dualized", info.dualized);
+    dump(os, "dense_cols", info.dense_cols);
+
+    dump(os, "dependent_rows", info.dependent_rows);
+    dump(os, "dependent_cols", info.dependent_cols);
+    dump(os, "rows_inconsistent", info.rows_inconsistent);
+    dump(os, "cols_inconsistent", info.cols_inconsistent);
+    dump(os, "primal_dropped", info.primal_dropped);
+    dump(os, "dual_dropped", info.dual_dropped);
+
+    dump(os, "abs_presidual", sci2(info.abs_presidual));
+    dump(os, "abs_dresidual", sci2(info.abs_dresidual));
+    dump(os, "rel_presidual", sci2(info.rel_presidual));
+    dump(os, "rel_dresidual", sci2(info.rel_dresidual));
+    dump(os, "pobjval", sci8(info.pobjval));
+    dump(os, "dobjval", sci8(info.dobjval));
+    dump(os, "rel_objgap", sci2(info.rel_objgap));
+    dump(os, "complementarity", sci2(info.complementarity));
+    dump(os, "normx", sci2(info.normx));
+    dump(os, "normy", sci2(info.normy));
+    dump(os, "normz", sci2(info.normz));
+
+    dump(os, "objval", sci8(info.objval));
+    dump(os, "primal_infeas", sci2(info.primal_infeas));
+    dump(os, "dual_infeas", sci2(info.dual_infeas));
+
+    dump(os, "iter", info.iter);
+    dump(os, "kktiter1", info.kktiter1);
+    dump(os, "kktiter2", info.kktiter2);
+    dump(os, "basis_repairs", info.basis_repairs);
+    dump(os, "updates_start", info.updates_start);
+    dump(os, "updates_ipm", info.updates_ipm);
+    dump(os, "updates_crossover", info.updates_crossover);
+
+    dump(os, "time_total", fix2(info.time_total));
+    dump(os, "time_ipm1", fix2(info.time_ipm1));
+    dump(os, "time_ipm2", fix2(info.time_ipm2));
+    dump(os, "time_starting_basis", fix2(info.time_starting_basis));
+    dump(os, "time_crossover", fix2(info.time_crossover));
+
+    dump(os, "time_kkt_factorize", fix2(info.time_kkt_factorize));
+    dump(os, "time_kkt_solve", fix2(info.time_kkt_solve));
+    dump(os, "time_maxvol", fix2(info.time_maxvol));
+    dump(os, "time_cr1", fix2(info.time_cr1));
+    dump(os, "time_cr1_AAt", fix2(info.time_cr1_AAt));
+    dump(os, "time_cr1_pre", fix2(info.time_cr1_pre));
+    dump(os, "time_cr2", fix2(info.time_cr2));
+    dump(os, "time_cr2_NNt", fix2(info.time_cr2_NNt));
+    dump(os, "time_cr2_B", fix2(info.time_cr2_B));
+    dump(os, "time_cr2_Bt", fix2(info.time_cr2_Bt));
+
+    dump(os, "ftran_sparse", fix2(info.ftran_sparse));
+    dump(os, "btran_sparse", fix2(info.btran_sparse));
+    dump(os, "time_ftran", fix2(info.time_ftran));
+    dump(os, "time_btran", fix2(info.time_btran));
+    dump(os, "time_lu_invert", fix2(info.time_lu_invert));
+    dump(os, "time_lu_update", fix2(info.time_lu_update));
+    dump(os, "mean_fill", fix2(info.mean_fill));
+    dump(os, "max_fill", fix2(info.max_fill));
+    dump(os, "time_symb_invert", fix2(info.time_symb_invert));
+
+    dump(os, "maxvol_updates", info.maxvol_updates);
+    dump(os, "maxvol_skipped", info.maxvol_skipped);
+    dump(os, "maxvol_passes", info.maxvol_passes);
+    dump(os, "tbl_nnz", info.tbl_nnz);
+    dump(os, "tbl_max", sci2(info.tbl_max));
+    dump(os, "frobnorm_squared", sci2(info.frobnorm_squared));
+    dump(os, "lambdamax", sci2(info.lambdamax));
+    dump(os, "volume_increase", sci2(info.volume_increase));
+
+    return os;
+}
+
+std::string StatusString(Int status) {
+    const std::map<int,std::string> status_name = {
+        {IPX_STATUS_not_run, "not run"},
+        {IPX_STATUS_solved, "solved"},
+        {IPX_STATUS_stopped, "stopped"},
+        {IPX_STATUS_no_model, "no model"},
+        {IPX_STATUS_out_of_memory, "out of memory"},
+        {IPX_STATUS_internal_error, "internal error"},
+        {IPX_STATUS_optimal, "optimal"},
+        {IPX_STATUS_imprecise, "imprecise"},
+        {IPX_STATUS_primal_infeas, "primal infeas"},
+        {IPX_STATUS_dual_infeas, "dual infeas"},
+        {IPX_STATUS_time_limit, "time limit"},
+        {IPX_STATUS_iter_limit, "iter limit"},
+        {IPX_STATUS_no_progress, "no progress"},
+        {IPX_STATUS_failed, "failed"},
+        {IPX_STATUS_debug, "debug"}
+    };
+    auto entry = status_name.find(status);
+    if (entry != status_name.end())
+        return entry->second;
+    return "unknown";
+}
+
+}  // namespace ipx

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