lpsolver 0.1.0 → 0.2.0

data/ext/lpsolver-highs/highs/ipm/hipo/ipm/Model.cpp

@@ -0,0 +1,403 @@
+#include "Model.h"
+
+#include "Parameters.h"
+#include "Status.h"
+#include "ipm/IpxWrapper.h"
+#include "ipm/hipo/auxiliary/Log.h"
+#include "model/HighsHessianUtils.h"
+
+namespace hipo {
+
+Int Model::init(const HighsLp& lp, const HighsHessian& Q) {
+  fillInIpxData(lp, n_, m_, offset_, c_, lower_, upper_, A_.start_, A_.index_,
+                A_.value_, b_, constraints_);
+  rhs_orig_ = b_;
+  constraints_orig_ = constraints_;
+  Q_ = Q;
+  if (qp()) completeHessian(n_, Q_);
+  sense_ = lp.sense_;
+
+  if (checkData()) return kStatusBadModel;
+
+  lp_orig_ = &lp;
+  n_orig_ = n_;
+  m_orig_ = m_;
+  A_.num_col_ = n_;
+  A_.num_row_ = m_;
+
+  preprocess();
+
+  denseColumns();
+  computeNorms();
+
+  // double transpose to sort indices of each column
+  A_.ensureRowwise();
+  A_.ensureColwise();
+
+  if (checkData()) return kStatusBadModel;
+
+  ready_ = true;
+
+  return 0;
+}
+
+Int Model::checkData() const {
+  // Check if model provided by the user is ok.
+  // Return kStatusBadModel if something is wrong.
+
+  // Dimensions are valid
+  if (n_ <= 0 || m_ < 0) return kStatusBadModel;
+
+  // Vectors are of correct size
+  if (static_cast<Int>(c_.size()) != n_ || static_cast<Int>(b_.size()) != m_ ||
+      static_cast<Int>(lower_.size()) != n_ ||
+      static_cast<Int>(upper_.size()) != n_ ||
+      static_cast<Int>(constraints_.size()) != m_ ||
+      static_cast<Int>(A_.start_.size()) != n_ + 1 ||
+      static_cast<Int>(A_.index_.size()) != A_.start_.back() ||
+      static_cast<Int>(A_.value_.size()) != A_.start_.back())
+    return kStatusBadModel;
+
+  // Hessian is ok, for QPs only
+  if (qp() && (Q_.dim_ != n_ || Q_.format_ != HessianFormat::kTriangular))
+    return kStatusBadModel;
+
+  // Vectors are valid
+  for (Int i = 0; i < n_; ++i)
+    if (!std::isfinite(c_[i])) return kStatusBadModel;
+  for (Int i = 0; i < m_; ++i)
+    if (!std::isfinite(b_[i])) return kStatusBadModel;
+  for (Int i = 0; i < n_; ++i) {
+    if (!std::isfinite(lower_[i]) && lower_[i] != -INFINITY)
+      return kStatusBadModel;
+    if (!std::isfinite(upper_[i]) && upper_[i] != INFINITY)
+      return kStatusBadModel;
+    if (lower_[i] > upper_[i]) return kStatusBadModel;
+  }
+  for (Int i = 0; i < m_; ++i)
+    if (constraints_[i] != '<' && constraints_[i] != '=' &&
+        constraints_[i] != '>')
+      return kStatusBadModel;
+
+  // Matrix is valid
+  for (Int i = 0; i < A_.start_[n_]; ++i)
+    if (!std::isfinite(A_.value_[i])) return kStatusBadModel;
+
+  return 0;
+}
+
+void Model::preprocess() { preprocessor_.apply(*this); }
+
+void Model::postprocess(std::vector<double>& x, std::vector<double>& xl,
+                        std::vector<double>& xu, std::vector<double>& slack,
+                        std::vector<double>& y, std::vector<double>& zl,
+                        std::vector<double>& zu, const Iterate& it) const {
+  PreprocessorPoint point{x, xl, xu, slack, y, zl, zu};
+  preprocessor_.undo(point, *this, it);
+}
+
+void Model::computeNorms() {
+  norm_scaled_obj_ = infNorm(c_);
+
+  norm_unscaled_obj_ = 0.0;
+  for (Int i = 0; i < n_; ++i) {
+    double val = std::abs(c_[i]);
+    if (scaled()) val /= colScale(i);
+    norm_unscaled_obj_ = std::max(norm_unscaled_obj_, val);
+  }
+
+  norm_scaled_rhs_ = infNorm(b_);
+  for (double d : lower_)
+    if (std::isfinite(d))
+      norm_scaled_rhs_ = std::max(norm_scaled_rhs_, std::abs(d));
+  for (double d : upper_)
+    if (std::isfinite(d))
+      norm_scaled_rhs_ = std::max(norm_scaled_rhs_, std::abs(d));
+
+  norm_unscaled_rhs_ = 0.0;
+  for (Int i = 0; i < m_; ++i) {
+    double val = std::abs(b_[i]);
+    if (scaled()) val /= rowScale(i);
+    norm_unscaled_rhs_ = std::max(norm_unscaled_rhs_, val);
+  }
+  for (Int i = 0; i < n_; ++i) {
+    if (std::isfinite(lower_[i])) {
+      double val = std::abs(lower_[i]);
+      if (scaled()) val *= colScale(i);
+      norm_unscaled_rhs_ = std::max(norm_unscaled_rhs_, val);
+    }
+    if (std::isfinite(upper_[i])) {
+      double val = std::abs(upper_[i]);
+      if (scaled()) val *= colScale(i);
+      norm_unscaled_rhs_ = std::max(norm_unscaled_rhs_, val);
+    }
+  }
+
+  // norms of rows and cols of A
+  one_norm_cols_.resize(n_);
+  one_norm_rows_.resize(m_);
+  inf_norm_cols_.resize(n_);
+  inf_norm_rows_.resize(m_);
+  for (Int col = 0; col < n_; ++col) {
+    for (Int el = A_.start_[col]; el < A_.start_[col + 1]; ++el) {
+      Int row = A_.index_[el];
+      double val = A_.value_[el];
+      one_norm_cols_[col] += std::abs(val);
+      one_norm_rows_[row] += std::abs(val);
+      inf_norm_rows_[row] = std::max(inf_norm_rows_[row], std::abs(val));
+      inf_norm_cols_[col] = std::max(inf_norm_cols_[col], std::abs(val));
+    }
+  }
+}
+
+void Model::print(const LogHighs& log) const {
+  std::stringstream log_stream;
+
+  log_stream << textline("Rows:") << sci(m_, 0, 1) << '\n';
+  log_stream << textline("Cols:") << sci(n_, 0, 1) << '\n';
+  log_stream << textline("Nnz A:") << sci(A_.numNz(), 0, 1) << '\n';
+  if (num_dense_cols_ > 0)
+    log_stream << textline("Dense cols:") << integer(num_dense_cols_, 0)
+               << '\n';
+  if (qp()) {
+    log_stream << textline("Nnz Q:") << sci(Q_.numNz(), 0, 1);
+    if (nonSeparableQp())
+      log_stream << ", non-separable\n";
+    else
+      log_stream << ", separable\n";
+  }
+
+  // compute max and min entry of A in absolute value
+  double Amin = kHighsInf;
+  double Amax = 0.0;
+  std::vector<double> norm_inf_cols(n_);
+  std::vector<double> norm_inf_rows(m_);
+  std::vector<double> norm_one_cols(n_);
+  std::vector<double> norm_one_rows(m_);
+  for (Int col = 0; col < n_; ++col) {
+    for (Int el = A_.start_[col]; el < A_.start_[col + 1]; ++el) {
+      const Int row = A_.index_[el];
+      const double value = A_.value_[el];
+      if (value != 0.0) {
+        Amin = std::min(Amin, std::abs(value));
+        Amax = std::max(Amax, std::abs(value));
+        norm_inf_cols[col] = std::max(norm_inf_cols[col], std::abs(value));
+        norm_inf_rows[row] = std::max(norm_inf_rows[row], std::abs(value));
+        norm_one_cols[col] += std::abs(value);
+        norm_one_rows[row] += std::abs(value);
+      }
+    }
+  }
+  if (std::isinf(Amin)) Amin = 0.0;
+
+  double norm_inf_col_min = kHighsInf;
+  double norm_inf_col_max = 0.0;
+  double norm_inf_row_min = kHighsInf;
+  double norm_inf_row_max = 0.0;
+  for (double d : norm_inf_cols) {
+    norm_inf_col_min = std::min(norm_inf_col_min, d);
+    norm_inf_col_max = std::max(norm_inf_col_max, d);
+  }
+  for (double d : norm_inf_rows) {
+    norm_inf_row_min = std::min(norm_inf_row_min, d);
+    norm_inf_row_max = std::max(norm_inf_row_max, d);
+  }
+
+  double norm_one_col_min = kHighsInf;
+  double norm_one_col_max = 0.0;
+  double norm_one_row_min = kHighsInf;
+  double norm_one_row_max = 0.0;
+  for (double d : norm_one_cols) {
+    norm_one_col_min = std::min(norm_one_col_min, d);
+    norm_one_col_max = std::max(norm_one_col_max, d);
+  }
+  for (double d : norm_one_rows) {
+    norm_one_row_min = std::min(norm_one_row_min, d);
+    norm_one_row_max = std::max(norm_one_row_max, d);
+  }
+
+  // compute max and min entry of c
+  double cmin = kHighsInf;
+  double cmax = 0.0;
+  for (Int i = 0; i < n_; ++i) {
+    if (c_[i] != 0.0) {
+      cmin = std::min(cmin, std::abs(c_[i]));
+      cmax = std::max(cmax, std::abs(c_[i]));
+    }
+  }
+  if (std::isinf(cmin)) cmin = 0.0;
+
+  // compute max and min entry of b
+  double bmin = kHighsInf;
+  double bmax = 0.0;
+  for (Int i = 0; i < m_; ++i) {
+    if (b_[i] != 0.0) {
+      bmin = std::min(bmin, std::abs(b_[i]));
+      bmax = std::max(bmax, std::abs(b_[i]));
+    }
+  }
+  if (std::isinf(bmin)) bmin = 0.0;
+
+  // compute max and min entry of Q in absolute value
+  double Qmin = kHighsInf;
+  double Qmax = 0.0;
+  for (double val : Q_.value_) {
+    if (val != 0.0) {
+      Qmin = std::min(Qmin, std::abs(val));
+      Qmax = std::max(Qmax, std::abs(val));
+    }
+  }
+  if (std::isinf(Qmin)) Qmin = 0.0;
+
+  // compute max and min for bounds intervals
+  double boundmin = kHighsInf;
+  double boundmax = 0.0;
+  for (Int i = 0; i < n_; ++i) {
+    if (std::isfinite(lower_[i]) && std::isfinite(upper_[i])) {
+      const double diff = std::abs(upper_[i] - lower_[i]);
+      boundmin = std::min(boundmin, diff);
+      boundmax = std::max(boundmax, diff);
+    }
+  }
+  if (std::isinf(boundmin)) boundmin = 0.0;
+
+  // compute max and min scaling
+  double scalemin = kHighsInf;
+  double scalemax = 0.0;
+  if (scaled()) {
+    for (Int i = 0; i < n_; ++i) {
+      scalemin = std::min(scalemin, colScale(i));
+      scalemax = std::max(scalemax, colScale(i));
+    }
+    for (Int i = 0; i < m_; ++i) {
+      scalemin = std::min(scalemin, rowScale(i));
+      scalemax = std::max(scalemax, rowScale(i));
+    }
+  }
+  if (std::isinf(scalemin)) scalemin = 0.0;
+
+  // print ranges
+  log_stream << textline("Range of A:") << "[" << sci(Amin, 5, 1) << ", "
+             << sci(Amax, 5, 1) << "]\n";
+
+  if (log.debug(1)) {
+    log_stream << textline("Inf-norm rows:") << "["
+               << sci(norm_inf_row_min, 5, 1) << ", "
+               << sci(norm_inf_row_max, 5, 1) << "]\n";
+
+    log_stream << textline("Inf-norm cols:") << "["
+               << sci(norm_inf_col_min, 5, 1) << ", "
+               << sci(norm_inf_col_max, 5, 1) << "]\n";
+
+    log_stream << textline("One-norm rows:") << "["
+               << sci(norm_one_row_min, 5, 1) << ", "
+               << sci(norm_one_row_max, 5, 1) << "]\n";
+
+    log_stream << textline("One-norm cols:") << "["
+               << sci(norm_one_col_min, 5, 1) << ", "
+               << sci(norm_one_col_max, 5, 1) << "]\n";
+  }
+
+  log_stream << textline("Range of b:") << "[" << sci(bmin, 5, 1) << ", "
+             << sci(bmax, 5, 1) << "]\n";
+
+  log_stream << textline("Range of c:") << "[" << sci(cmin, 5, 1) << ", "
+             << sci(cmax, 5, 1) << "]\n";
+
+  if (qp()) {
+    log_stream << textline("Range of Q:") << "[" << sci(Qmin, 5, 1) << ", "
+               << sci(Qmax, 5, 1) << "]\n";
+  }
+
+  log_stream << textline("Range of bound intervals:") << "["
+             << sci(boundmin, 5, 1) << ", " << sci(boundmax, 5, 1) << "]\n";
+
+  log_stream << textline("Scaling coefficients:") << "[" << sci(scalemin, 5, 1)
+             << ", " << sci(scalemax, 5, 1) << "]\n";
+
+  if (log.debug(1)) preprocessor_.print(log_stream);
+
+  log.print(log_stream);
+}
+
+void Model::denseColumns() {
+  // Compute the maximum density of any column of A and count the number of
+  // dense columns.
+
+  max_col_density_ = 0.0;
+  num_dense_cols_ = 0;
+  for (Int col = 0; col < n_; ++col) {
+    Int col_nz = A_.start_[col + 1] - A_.start_[col];
+    double col_density = (double)col_nz / m_;
+    max_col_density_ = std::max(max_col_density_, col_density);
+    if (A_.num_row_ > kMinRowsForDensity && col_density > kDenseColThresh)
+      ++num_dense_cols_;
+  }
+}
+
+Int Model::loadIntoIpx(ipx::LpSolver& lps) const {
+  Int ipx_m, ipx_n;
+  std::vector<double> ipx_b, ipx_c, ipx_lower, ipx_upper, ipx_A_vals;
+  std::vector<Int> ipx_A_ptr, ipx_A_rows;
+  std::vector<char> ipx_constraints;
+  double ipx_offset;
+
+  if (!lp_orig_) return kStatusError;
+
+  fillInIpxData(*lp_orig_, ipx_n, ipx_m, ipx_offset, ipx_c, ipx_lower,
+                ipx_upper, ipx_A_ptr, ipx_A_rows, ipx_A_vals, ipx_b,
+                ipx_constraints);
+
+  Int load_status = lps.LoadModel(
+      ipx_n, ipx_offset, ipx_c.data(), ipx_lower.data(), ipx_upper.data(),
+      ipx_m, ipx_A_ptr.data(), ipx_A_rows.data(), ipx_A_vals.data(),
+      ipx_b.data(), ipx_constraints.data());
+
+  return load_status;
+}
+
+void Model::printDense() const {
+  std::vector<std::vector<double>> Adense(m_, std::vector<double>(n_, 0.0));
+  std::vector<std::vector<double>> Qdense(n_, std::vector<double>(n_, 0.0));
+
+  for (Int col = 0; col < n_; ++col) {
+    for (Int el = A_.start_[col]; el < A_.start_[col + 1]; ++el) {
+      const Int row = A_.index_[el];
+      const double val = A_.value_[el];
+      Adense[row][col] = val;
+    }
+  }
+  for (Int col = 0; col < n_; ++col) {
+    for (Int el = Q_.start_[col]; el < Q_.start_[col + 1]; ++el) {
+      const Int row = Q_.index_[el];
+      const double val = Q_.value_[el];
+      Qdense[row][col] = val;
+    }
+  }
+
+  printf("\nA\n");
+  for (Int i = 0; i < m_; ++i) {
+    for (Int j = 0; j < n_; ++j) printf("%6.2f ", Adense[i][j]);
+    printf("\n");
+  }
+  printf("b\n");
+  for (Int i = 0; i < m_; ++i) printf("%6.2f ", b_[i]);
+  printf("\n");
+  printf("c\n");
+  for (Int i = 0; i < n_; ++i) printf("%6.2f ", c_[i]);
+  printf("\n");
+  printf("lb\n");
+  for (Int i = 0; i < n_; ++i) printf("%6.2f ", lower_[i]);
+  printf("\n");
+  printf("ub\n");
+  for (Int i = 0; i < n_; ++i) printf("%6.2f ", upper_[i]);
+  printf("\n");
+  printf("Q\n");
+  for (Int i = 0; i < n_; ++i) {
+    for (Int j = 0; j < n_; ++j) printf("%6.2f ", Qdense[i][j]);
+    printf("\n");
+  }
+  printf("offset %6.2f\n", offset_);
+}
+
+}  // namespace hipo

data/ext/lpsolver-highs/highs/ipm/hipo/ipm/Model.h

@@ -0,0 +1,136 @@
+#ifndef HIPO_MODEL_H
+#define HIPO_MODEL_H
+
+#include <limits>
+#include <string>
+#include <vector>
+
+#include "LogHighs.h"
+#include "PreProcess.h"
+#include "ipm/hipo/auxiliary/IntConfig.h"
+#include "ipm/ipx/lp_solver.h"
+#include "lp_data/HighsLp.h"
+#include "model/HighsHessian.h"
+#include "util/HighsSparseMatrix.h"
+
+namespace hipo {
+
+// Optimization problem:
+// min  c^T * x + 1/2 x^T * Q * x
+// s.t. A * x = b
+//      x - xl = lower
+//      x + xu = upper
+//      xl, xu >= 0
+//
+// A is of size num_con x num_var, stored in CSC format using ptr, rows, vals.
+//
+// See Schork, Gondzio "Implementation of an interior point method with basis
+// preconditioning", Math. Prog. Comput. 12, 2020
+//
+
+class Model {
+ private:
+  // data of original problem
+  Int n_orig_{};
+  Int m_orig_{};
+  const HighsLp* lp_orig_ = nullptr;
+  double offset_;
+  ObjSense sense_ = ObjSense::kMinimize;
+  std::vector<double> rhs_orig_;
+  std::vector<char> constraints_orig_;
+
+  // data of reformulated problem
+  Int n_{};
+  Int m_{};
+  std::vector<double> c_{};
+  std::vector<double> b_{};
+  std::vector<double> lower_{};
+  std::vector<double> upper_{};
+  HighsSparseMatrix A_{};
+  HighsHessian Q_{};
+  std::vector<char> constraints_{};
+  Int num_dense_cols_{};
+  double max_col_density_{};
+
+  std::vector<double> colscale_, rowscale_;
+
+  double norm_unscaled_rhs_, norm_scaled_rhs_, norm_unscaled_obj_,
+      norm_scaled_obj_;
+
+  bool ready_ = false;
+
+  Preprocessor preprocessor_;
+
+  // norms of rows and cols of A
+  std::vector<double> one_norm_cols_, one_norm_rows_, inf_norm_cols_,
+      inf_norm_rows_;
+
+  void preprocess();
+  void denseColumns();
+  Int checkData() const;
+  void computeNorms();
+
+ public:
+  // Initialise the model
+  Int init(const HighsLp& lp, const HighsHessian& Q);
+
+  // Print information of model
+  void print(const LogHighs& log) const;
+
+  void printDense() const;
+
+  void postprocess(std::vector<double>& x, std::vector<double>& xl,
+                   std::vector<double>& xu, std::vector<double>& slack,
+                   std::vector<double>& y, std::vector<double>& zl,
+                   std::vector<double>& zu, const Iterate& it) const;
+
+  double normScaledRhs() const { return norm_scaled_rhs_; }
+  double normScaledObj() const { return norm_scaled_obj_; }
+  double normUnscaledObj() const { return norm_unscaled_obj_; }
+  double normUnscaledRhs() const { return norm_unscaled_rhs_; }
+
+  // Check if variable has finite lower/upper bound
+  bool hasLb(Int j) const { return std::isfinite(lower_[j]); }
+  bool hasUb(Int j) const { return std::isfinite(upper_[j]); }
+
+  Int m() const { return m_; }
+  Int n() const { return n_; }
+  Int n_orig() const { return n_orig_; }
+  Int m_orig() const { return m_orig_; }
+  const HighsLp* lpOrig() const { return lp_orig_; }
+  const std::vector<double>& rhsOrig() const { return rhs_orig_; }
+  const std::vector<char>& constraintsOrig() const { return constraints_orig_; }
+  bool qp() const { return !Q_.empty(); }
+  bool nonSeparableQp() const { return qp() && !Q_.isDiagonal(); }
+  double sense() const { return (double)sense_; }
+  const HighsSparseMatrix& A() const { return A_; }
+  const HighsHessian& Q() const { return Q_; }
+  const std::vector<double>& b() const { return b_; }
+  const std::vector<double>& c() const { return c_; }
+  double lb(Int i) const { return lower_[i]; }
+  double ub(Int i) const { return upper_[i]; }
+  char constraint(Int i) const { return constraints_[i]; }
+  double colScale(Int i) const { return scaled() ? colscale_[i] : 1.0; }
+  double rowScale(Int i) const { return scaled() ? rowscale_[i] : 1.0; }
+  bool ready() const { return ready_; }
+  bool scaled() const { return !colscale_.empty(); }
+  double offset() const { return offset_; }
+  double maxColDensity() const { return max_col_density_; }
+  Int numDenseCols() const { return num_dense_cols_; }
+  double oneNormRows(Int i) const { return one_norm_rows_[i]; }
+  double oneNormCols(Int i) const { return one_norm_cols_[i]; }
+  double infNormRows(Int i) const { return inf_norm_rows_[i]; }
+  double infNormCols(Int i) const { return inf_norm_cols_[i]; }
+
+  Int loadIntoIpx(ipx::LpSolver& lps) const;
+
+  // classes for preprocessing
+  friend struct PreprocessEmptyRows;
+  friend struct PreprocessFixedVars;
+  friend struct PreprocessScaling;
+  friend struct PreprocessFormulation;
+};
+
+}  // namespace hipo
+
+#endif

data/ext/lpsolver-highs/highs/ipm/hipo/ipm/Options.h

@@ -0,0 +1,35 @@
+#ifndef HIPO_OPTION_H
+#define HIPO_OPTION_H
+
+#include "Parameters.h"
+#include "io/HighsIO.h"
+#include "lp_data/HighsOptions.h"
+
+namespace hipo {
+
+struct Options {
+  // Solver options
+  std::string nla = kHighsChooseString;
+  std::string crossover = kHighsOffString;
+  std::string parallel = kHighsChooseString;
+  std::string parallel_type = kHipoBothString;
+  std::string ordering = kHighsChooseString;
+
+  // Ipm parameters
+  Int max_iter = kMaxIterDefault;
+  double feasibility_tol = kIpmTolDefault;
+  double optimality_tol = kIpmTolDefault;
+  double crossover_tol = kIpmTolDefault;
+  bool refine_with_ipx = true;
+  double time_limit = -1.0;
+  Int block_size = 0;
+
+  // Logging
+  bool display = true;
+  bool timeless_log = false;
+  const HighsLogOptions* log_options = nullptr;
+};
+
+}  // namespace hipo
+
+#endif

data/ext/lpsolver-highs/highs/ipm/hipo/ipm/Parameters.h

@@ -0,0 +1,63 @@
+#ifndef HIPO_PARAMETERS_H
+#define HIPO_PARAMETERS_H
+
+#include "ipm/hipo/auxiliary/IntConfig.h"
+
+namespace hipo {
+
+// parameters for termination
+const Int kMaxIterDefault = 200;
+const double kIpmTolDefault = 1e-8;
+const Int kMaxBadIter = 5;
+const double kDivergeTol = 1e3;
+
+// parameters for correctors
+const double kGammaCorrector = 0.1;
+const double kSigmaAffine = 0.01;
+const Int kMaxCorrectors = 10;
+const double kMccIncreaseAlpha = 0.1;
+const double kMccIncreaseMin = 0.1;
+const double kSmallProduct = 1e-3;
+const double kLargeProduct = 1e3;
+
+// parameters for choice of AS or NE
+const double kSpopsWeight = 30.0;
+const double kRatioOpsThresh = 10.0;
+const double kRatioSnThresh = 1.5;
+const double kSymbNzMult = 5.0;
+
+// parameters for choice of parallelism
+const double kLargeFlopsThresh = 1e7;
+const double kLargeSpeedupThresh = 1;
+const double kLargeSnThresh = 20.0;
+const double kSmallSnThresh = 5.0;
+const Int kMinNumberSn = 10;
+const double kLargeStorageGB = 20.0;
+const double kLargeFillin = 50.0;
+const double kMaxTreeDepth = 1000;
+
+// parameters for choice of ordering
+const double kFlopsOrderingThresh = 1.2;
+
+// parameters for dense columns
+const double kDenseColThresh = 0.5;
+const Int kMinRowsForDensity = 2000;
+
+// parameters for iterative refinement
+const Int kMaxIterRefine = 3;
+const double kTolRefine = 1e-12;
+
+// parameters for scaling
+const double kSmallScalingCoeff = 1e-4;
+const double kLargeScalingCoeff = 1e4;
+const double kSmallBoundDiff = 1e-3;
+
+// static regularisation
+struct Regularisation {
+  double primal = 1e-12;
+  double dual = 1e-10;
+};
+
+}  // namespace hipo
+
+#endif