casadi 3.6.2__cp311-none-manylinux2014_i686.whl → 3.6.4__cp311-none-manylinux2014_i686.whl

casadi/include/highs/mip/HighsPrimalHeuristics.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 #ifndef HIGHS_PRIMAL_HEURISTICS_H_
 #define HIGHS_PRIMAL_HEURISTICS_H_

casadi/include/highs/mip/HighsPseudocost.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
 #ifndef HIGHS_PSEUDOCOST_H_

casadi/include/highs/mip/HighsRedcostFixing.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 /**@file mip/HighsRedcostFixing.h
  * @brief reduced cost fixing using the current cutoff bound

casadi/include/highs/mip/HighsSearch.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 #ifndef HIGHS_SEARCH_H_
 #define HIGHS_SEARCH_H_

casadi/include/highs/mip/HighsSeparation.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 #ifndef HIGHS_SEPARATION_H_
 #define HIGHS_SEPARATION_H_

casadi/include/highs/mip/HighsSeparator.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 /**@file mip/HighsSeparator.h
  * @brief Base class for separators

casadi/include/highs/mip/HighsTableauSeparator.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 /**@file mip/HighsTableauSeparator.h
  * @brief Class for separating cuts from the LP tableaux rows

casadi/include/highs/mip/HighsTransformedLp.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 /**@file mip/HighsTransformedLp.h
  * @brief LP transformations useful for cutting plane separation. This includes

casadi/include/highs/model/HighsHessian.h

@@ -19,6 +19,7 @@
 #include <vector>
 
 #include "lp_data/HConst.h"
+#include "util/HighsCDouble.h"
 
 // class HighsHessian;
 
@@ -30,10 +31,11 @@ class HighsHessian {
   std::vector<HighsInt> start_;
   std::vector<HighsInt> index_;
   std::vector<double> value_;
-  bool operator==(const HighsHessian& hessian);
+  bool operator==(const HighsHessian& hessian) const;
   void product(const std::vector<double>& solution,
                std::vector<double>& product) const;
   double objectiveValue(const std::vector<double>& solution) const;
+  HighsCDouble objectiveCDoubleValue(const std::vector<double>& solution) const;
   void exactResize();
   void clear();
   bool formatOk() const {

casadi/include/highs/model/HighsModel.h

@@ -27,6 +27,8 @@ class HighsModel {
  public:
   HighsLp lp_;
   HighsHessian hessian_;
+  bool operator==(const HighsModel& model) const;
+  bool equalButForNames(const HighsModel& model) const;
   bool isQp() const { return this->hessian_.dim_; }
   bool isMip() const { return this->lp_.isMip(); }
   bool isEmpty() const {

casadi/include/highs/parallel/HighsSpinMutex.h

@@ -32,6 +32,7 @@ class HighsSpinMutex {
 #ifdef HIGHS_HAVE_MM_PAUSE
     _mm_pause();
 #else
+    // ToDo: See if this is OK on Mac M1
     std::this_thread::yield();
 #endif
   }
@@ -49,4 +50,4 @@ class HighsSpinMutex {
   void unlock() { flag.store(false, std::memory_order_release); }
 };
 
-#endif
+#endif

casadi/include/highs/parallel/HighsSplitDeque.h

@@ -274,7 +274,7 @@ class HighsSplitDeque {
   }
 
   void cancelTask(HighsInt taskIndex) {
-    assert(taskIndex < ownerData.head);
+    assert(taskIndex < (HighsInt)ownerData.head);
     assert(taskIndex >= 0);
     taskArray[taskIndex].cancel();
   }

casadi/include/highs/parallel/HighsTaskExecutor.h

@@ -88,8 +88,16 @@ class HighsTaskExecutor {
   void run_worker(int workerId) {
     // spin until the global executor pointer is set up
     ExecutorHandle* executor;
-    while (!(executor = mainWorkerHandle.load(std::memory_order_acquire)))
+    // Following yields warning C4706: assignment within conditional
+    // expression when building libhighs on Windows (/W4):
+    //
+    //    while (!(executor = mainWorkerHandle.load(std::memory_order_acquire)))
+    //      HighsSpinMutex::yieldProcessor();
+    while (true) {
+      executor = mainWorkerHandle.load(std::memory_order_acquire);
+      if (executor != nullptr) break;
       HighsSpinMutex::yieldProcessor();
+    }
     // now acquire a reference count of the global executor
     threadLocalExecutorHandle() = *executor;
     HighsSplitDeque* localDeque = workerDeques[workerId].get();
@@ -143,7 +151,7 @@ class HighsTaskExecutor {
     if (executorHandle.ptr) {
       // first spin until every worker has acquired its executor reference
       while (executorHandle.ptr.use_count() !=
-             executorHandle.ptr->workerDeques.size())
+             (long)executorHandle.ptr->workerDeques.size())
         HighsSpinMutex::yieldProcessor();
       // set the active flag to false first with release ordering
       executorHandle.ptr->mainWorkerHandle.store(nullptr,

casadi/include/highs/presolve/HPresolve.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 /**@file presolve/HPresolve.h
  * @brief
@@ -137,7 +135,7 @@ class HPresolve {
     kDualInfeasible,
     kStopped,
   };
-
+  HighsPresolveStatus presolve_status_;
   HPresolveAnalysis analysis_;
 
   // private functions for different shared functionality and matrix
@@ -275,7 +273,7 @@ class HPresolve {
 
   void shrinkProblem(HighsPostsolveStack& postsolve_stack);
 
-  void addToMatrix(HighsInt row, HighsInt col, double val);
+  void addToMatrix(const HighsInt row, const HighsInt col, const double val);
 
   Result runProbing(HighsPostsolveStack& postsolve_stack);
 
@@ -341,6 +339,11 @@ class HPresolve {
     return analysis_.presolve_log_;
   }
 
+  HighsPresolveStatus getPresolveStatus() const { return presolve_status_; }
+
+  HighsInt debugGetCheckCol() const;
+  HighsInt debugGetCheckRow() const;
+
   // Not currently called
   static void debug(const HighsLp& lp, const HighsOptions& options);
 };

casadi/include/highs/presolve/HPresolveAnalysis.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 /**@file presolve/HPresolveAnalysis.h
  * @brief
@@ -39,6 +37,9 @@ class HPresolveAnalysis {
   HighsPresolveLog presolve_log_;
 
   // for LP presolve
+  //
+  // Transform options->presolve_rule_off into logical settings in
+  // allow_rule_[*], commenting on the rules switched off
   void setup(const HighsLp* model_, const HighsOptions* options_,
              const HighsInt& numDeletedRows_, const HighsInt& numDeletedCols_);
   void resetNumDeleted();

casadi/include/highs/presolve/HighsPostsolveStack.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 /**@file HighsPostsolveStack.h
  * @brief Class to hold all information for postsolve and can transform back
@@ -62,6 +60,12 @@ class HighsPostsolveStack {
     Nonzero() = default;
   };
 
+  size_t debug_prev_numreductions = 0;
+  double debug_prev_col_lower = 0;
+  double debug_prev_col_upper = 0;
+  double debug_prev_row_lower = 0;
+  double debug_prev_row_upper = 0;
+
  private:
   /// transform a column x by a linear mapping with a new column x'.
   /// I.e. substitute x = a * x' + b
@@ -207,7 +211,8 @@ class HighsPostsolveStack {
 
     void undo(const HighsOptions& options, HighsSolution& solution,
               HighsBasis& basis) const;
-
+    bool okMerge(const double tolerance) const;
+    void undoFix(const HighsOptions& options, HighsSolution& solution) const;
     void transformToPresolvedSpace(std::vector<double>& primalSol) const;
   };
 
@@ -474,20 +479,32 @@ class HighsPostsolveStack {
     reductionAdded(ReductionType::kDuplicateRow);
   }
 
-  void duplicateColumn(double colScale, double colLower, double colUpper,
+  bool duplicateColumn(double colScale, double colLower, double colUpper,
                        double duplicateColLower, double duplicateColUpper,
                        HighsInt col, HighsInt duplicateCol, bool colIntegral,
-                       bool duplicateColIntegral) {
+                       bool duplicateColIntegral,
+                       const double ok_merge_tolerance) {
     const HighsInt origCol = origColIndex[col];
     const HighsInt origDuplicateCol = origColIndex[duplicateCol];
-    reductionValues.push(DuplicateColumn{
-        colScale, colLower, colUpper, duplicateColLower, duplicateColUpper,
-        origCol, origDuplicateCol, colIntegral, duplicateColIntegral});
+    DuplicateColumn debug_values = {
+        colScale,          colLower,          colUpper,
+        duplicateColLower, duplicateColUpper, origCol,
+        origDuplicateCol,  colIntegral,       duplicateColIntegral};
+    const bool ok_merge = debug_values.okMerge(ok_merge_tolerance);
+    const bool prevent_illegal_merge = true;
+    if (!ok_merge && prevent_illegal_merge) return false;
+    reductionValues.push(debug_values);
+    //    reductionValues.push(DuplicateColumn{
+    //        colScale, colLower, colUpper, duplicateColLower,
+    //        duplicateColUpper, origCol, origDuplicateCol, colIntegral,
+    //        duplicateColIntegral});
+
     reductionAdded(ReductionType::kDuplicateColumn);
 
     // mark columns as not linearly transformable
     linearlyTransformable[origCol] = false;
     linearlyTransformable[origDuplicateCol] = false;
+    return true;
   }
 
   std::vector<double> getReducedPrimalSolution(
@@ -530,7 +547,7 @@ class HighsPostsolveStack {
 
   /// undo presolve steps for primal dual solution and basis
   void undo(const HighsOptions& options, HighsSolution& solution,
-            HighsBasis& basis) {
+            HighsBasis& basis, const HighsInt report_col = -1) {
     reductionValues.resetPosition();
 
     // Verify that undo can be performed
@@ -539,12 +556,14 @@ class HighsPostsolveStack {
     bool perform_basis_postsolve = basis.valid;
 
     // expand solution to original index space
+    assert(origNumCol > 0);
     solution.col_value.resize(origNumCol);
     for (HighsInt i = origColIndex.size() - 1; i >= 0; --i) {
       assert(origColIndex[i] >= i);
       solution.col_value[origColIndex[i]] = solution.col_value[i];
     }
 
+    assert(origNumRow >= 0);
     solution.row_value.resize(origNumRow);
     for (HighsInt i = origRowIndex.size() - 1; i >= 0; --i) {
       assert(origRowIndex[i] >= i);
@@ -576,6 +595,10 @@ class HighsPostsolveStack {
 
     // now undo the changes
     for (HighsInt i = reductions.size() - 1; i >= 0; --i) {
+      if (report_col >= 0)
+        printf("Before  reduction %2d (type %2d): col_value[%2d] = %g\n",
+               int(i), int(reductions[i].first), int(report_col),
+               solution.col_value[report_col]);
       switch (reductions[i].first) {
         case ReductionType::kLinearTransform: {
           LinearTransform reduction;
@@ -663,20 +686,32 @@ class HighsPostsolveStack {
           DuplicateColumn reduction;
           reductionValues.pop(reduction);
           reduction.undo(options, solution, basis);
+          break;
         }
+        default:
+          printf("Reduction case %d not handled\n", int(reductions[i].first));
+          if (kAllowDeveloperAssert) assert(1 == 0);
       }
     }
+    if (report_col >= 0)
+      printf("After last reduction: col_value[%2d] = %g\n", int(report_col),
+             solution.col_value[report_col]);
   }
 
   /// undo presolve steps for primal solution
-  void undoPrimal(const HighsOptions& options, HighsSolution& solution) {
+  void undoPrimal(const HighsOptions& options, HighsSolution& solution,
+                  const HighsInt report_col = -1) {
+    // Call to reductionValues.resetPosition(); seems unnecessary as
+    // it's the first thing done in undo
     reductionValues.resetPosition();
     HighsBasis basis;
     basis.valid = false;
     solution.dual_valid = false;
-    undo(options, solution, basis);
+    undo(options, solution, basis, report_col);
   }
 
+  /*
+    // Not used
   /// undo presolve steps for primal and dual solution
   void undoPrimalDual(const HighsOptions& options, HighsSolution& solution) {
     reductionValues.resetPosition();
@@ -686,7 +721,9 @@ class HighsPostsolveStack {
     assert(solution.dual_valid);
     undo(options, solution, basis);
   }
+  */
 
+  // Only used for debugging
   void undoUntil(const HighsOptions& options,
                  const std::vector<HighsInt>& flagRow,
                  const std::vector<HighsInt>& flagCol, HighsSolution& solution,

casadi/include/highs/presolve/HighsSymmetry.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 /**@file HighsSymmetry.h
  * @brief Facilities for symmetry detection

casadi/include/highs/presolve/ICrash.h

@@ -2,7 +2,8 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2021 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
@@ -115,6 +116,6 @@ void reportOptions(const ICrashOptions& options);
 
 bool callCrossover(const HighsLp& lp, const HighsOptions& options,
                    const std::vector<double>& x_values, HighsSolution& solution,
-                   HighsBasis& basis);
+                   HighsBasis& basis, HighsCallback& callback);
 
-#endif
+#endif

casadi/include/highs/presolve/ICrashUtil.h

@@ -1,9 +1,9 @@
-
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2021 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */

casadi/include/highs/presolve/ICrashX.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 #ifndef PRESOLVE_ICRASHX_H_
 #define PRESOLVE_ICRASHX_H_
@@ -22,7 +20,7 @@
 HighsStatus callCrossover(const HighsOptions& options, const HighsLp& lp,
                           HighsBasis& highs_basis,
                           HighsSolution& highs_solution,
-                          HighsModelStatus& model_status,
-                          HighsInfo& highs_info);
+                          HighsModelStatus& model_status, HighsInfo& highs_info,
+                          HighsCallback& highs_callback);
 
 #endif

casadi/include/highs/presolve/PresolveComponent.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 /**@file PresolveComponent.h
  * @brief The HiGHS class
@@ -24,8 +22,8 @@
 #include <string>
 #include <utility>
 
-#include "HighsPostsolveStack.h"
 #include "lp_data/HighsLp.h"
+#include "presolve/HighsPostsolveStack.h"
 #include "util/HighsComponent.h"
 #include "util/HighsTimer.h"
 
@@ -35,13 +33,6 @@
 // The structure of component is general, of the presolve component - presolve
 // specific.
 
-enum class HighsPostsolveStatus {
-  kNotPresolved = -1,
-  kNoPrimalSolutionError,
-  kSolutionRecovered,
-  kBasisError
-};
-
 struct PresolveComponentData : public HighsComponentData {
   HighsLp reduced_lp_;
   presolve::HighsPostsolveStack postSolveStack;
@@ -70,29 +61,12 @@ struct PresolveComponentInfo : public HighsComponentInfo {
   HighsInt n_cols_removed = 0;
   HighsInt n_nnz_removed = 0;
 
-  double init_time = 0;
   double presolve_time = 0;
-  double solve_time = 0;
   double postsolve_time = 0;
-  double cleanup_time = 0;
 
   virtual ~PresolveComponentInfo() = default;
 };
 
-// HighsComponentOptions is a placeholder for options specific to this component
-struct PresolveComponentOptions : public HighsComponentOptions {
-  bool is_valid = false;
-  // presolve options later when needed.
-
-  std::string iteration_strategy = "smart";
-  HighsInt max_iterations = 0;
-
-  double time_limit = -1;
-  bool dev = false;
-
-  virtual ~PresolveComponentOptions() = default;
-};
-
 class PresolveComponent : public HighsComponent {
  public:
   void clear() override;
@@ -104,13 +78,7 @@ class PresolveComponent : public HighsComponent {
   HighsLp& getReducedProblem() { return data_.reduced_lp_; }
   HighsPresolveLog& getPresolveLog() { return data_.presolve_log_; }
 
-  HighsStatus setOptions(const HighsOptions& options);
-  std::string presolveStatusToString(const HighsPresolveStatus presolve_status);
-
-  void negateReducedLpColDuals(bool reduced);
-  void negateReducedLpCost();
-
-  //  bool has_run_ = false;
+  void negateReducedLpColDuals();
 
   PresolveComponentInfo info_;
   PresolveComponentData data_;
@@ -122,10 +90,4 @@ class PresolveComponent : public HighsComponent {
 
   virtual ~PresolveComponent() = default;
 };
-
-namespace presolve {
-
-bool checkOptions(const PresolveComponentOptions& options);
-}
-
 #endif