lpsolver 0.1.0 → 0.2.1

data/ext/lpsolver-highs/highs/presolve/ICrashUtil.cpp

@@ -0,0 +1,267 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/**@file presolve/ICrashUtil.cpp
+ * @brief
+ * @author Julian Hall, Ivet Galabova, Qi Huangfu and Michael Feldmeier
+ */
+#include "presolve/ICrashUtil.h"
+
+#include <algorithm>
+#include <cmath>
+
+#include "io/HighsIO.h"
+#include "lp_data/HighsLp.h"
+#include "lp_data/HighsLpUtils.h"
+#include "lp_data/HighsSolution.h"
+#include "util/HighsUtils.h"
+
+void convertToMinimization(HighsLp& lp) {
+  if (lp.sense_ != ObjSense::kMinimize) {
+    for (int col = 0; col < lp.num_col_; col++)
+      lp.col_cost_[col] = -lp.col_cost_[col];
+  }
+}
+
+bool isEqualityProblem(const HighsLp& lp) {
+  for (int row = 0; row < lp.num_row_; row++)
+    if (lp.row_lower_[row] != lp.row_upper_[row]) return false;
+
+  return true;
+}
+
+double vectorProduct(const std::vector<double>& v1,
+                     const std::vector<double>& v2) {
+  assert(v1.size() == v2.size());
+  double sum = 0;
+  for (int i = 0; i < (int)v1.size(); i++) sum += v1[i] * v2[i];
+  return sum;
+}
+
+void muptiplyByTranspose(const HighsLp& lp, const std::vector<double>& v,
+                         std::vector<double>& result) {
+  assert((int)result.size() == lp.num_col_);
+  assert((int)v.size() == lp.num_row_);
+
+  result.assign(lp.num_col_, 0);
+  for (int col = 0; col < lp.num_col_; col++) {
+    for (int k = lp.a_matrix_.start_[col]; k < lp.a_matrix_.start_[col + 1];
+         k++) {
+      const int row = lp.a_matrix_.index_[k];
+      result.at(col) += lp.a_matrix_.value_[k] * v[row];
+    }
+  }
+}
+
+void printMinorIterationDetails(const double iteration, const double col,
+                                const double old_value, const double update,
+                                const double ctx, const std::vector<double>& r,
+                                const double quadratic_objective,
+                                HighsLogOptions options) {
+  double rnorm = getNorm2(r);
+  std::stringstream ss;
+  ss << "iter " << iteration;
+  ss << ", col " << col;
+  ss << ", update " << update;
+  ss << ", old_value " << old_value;
+  ss << ", new_value " << old_value + update;
+  ss << ", ctx " << ctx;
+  ss << ", r " << rnorm;
+  ss << ", quadratic_objective " << quadratic_objective;
+  ss << std::endl;
+
+  // std::cout << ss.str();
+  highsLogUser(options, HighsLogType::kInfo, ss.str().c_str());
+}
+
+bool initialize(const HighsLp& lp, HighsSolution& solution,
+                std::vector<double>& lambda) {
+  // Clear and resize primal column solution.
+  solution.clear();
+  solution.col_value.resize(lp.num_col_);
+
+  for (int col = 0; col < lp.num_col_; col++) {
+    if (lp.col_lower_[col] <= 0 && lp.col_upper_[col] >= 0)
+      solution.col_value[col] = 0;
+    else if (lp.col_lower_[col] > 0)
+      solution.col_value[col] = lp.col_lower_[col];
+    else if (lp.col_upper_[col] < 0)
+      solution.col_value[col] = lp.col_upper_[col];
+    else {
+      printf("ICrash error: setting initial value for column %d\n", col);
+      return false;
+    }
+  }
+
+  lambda.resize(lp.num_row_);
+  lambda.assign(lp.num_row_, 0);
+
+  return true;
+}
+
+double minimizeComponentQP(const int col, const double mu, const HighsLp& lp,
+                           double& objective, std::vector<double>& residual,
+                           HighsSolution& sol) {
+  // Minimize quadratic for column col.
+
+  // Formulas for a and b when minimizing for x_j
+  // a = (1/(2*mu)) * sum_i a_ij^2
+  // b = -(1/(2*mu)) sum_i (2 * a_ij * (sum_{k!=j} a_ik * x_k - b_i))
+  // b / 2 = -(1/(2*mu)) sum_i (2 * a_ij
+  double a = 0.0;
+  double b = 0.0;
+
+  for (int k = lp.a_matrix_.start_[col]; k < lp.a_matrix_.start_[col + 1];
+       k++) {
+    int row = lp.a_matrix_.index_[k];
+    a += lp.a_matrix_.value_[k] * lp.a_matrix_.value_[k];
+    // matlab but with b = b / 2
+    double bracket =
+        -residual[row] - lp.a_matrix_.value_[k] * sol.col_value[col];
+    // clp minimizing for delta_x
+    // double bracket_clp = - residual_[row];
+    b += lp.a_matrix_.value_[k] * bracket;
+  }
+
+  a = (0.5 / mu) * a;
+  b = (0.5 / mu) * b + 0.5 * lp.col_cost_[col];
+
+  double theta = -b / a;
+  double delta_x = 0;
+
+  // matlab
+  double new_x;
+  if (theta > 0)
+    new_x = std::min(theta, lp.col_upper_[col]);
+  else
+    new_x = std::max(theta, lp.col_lower_[col]);
+  delta_x = new_x - sol.col_value[col];
+
+  // clp minimizing for delta_x
+  // if (theta > 0)
+  //   delta_x = std::min(theta, lp_.col_upper_[col] - col_value_[col]);
+  // else
+  //   delta_x = std::max(theta, lp_.col_lower_[col] - col_value_[col]);
+
+  sol.col_value[col] += delta_x;
+
+  // std::cout << "col " << col << ": " << delta_x << std::endl;
+
+  // Update objective, row_value, residual after each component update.
+  objective += lp.col_cost_[col] * delta_x;
+  for (int k = lp.a_matrix_.start_[col]; k < lp.a_matrix_.start_[col + 1];
+       k++) {
+    int row = lp.a_matrix_.index_[k];
+    sol.row_value[row] += lp.a_matrix_.value_[k] * delta_x;
+    residual[row] = std::fabs(lp.row_upper_[row] - sol.row_value[row]);
+  }
+
+  return delta_x;
+}
+
+double minimizeComponentIca(const int col, const double mu,
+                            const std::vector<double>& lambda,
+                            const HighsLp& lp, double& objective,
+                            std::vector<double>& residual, HighsSolution& sol) {
+  // Minimize quadratic for column col.
+
+  // Formulas for a and b when minimizing for x_j
+  // a = (1/(2*mu)) * sum_i a_ij^2
+  // b = -(1/(2*mu)) sum_i (2 * a_ij * (sum_{k!=j} a_ik * x_k - b_i)) + c_j (\)
+  //     + sum_i a_ij * lambda_i
+  // b / 2 = -(1/(2*mu)) sum_i (2 * a_ij
+  double a = 0.0;
+  double b = 0.0;
+
+  for (int k = lp.a_matrix_.start_[col]; k < lp.a_matrix_.start_[col + 1];
+       k++) {
+    int row = lp.a_matrix_.index_[k];
+    a += lp.a_matrix_.value_[k] * lp.a_matrix_.value_[k];
+    // matlab but with b = b / 2
+    double bracket =
+        -residual[row] - lp.a_matrix_.value_[k] * sol.col_value[col];
+    bracket += lambda[row];
+    // clp minimizing for delta_x
+    // double bracket_clp = - residual_[row];
+    b += lp.a_matrix_.value_[k] * bracket;
+  }
+
+  a = (0.5 / mu) * a;
+  b = (0.5 / mu) * b + 0.5 * lp.col_cost_[col];
+
+  double theta = -b / a;
+  double delta_x = 0;
+
+  // matlab
+  double new_x;
+  if (theta > 0)
+    new_x = std::min(theta, lp.col_upper_[col]);
+  else
+    new_x = std::max(theta, lp.col_lower_[col]);
+  delta_x = new_x - sol.col_value[col];
+
+  // clp minimizing for delta_x
+  // if (theta > 0)
+  //   delta_x = std::min(theta, lp_.col_upper_[col] - col_value_[col]);
+  // else
+  //   delta_x = std::max(theta, lp_.col_lower_[col] - col_value_[col]);
+
+  sol.col_value[col] += delta_x;
+
+  // std::cout << "col " << col << ": " << delta_x << std::endl;
+
+  // Update objective, row_value, residual after each component update.
+  objective += lp.col_cost_[col] * delta_x;
+  for (int k = lp.a_matrix_.start_[col]; k < lp.a_matrix_.start_[col + 1];
+       k++) {
+    int row = lp.a_matrix_.index_[k];
+    residual[row] -= lp.a_matrix_.value_[k] * delta_x;
+    sol.row_value[row] += lp.a_matrix_.value_[k] * delta_x;
+    // residual[row] = fabs(lp.row_upper_[row] - sol.row_value[row]); # ~~~
+  }
+
+  return delta_x;
+}
+
+void updateResidual(bool piecewise, const HighsLp& lp, const HighsSolution& sol,
+                    std::vector<double>& residual) {
+  residual.clear();
+  residual.assign(lp.num_row_, 0);
+
+  if (!piecewise) {
+    assert(isEqualityProblem(lp));
+    for (int row = 0; row < lp.num_row_; row++)
+      residual[row] = std::fabs(lp.row_upper_[row] - sol.row_value[row]);
+  } else {
+    // piecewise
+    for (int row = 0; row < lp.num_row_; row++) {
+      double value = 0;
+      if (sol.row_value[row] <= lp.row_lower_[row])
+        value = lp.row_lower_[row] - sol.row_value[row];
+      else if (sol.row_value[row] >= lp.row_upper_[row])
+        value = sol.row_value[row] - lp.row_upper_[row];
+
+      residual[row] = value;
+    }
+  }
+}
+
+void updateResidualFast(const HighsLp& lp, const HighsSolution& sol,
+                        std::vector<double>& residual) {
+  assert(isEqualityProblem(lp));
+  for (int row = 0; row < lp.num_row_; row++) {
+    residual[row] = std::fabs(lp.row_upper_[row] - sol.row_value[row]);
+  }
+}
+
+// Allows negative residuals
+void updateResidualIca(const HighsLp& lp, const HighsSolution& sol,
+                       std::vector<double>& residual) {
+  assert(isEqualityProblem(lp));
+  for (int row = 0; row < lp.num_row_; row++)
+    residual[row] = lp.row_upper_[row] - sol.row_value[row];
+}

data/ext/lpsolver-highs/highs/presolve/ICrashUtil.h

@@ -0,0 +1,62 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/**@file presolve/ICrashUtil.h
+ * @brief
+ * @author Julian Hall, Ivet Galabova, Qi Huangfu and Michael Feldmeier
+ */
+#ifndef PRESOLVE_ICRASH_UTIL_H_
+#define PRESOLVE_ICRASH_UTIL_H_
+
+#include <vector>
+
+#include "io/HighsIO.h"
+
+class HighsLp;
+struct HighsSolution;
+
+void convertToMinimization(HighsLp& lp);
+
+bool isEqualityProblem(const HighsLp& lp);
+
+double vectorProduct(const std::vector<double>& v1,
+                     const std::vector<double>& v2);
+
+// Calculates value of A^t*v in result.
+void muptiplyByTranspose(const HighsLp& lp, const std::vector<double>& v,
+                         std::vector<double>& result);
+
+void printMinorIterationDetails(const double iteration, const double col,
+                                const double old_value, const double update,
+                                const double ctx, const std::vector<double>& r,
+                                const double quadratic_objective,
+                                HighsLogOptions options);
+
+bool initialize(const HighsLp& lp, HighsSolution& solution,
+                std::vector<double>& lambda);
+
+double minimizeComponentQP(const int col, const double mu, const HighsLp& lp,
+                           double& objective, std::vector<double>& residual,
+                           HighsSolution& sol);
+
+double minimizeComponentIca(const int col, const double mu,
+                            const std::vector<double>& lambda,
+                            const HighsLp& lp, double& objective,
+                            std::vector<double>& residual, HighsSolution& sol);
+
+// todo:
+double minimizeComponentBreakpoints();
+
+void updateResidual(bool piecewise, const HighsLp& lp, const HighsSolution& sol,
+                    std::vector<double>& residual);
+void updateResidualFast(const HighsLp& lp, const HighsSolution& sol,
+                        std::vector<double>& residual);
+
+// Allows negative residuals
+void updateResidualIca(const HighsLp& lp, const HighsSolution& sol,
+                       std::vector<double>& residual);
+#endif

data/ext/lpsolver-highs/highs/presolve/ICrashX.cpp

@@ -0,0 +1,173 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+#include "presolve/ICrashX.h"
+
+#include <algorithm>
+#include <iostream>
+
+#include "HConfig.h"
+#include "io/HighsIO.h"
+#include "ipm/IpxWrapper.h"
+
+HighsStatus callCrossover(const HighsOptions& options, const HighsLp& lp,
+                          HighsBasis& highs_basis,
+                          HighsSolution& highs_solution,
+                          HighsModelStatus& model_status, HighsInfo& highs_info,
+                          HighsCallback& highs_callback) {
+  ipx::Int num_col, num_row;
+  double offset;
+  std::vector<ipx::Int> Ap, Ai;
+  std::vector<double> objective, col_lb, col_ub, Av, rhs;
+  std::vector<char> constraint_type;
+
+  fillInIpxData(lp, num_col, num_row, offset, objective, col_lb, col_ub, Ap, Ai,
+                Av, rhs, constraint_type);
+  // if (res != IpxStatus::OK) return HighsStatus::kError;
+
+  const HighsLogOptions& log_options = options.log_options;
+
+  ipx::Parameters parameters;
+  parameters.run_crossover = 1;  // 1 = "on"
+  parameters.crash_basis = 1;    // 0 = slack basis; 1 = crash basis
+  parameters.display = 1;
+  if (!options.output_flag) parameters.display = 0;
+  // Modify parameters.debug according to log_dev_level
+  parameters.debug = 0;
+  if (options.log_dev_level == kHighsLogDevLevelDetailed) {
+    // Default options.log_dev_level setting is kHighsLogDevLevelNone, yielding
+    // default setting debug = 0
+  } else if (options.log_dev_level == kHighsLogDevLevelInfo) {
+    parameters.debug = 2;
+  } else if (options.log_dev_level == kHighsLogDevLevelVerbose) {
+    parameters.debug = 4;
+  }
+  parameters.highs_logging = true;
+  parameters.log_options = &options.log_options;
+
+  ipx::LpSolver lps;
+  lps.SetParameters(parameters);
+
+  // Set pointer to any callback
+  lps.SetCallback(&highs_callback);
+
+  ipx::Int load_status = lps.LoadModel(
+      num_col, offset, objective.data(), col_lb.data(), col_ub.data(), num_row,
+      Ap.data(), Ai.data(), Av.data(), rhs.data(), constraint_type.data());
+  if (load_status != 0) {
+    highsLogUser(log_options, HighsLogType::kError,
+                 "Error loading ipx model\n");
+    return HighsStatus::kError;
+  }
+
+  // Set x values within bounds.
+  std::vector<double> x(highs_solution.col_value);
+  for (int i = 0; i < num_col; i++) {
+    x[i] = std::max(x[i], col_lb[i]);
+    x[i] = std::min(x[i], col_ub[i]);
+  }
+
+  // Build slack variables from rhs-A*x but subject to sign conditions.
+  std::vector<double> slack(rhs);
+  for (int i = 0; i < num_col; i++) {
+    for (int p = Ap[i]; p < Ap[i + 1]; ++p) slack[Ai[p]] -= Av[p] * x[i];
+  }
+  for (int i = 0; i < num_row; i++) {
+    switch (constraint_type[i]) {
+      case '=':
+        slack[i] = 0.0;
+        break;
+      case '<':
+        slack[i] = std::max(slack[i], 0.0);
+        break;
+      case '>':
+        slack[i] = std::min(slack[i], 0.0);
+        break;
+    }
+  }
+  ipx::Int crossover_status;
+  if (highs_solution.dual_valid &&
+      (HighsInt)highs_solution.col_dual.size() == num_col &&
+      (HighsInt)highs_solution.row_dual.size() == num_row) {
+    highsLogUser(log_options, HighsLogType::kInfo,
+                 "Calling IPX crossover with primal and dual values\n");
+    crossover_status = lps.CrossoverFromStartingPoint(
+        x.data(), slack.data(), highs_solution.row_dual.data(),
+        highs_solution.col_dual.data());
+  } else {
+    highsLogUser(log_options, HighsLogType::kInfo,
+                 "Calling IPX crossover with only primal values\n");
+    crossover_status = lps.CrossoverFromStartingPoint(x.data(), slack.data(),
+                                                      nullptr, nullptr);
+  }
+
+  if (crossover_status != 0) {
+    highsLogUser(log_options, HighsLogType::kError,
+                 "IPX crossover error: flag = %d\n", (int)crossover_status);
+    return HighsStatus::kError;
+  }
+  ipx::Info ipx_info = lps.GetInfo();
+  highs_info.crossover_iteration_count += (HighsInt)ipx_info.updates_crossover;
+  const bool imprecise_solution =
+      ipx_info.status_crossover == IPX_STATUS_imprecise;
+  if (ipx_info.status_crossover != IPX_STATUS_optimal &&
+      ipx_info.status_crossover != IPX_STATUS_imprecise &&
+      ipx_info.status_crossover != IPX_STATUS_time_limit) {
+    highsLogUser(log_options, HighsLogType::kError,
+                 "IPX crossover failed: status = %d\n",
+                 (int)ipx_info.status_crossover);
+    return HighsStatus::kError;
+  }
+  if (ipx_info.status_crossover == IPX_STATUS_time_limit) {
+    model_status = HighsModelStatus::kTimeLimit;
+    return HighsStatus::kWarning;
+  }
+
+  // Get basis
+  IpxSolution ipx_solution;
+  ipx_solution.num_col = num_col;
+  ipx_solution.num_row = num_row;
+  ipx_solution.ipx_col_value.resize(num_col);
+  ipx_solution.ipx_row_value.resize(num_row);
+  ipx_solution.ipx_col_dual.resize(num_col);
+  ipx_solution.ipx_row_dual.resize(num_row);
+  ipx_solution.ipx_row_status.resize(num_row);
+  ipx_solution.ipx_col_status.resize(num_col);
+  ipx::Int errflag = lps.GetBasicSolution(
+      ipx_solution.ipx_col_value.data(), ipx_solution.ipx_row_value.data(),
+      ipx_solution.ipx_row_dual.data(), ipx_solution.ipx_col_dual.data(),
+      ipx_solution.ipx_row_status.data(), ipx_solution.ipx_col_status.data());
+  if (errflag != 0) {
+    highsLogUser(log_options, HighsLogType::kError,
+                 "IPX crossover getting basic solution: flag = %d\n",
+                 (int)errflag);
+    return HighsStatus::kError;
+  }
+
+  // Convert the IPX basic solution to a HiGHS basic solution
+  HighsStatus status = ipxBasicSolutionToHighsBasicSolution(
+      options.log_options, lp, rhs, constraint_type, ipx_solution, highs_basis,
+      highs_solution);
+
+  if (status != HighsStatus::kOk) {
+    highsLogUser(
+        log_options, HighsLogType::kError,
+        "Failed to convert IPX basic solution to Highs basic solution\n");
+    return HighsStatus::kError;
+  }
+  highs_info.basis_validity =
+      highs_basis.valid ? kBasisValidityValid : kBasisValidityInvalid;
+  HighsStatus return_status;
+  if (imprecise_solution) {
+    model_status = HighsModelStatus::kUnknown;
+    return_status = HighsStatus::kWarning;
+  } else {
+    model_status = HighsModelStatus::kOptimal;
+    return_status = HighsStatus::kOk;
+  }
+  return return_status;
+}

data/ext/lpsolver-highs/highs/presolve/ICrashX.h

@@ -0,0 +1,23 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+#ifndef PRESOLVE_ICRASHX_H_
+#define PRESOLVE_ICRASHX_H_
+
+#include <iostream>
+
+#include "HConfig.h"
+#include "lp_data/HighsLp.h"
+#include "lp_data/HighsSolution.h"
+
+HighsStatus callCrossover(const HighsOptions& options, const HighsLp& lp,
+                          HighsBasis& highs_basis,
+                          HighsSolution& highs_solution,
+                          HighsModelStatus& model_status, HighsInfo& highs_info,
+                          HighsCallback& highs_callback);
+
+#endif

data/ext/lpsolver-highs/highs/presolve/PresolveComponent.cpp

@@ -0,0 +1,45 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/**@file PresolveComponent.cpp
+ * @brief The HiGHS class
+ */
+
+#include "presolve/PresolveComponent.h"
+
+#include "presolve/HPresolve.h"
+
+HighsStatus PresolveComponent::init(const HighsLp& lp, HighsTimer& timer,
+                                    bool mip) {
+  data_.postSolveStack.initializeIndexMaps(lp.num_row_, lp.num_col_);
+  data_.reduced_lp_ = lp;
+  this->timer = &timer;
+  return HighsStatus::kOk;
+}
+
+void PresolveComponent::negateReducedLpColDuals() {
+  for (HighsInt col = 0; col < data_.reduced_lp_.num_col_; col++)
+    data_.recovered_solution_.col_dual[col] =
+        -data_.recovered_solution_.col_dual[col];
+  return;
+}
+
+HighsPresolveStatus PresolveComponent::run() {
+  presolve::HPresolve presolve;
+  if (!presolve.okSetInput(data_.reduced_lp_, *options_,
+                           options_->presolve_reduction_limit, timer)) {
+    presolve_status_ = HighsPresolveStatus::kOutOfMemory;
+    return presolve_status_;
+  }
+
+  presolve.run(data_.postSolveStack);
+  data_.presolve_log_ = presolve.getPresolveLog();
+  presolve_status_ = presolve.getPresolveStatus();
+  return presolve_status_;
+}
+
+void PresolveComponent::clear() { data_.clear(); }

data/ext/lpsolver-highs/highs/presolve/PresolveComponent.h

@@ -0,0 +1,90 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/**@file PresolveComponent.h
+ * @brief The HiGHS class
+ */
+#ifndef PRESOLVE_PRESOLVE_COMPONENT_H_
+#define PRESOLVE_PRESOLVE_COMPONENT_H_
+
+// Not all necessary, but copied from Presolve.h to avoid non-Linux
+// failures
+#include <list>
+#include <map>
+#include <stack>
+#include <string>
+#include <utility>
+
+#include "lp_data/HighsLp.h"
+#include "presolve/HighsPostsolveStack.h"
+#include "util/HighsComponent.h"
+#include "util/HighsTimer.h"
+
+// Class defining the Presolve Component to be used in HiGHS.
+// What used to be in Presolve.h but allowing for further testing and dev.
+
+// The structure of component is general, of the presolve component - presolve
+// specific.
+
+struct PresolveComponentData : public HighsComponentData {
+  HighsLp reduced_lp_;
+  presolve::HighsPostsolveStack postSolveStack;
+  HighsSolution recovered_solution_;
+  HighsBasis recovered_basis_;
+  HighsPresolveLog presolve_log_;
+
+  void clear() {
+    is_valid = false;
+
+    postSolveStack = presolve::HighsPostsolveStack();
+
+    reduced_lp_.clear();
+    recovered_solution_.clear();
+    recovered_basis_.clear();
+  }
+
+  virtual ~PresolveComponentData() = default;
+};
+
+// HighsComponentInfo is a placeholder for details we want to query from outside
+// of HiGHS like execution information. Times are recorded at the end of
+// Highs::run()
+struct PresolveComponentInfo : public HighsComponentInfo {
+  HighsInt n_rows_removed = 0;
+  HighsInt n_cols_removed = 0;
+  HighsInt n_nnz_removed = 0;
+
+  double presolve_time = 0;
+  double postsolve_time = 0;
+
+  virtual ~PresolveComponentInfo() = default;
+};
+
+class PresolveComponent : public HighsComponent {
+ public:
+  void clear() override;
+
+  HighsStatus init(const HighsLp& lp, HighsTimer& timer, bool mip = false);
+
+  HighsPresolveStatus run();
+
+  HighsLp& getReducedProblem() { return data_.reduced_lp_; }
+  HighsPresolveLog& getPresolveLog() { return data_.presolve_log_; }
+
+  void negateReducedLpColDuals();
+
+  PresolveComponentInfo info_;
+  PresolveComponentData data_;
+  const HighsOptions* options_;
+  HighsTimer* timer;
+
+  HighsPresolveStatus presolve_status_ = HighsPresolveStatus::kNotPresolved;
+  HighsPostsolveStatus postsolve_status_ = HighsPostsolveStatus::kNotPresolved;
+
+  virtual ~PresolveComponent() = default;
+};
+#endif