lpsolver 0.1.0 → 0.2.0

data/ext/lpsolver-highs/highs/mip/HighsDynamicRowMatrix.cpp

@@ -0,0 +1,199 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+#include "mip/HighsDynamicRowMatrix.h"
+
+#include <algorithm>
+#include <cassert>
+#include <cstddef>
+#include <numeric>
+
+HighsDynamicRowMatrix::HighsDynamicRowMatrix(HighsInt ncols) {
+  AheadPos_.resize(ncols, -1);
+  AheadNeg_.resize(ncols, -1);
+}
+/// adds a row to the matrix with the given values and returns its index
+HighsInt HighsDynamicRowMatrix::addRow(HighsInt* Rindex, double* Rvalue,
+                                       HighsInt Rlen, bool linkCols) {
+  HighsInt rowindex;
+  HighsInt start;
+  HighsInt end;
+
+  // insert the row in an existing empty space or append the values to the end
+  // if no space that is large enough exists
+  std::set<std::pair<HighsInt, HighsInt>>::iterator it;
+  if (freespaces_.empty() || (it = freespaces_.lower_bound(std::make_pair(
+                                  Rlen, HighsInt{-1}))) == freespaces_.end()) {
+    start = ARindex_.size();
+    end = start + Rlen;
+
+    ARindex_.resize(end);
+    ARvalue_.resize(end);
+    ARrowindex_.resize(end);
+    AprevPos_.resize(end, -1);
+    AnextPos_.resize(end, -1);
+    AprevNeg_.resize(end, -1);
+    AnextNeg_.resize(end, -1);
+  } else {
+    std::pair<HighsInt, HighsInt> freeslot = *it;
+    freespaces_.erase(it);
+
+    start = freeslot.second;
+    end = start + Rlen;
+    // if the space was not completely occupied, we register the remainder of
+    // it again in the priority queue
+    if (freeslot.first > Rlen) {
+      freespaces_.emplace(freeslot.first - Rlen, end);
+    }
+  }
+
+  // register the range of values for this row with a reused or a new index
+  if (deletedrows_.empty()) {
+    rowindex = ARrange_.size();
+    ARrange_.emplace_back(start, end);
+    colsLinked.push_back(linkCols);
+  } else {
+    rowindex = deletedrows_.back();
+    deletedrows_.pop_back();
+    ARrange_[rowindex].first = start;
+    ARrange_[rowindex].second = end;
+    colsLinked[rowindex] = linkCols;
+  }
+
+  // now add the nonzeros in the order sorted by the index value
+  for (HighsInt i = start; i != end; ++i) {
+    ARindex_[i] = Rindex[i - start];
+    ARvalue_[i] = Rvalue[i - start];
+    ARrowindex_[i] = rowindex;
+  }
+
+  // link the row values to the columns
+  if (!linkCols) return rowindex;
+
+  for (HighsInt i = start; i != end; ++i) {
+    HighsInt col = ARindex_[i];
+
+    if (ARvalue_[i] > 0) {
+      AprevPos_[i] = -1;
+      HighsInt head = AheadPos_[col];
+      AheadPos_[col] = i;
+      AnextPos_[i] = head;
+
+      if (head != -1) AprevPos_[head] = i;
+    } else {
+      AprevNeg_[i] = -1;
+      HighsInt head = AheadNeg_[col];
+      AheadNeg_[col] = i;
+      AnextNeg_[i] = head;
+
+      if (head != -1) AprevNeg_[head] = i;
+    }
+  }
+
+  return rowindex;
+}
+
+void HighsDynamicRowMatrix::unlinkColumns(HighsInt rowindex) {
+  if (!colsLinked[rowindex]) return;
+
+  colsLinked[rowindex] = false;
+  HighsInt start = ARrange_[rowindex].first;
+  HighsInt end = ARrange_[rowindex].second;
+  for (HighsInt i = start; i != end; ++i) {
+    HighsInt col = ARindex_[i];
+
+    if (ARvalue_[i] > 0) {
+      HighsInt prev = AprevPos_[i];
+      HighsInt next = AnextPos_[i];
+
+      if (next != -1) {
+        assert(AprevPos_[next] == i);
+        AprevPos_[next] = prev;
+      }
+
+      if (prev != -1) {
+        assert(AnextPos_[prev] == i);
+        AnextPos_[prev] = next;
+      } else {
+        assert(AheadPos_[col] == i);
+        AheadPos_[col] = next;
+      }
+    } else {
+      HighsInt prev = AprevNeg_[i];
+      HighsInt next = AnextNeg_[i];
+
+      if (next != -1) {
+        assert(AprevNeg_[next] == i);
+        AprevNeg_[next] = prev;
+      }
+
+      if (prev != -1) {
+        assert(AnextNeg_[prev] == i);
+        AnextNeg_[prev] = next;
+      } else {
+        assert(AheadNeg_[col] == i);
+        AheadNeg_[col] = next;
+      }
+    }
+  }
+}
+
+/// removes the row with the given index from the matrix, afterwards the index
+/// can be reused for new rows
+void HighsDynamicRowMatrix::removeRow(HighsInt rowindex) {
+  HighsInt start = ARrange_[rowindex].first;
+  HighsInt end = ARrange_[rowindex].second;
+
+  if (colsLinked[rowindex]) {
+    for (HighsInt i = start; i != end; ++i) {
+      HighsInt col = ARindex_[i];
+
+      if (ARvalue_[i] > 0) {
+        HighsInt prev = AprevPos_[i];
+        HighsInt next = AnextPos_[i];
+
+        if (next != -1) {
+          assert(AprevPos_[next] == i);
+          AprevPos_[next] = prev;
+        }
+
+        if (prev != -1) {
+          assert(AnextPos_[prev] == i);
+          AnextPos_[prev] = next;
+        } else {
+          assert(AheadPos_[col] == i);
+          AheadPos_[col] = next;
+        }
+      } else {
+        HighsInt prev = AprevNeg_[i];
+        HighsInt next = AnextNeg_[i];
+
+        if (next != -1) {
+          assert(AprevNeg_[next] == i);
+          AprevNeg_[next] = prev;
+        }
+
+        if (prev != -1) {
+          assert(AnextNeg_[prev] == i);
+          AnextNeg_[prev] = next;
+        } else {
+          assert(AheadNeg_[col] == i);
+          AheadNeg_[col] = next;
+        }
+      }
+    }
+  }
+
+  // register the space of the deleted row and the index so that it can be
+  // reused
+  deletedrows_.push_back(rowindex);
+  freespaces_.emplace(end - start, start);
+
+  // set the range to -1,-1 to indicate a deleted row
+  ARrange_[rowindex].first = -1;
+  ARrange_[rowindex].second = -1;
+}

data/ext/lpsolver-highs/highs/mip/HighsDynamicRowMatrix.h

@@ -0,0 +1,104 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+#ifndef HIGHS_DYNAMIC_ROW_MATRIX_H_
+#define HIGHS_DYNAMIC_ROW_MATRIX_H_
+
+#include <set>
+#include <utility>
+#include <vector>
+
+#include "util/HighsInt.h"
+
+class HighsDynamicRowMatrix {
+ private:
+  /// vector of index ranges in the index and value arrays of AR for each row
+  std::vector<std::pair<HighsInt, HighsInt>> ARrange_;
+
+  /// column indices for each nonzero in AR
+  std::vector<HighsInt> ARindex_;
+  /// values for each nonzero in AR
+  std::vector<double> ARvalue_;
+
+  std::vector<HighsInt> ARrowindex_;
+  std::vector<HighsInt> AnextPos_;
+  std::vector<HighsInt> AprevPos_;
+  std::vector<HighsInt> AnextNeg_;
+  std::vector<HighsInt> AprevNeg_;
+
+  /// vector of pointers to the head/tail of the nonzero block list for each
+  /// column
+  std::vector<HighsInt> AheadPos_;
+  std::vector<HighsInt> AheadNeg_;
+
+  std::vector<uint8_t> colsLinked;
+
+  /// vector of column sizes
+
+  /// keep an ordered set of free spaces in the row arrays so that they can be
+  /// reused efficiently
+  std::set<std::pair<HighsInt, HighsInt>> freespaces_;
+
+  /// vector of deleted rows so that their indices can be reused
+  std::vector<HighsInt> deletedrows_;
+
+ public:
+  HighsDynamicRowMatrix(HighsInt ncols);
+
+  bool columnsLinked(HighsInt rowindex) const {
+    return (colsLinked[rowindex] != 0);
+  }
+
+  void unlinkColumns(HighsInt rowindex);
+
+  /// adds a row to the matrix with the given values and returns its index
+  HighsInt addRow(HighsInt* Rindex, double* Rvalue, HighsInt Rlen,
+                  bool linkCols = true);
+
+  /// removes the row with the given index from the matrix, afterwards the index
+  /// can be reused for new rows
+  void removeRow(HighsInt rowindex);
+
+  std::size_t nonzeroCapacity() const { return ARvalue_.size(); }
+
+  /// calls the given function object for each entry in the given column.
+  /// The function object should accept the row index as first argument and
+  /// the nonzero value of the column in that row as the second argument.
+  template <typename Func>
+  void forEachPositiveColumnEntry(HighsInt col, Func&& f) const {
+    HighsInt iter = AheadPos_[col];
+
+    while (iter != -1) {
+      if (!f(ARrowindex_[iter], ARvalue_[iter])) break;
+      iter = AnextPos_[iter];
+    }
+  }
+
+  template <typename Func>
+  void forEachNegativeColumnEntry(HighsInt col, Func&& f) const {
+    HighsInt iter = AheadNeg_[col];
+
+    while (iter != -1) {
+      if (!f(ARrowindex_[iter], ARvalue_[iter])) break;
+      iter = AnextNeg_[iter];
+    }
+  }
+
+  HighsInt getNumRows() const { return ARrange_.size(); }
+
+  HighsInt getNumDelRows() const { return deletedrows_.size(); }
+
+  HighsInt getRowStart(HighsInt row) const { return ARrange_[row].first; }
+
+  HighsInt getRowEnd(HighsInt row) const { return ARrange_[row].second; }
+
+  const HighsInt* getARindex() const { return ARindex_.data(); }
+
+  const double* getARvalue() const { return ARvalue_.data(); }
+};
+
+#endif

data/ext/lpsolver-highs/highs/mip/HighsFeasibilityJump.cpp

@@ -0,0 +1,139 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+#include "mip/HighsMipSolverData.h"
+#include "mip/feasibilityjump.hh"
+#include "util/HighsSparseMatrix.h"
+
+HighsModelStatus HighsMipSolverData::feasibilityJump() {
+  // This is the (presolved) model being solved
+  const HighsLp* model = this->mipsolver.model_;
+  const HighsLogOptions& log_options = mipsolver.options_mip_->log_options;
+  double sense_multiplier = static_cast<double>(model->sense_);
+
+#ifdef HIGHSINT64
+  // TODO(BenChampion,9999-12-31): make FJ work with 64-bit HighsInt
+  highsLogUser(log_options, HighsLogType::kInfo,
+               "Feasibility Jump code isn't currently compatible "
+               "with a 64-bit HighsInt: skipping Feasibility Jump\n");
+  return HighsModelStatus::kNotset;
+#else
+
+  bool found_integer_feasible_solution = false;
+  std::vector<double> col_value(model->num_col_, 0.0);
+  double objective_function_value;
+
+  const bool use_incumbent = !incumbent.empty();
+
+  // Configure Feasibility Jump and pass it the problem
+  auto solver = external_feasibilityjump::FeasibilityJumpSolver(
+      log_options,
+      /* seed = */ mipsolver.options_mip_->random_seed,
+      /* equalityTolerance = */ epsilon,
+      /* violationTolerance = */ feastol);
+
+  for (HighsInt col = 0; col < model->num_col_; ++col) {
+    double lower = model->col_lower_[col];
+    double upper = model->col_upper_[col];
+
+    assert(model->integrality_[col] == HighsVarType::kContinuous ||
+           model->integrality_[col] == HighsVarType::kInteger ||
+           model->integrality_[col] == HighsVarType::kImplicitInteger);
+    external_feasibilityjump::VarType fjVarType;
+    if (model->integrality_[col] == HighsVarType::kContinuous) {
+      fjVarType = external_feasibilityjump::VarType::Continuous;
+    } else {
+      fjVarType = external_feasibilityjump::VarType::Integer;
+      lower = std::ceil(lower - feastol);
+      upper = std::floor(upper + feastol);
+    }
+
+    const bool legal_bounds = lower <= upper && lower < kHighsInf &&
+                              upper > -kHighsInf && !std::isnan(lower) &&
+                              !std::isnan(upper);
+    if (!legal_bounds) {
+      highsLogUser(log_options, HighsLogType::kInfo,
+                   "HighsMipSolverData::feasibilityJump() has detected "
+                   "infeasible/illegal bounds [%g, %g] for "
+                   "column %d: MIP is infeasible\n",
+                   lower, upper, int(col));
+      assert(legal_bounds);
+      return HighsModelStatus::kInfeasible;
+    }
+    solver.addVar(fjVarType, lower, upper,
+                  sense_multiplier * model->col_cost_[col]);
+
+    double initial_assignment = 0.0;
+    if (use_incumbent && std::isfinite(incumbent[col])) {
+      initial_assignment = std::max(lower, std::min(upper, incumbent[col]));
+    } else {
+      if (std::isfinite(lower)) {
+        initial_assignment = lower;
+      } else if (std::isfinite(upper)) {
+        initial_assignment = upper;
+      }
+    }
+    col_value[col] = initial_assignment;
+  }
+
+  HighsSparseMatrix a_matrix;
+  a_matrix.createRowwise(model->a_matrix_);
+
+  for (HighsInt row = 0; row < model->num_row_; ++row) {
+    bool hasFiniteLower = std::isfinite(model->row_lower_[row]);
+    bool hasFiniteUpper = std::isfinite(model->row_upper_[row]);
+    if (hasFiniteLower || hasFiniteUpper) {
+      HighsInt row_num_nz = a_matrix.start_[row + 1] - a_matrix.start_[row];
+      auto row_index = a_matrix.index_.data() + a_matrix.start_[row];
+      auto row_value = a_matrix.value_.data() + a_matrix.start_[row];
+      if (hasFiniteLower) {
+        solver.addConstraint(external_feasibilityjump::RowType::Gte,
+                             model->row_lower_[row], row_num_nz, row_index,
+                             row_value, /* relax_continuous = */ 0);
+      }
+      if (hasFiniteUpper) {
+        solver.addConstraint(external_feasibilityjump::RowType::Lte,
+                             model->row_upper_[row], row_num_nz, row_index,
+                             row_value, /* relax_continuous = */ 0);
+      }
+    }
+  }
+
+  const HighsInt nnz = a_matrix.numNz();
+  const size_t kMaxTotalEffort = (size_t)nnz << 10;
+  const size_t kMaxEffortSinceLastImprovement = (size_t)nnz << 8;
+
+  auto fjControlCallback =
+      [=, &col_value, &found_integer_feasible_solution,
+       &objective_function_value](external_feasibilityjump::FJStatus status)
+      -> external_feasibilityjump::CallbackControlFlow {
+    if (status.solution != nullptr) {
+      found_integer_feasible_solution = true;
+      col_value = std::vector<double>(status.solution,
+                                      status.solution + status.numVars);
+      objective_function_value =
+          model->offset_ + sense_multiplier * status.solutionObjectiveValue;
+    }
+    if (status.effortSinceLastImprovement > kMaxEffortSinceLastImprovement ||
+        status.totalEffort > kMaxTotalEffort) {
+      return external_feasibilityjump::CallbackControlFlow::Terminate;
+    } else {
+      return external_feasibilityjump::CallbackControlFlow::Continue;
+    }
+  };
+
+  solver.solve(col_value.data(), fjControlCallback);
+
+  if (found_integer_feasible_solution) {
+    // Initial assignments that violate integrality or column bounds can lead to
+    // infeasible results. Even if those initial assignments should not occur,
+    // use trySolution rather than addIncumbent for an explicit check.
+    trySolution(col_value, kSolutionSourceFeasibilityJump);
+  }
+  return HighsModelStatus::kNotset;
+#endif
+}

data/ext/lpsolver-highs/highs/mip/HighsGFkSolve.cpp

@@ -0,0 +1,106 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+#include "mip/HighsGFkSolve.h"
+
+#include <cassert>
+
+#include "util/HighsSplay.h"
+
+void HighsGFkSolve::link(HighsInt pos) {
+  Anext[pos] = colhead[Acol[pos]];
+  Aprev[pos] = -1;
+  colhead[Acol[pos]] = pos;
+  if (Anext[pos] != -1) Aprev[Anext[pos]] = pos;
+
+  ++colsize[Acol[pos]];
+
+  auto get_row_left = [&](HighsInt pos) -> HighsInt& { return ARleft[pos]; };
+  auto get_row_right = [&](HighsInt pos) -> HighsInt& { return ARright[pos]; };
+  auto get_row_key = [&](HighsInt pos) { return Acol[pos]; };
+  highs_splay_link(pos, rowroot[Arow[pos]], get_row_left, get_row_right,
+                   get_row_key);
+  ++rowsize[Arow[pos]];
+}
+
+void HighsGFkSolve::unlink(HighsInt pos) {
+  HighsInt next = Anext[pos];
+  HighsInt prev = Aprev[pos];
+
+  if (next != -1) Aprev[next] = prev;
+
+  if (prev != -1)
+    Anext[prev] = next;
+  else
+    colhead[Acol[pos]] = next;
+  --colsize[Acol[pos]];
+
+  auto get_row_left = [&](HighsInt pos) -> HighsInt& { return ARleft[pos]; };
+  auto get_row_right = [&](HighsInt pos) -> HighsInt& { return ARright[pos]; };
+  auto get_row_key = [&](HighsInt pos) { return Acol[pos]; };
+  highs_splay_unlink(pos, rowroot[Arow[pos]], get_row_left, get_row_right,
+                     get_row_key);
+  --rowsize[Arow[pos]];
+
+  Avalue[pos] = 0;
+  freeslots.push(pos);
+}
+
+void HighsGFkSolve::storeRowPositions(HighsInt pos) {
+  if (pos == -1) return;
+
+  assert(iterstack.empty());
+  iterstack.push_back(pos);
+  do {
+    pos = iterstack.back();
+    iterstack.pop_back();
+
+    rowpositions.push_back(pos);
+    rowposColsizes.push_back(colsize[Acol[pos]]);
+
+    if (ARleft[pos] != -1) iterstack.push_back(ARleft[pos]);
+    if (ARright[pos] != -1) iterstack.push_back(ARright[pos]);
+  } while (!iterstack.empty());
+}
+
+HighsInt HighsGFkSolve::findNonzero(HighsInt row, HighsInt col) {
+  if (rowroot[row] == -1) return -1;
+
+  auto get_row_left = [&](HighsInt pos) -> HighsInt& { return ARleft[pos]; };
+  auto get_row_right = [&](HighsInt pos) -> HighsInt& { return ARright[pos]; };
+  auto get_row_key = [&](HighsInt pos) { return Acol[pos]; };
+  rowroot[row] =
+      highs_splay(col, rowroot[row], get_row_left, get_row_right, get_row_key);
+
+  if (Acol[rowroot[row]] == col) return rowroot[row];
+
+  return -1;
+}
+
+void HighsGFkSolve::addNonzero(HighsInt row, HighsInt col, unsigned int val) {
+  assert(findNonzero(row, col) == -1);
+  HighsInt pos;
+  if (freeslots.empty()) {
+    pos = Avalue.size();
+    Avalue.push_back(val);
+    Arow.push_back(row);
+    Acol.push_back(col);
+    Anext.push_back(-1);
+    Aprev.push_back(-1);
+    ARleft.push_back(-1);
+    ARright.push_back(-1);
+  } else {
+    pos = freeslots.top();
+    freeslots.pop();
+    Avalue[pos] = val;
+    Arow[pos] = row;
+    Acol[pos] = col;
+    Aprev[pos] = -1;
+  }
+
+  link(pos);
+}