casadi 3.6.4__cp312-none-macosx_10_13_x86_64.macosx_10_13_intel.whl

casadi/include/include/highs/mip/HighsPseudocost.h

@@ -0,0 +1,351 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#ifndef HIGHS_PSEUDOCOST_H_
+#define HIGHS_PSEUDOCOST_H_
+
+#include <algorithm>
+#include <cassert>
+#include <cmath>
+#include <limits>
+#include <vector>
+
+#include "util/HighsInt.h"
+
+class HighsMipSolver;
+namespace presolve {
+class HighsPostsolveStack;
+}
+
+class HighsPseudocost;
+
+struct HighsPseudocostInitialization {
+  std::vector<double> pseudocostup;
+  std::vector<double> pseudocostdown;
+  std::vector<HighsInt> nsamplesup;
+  std::vector<HighsInt> nsamplesdown;
+  std::vector<double> inferencesup;
+  std::vector<double> inferencesdown;
+  std::vector<HighsInt> ninferencesup;
+  std::vector<HighsInt> ninferencesdown;
+  std::vector<double> conflictscoreup;
+  std::vector<double> conflictscoredown;
+  double cost_total;
+  double inferences_total;
+  double conflict_avg_score;
+  int64_t nsamplestotal;
+  int64_t ninferencestotal;
+
+  HighsPseudocostInitialization(const HighsPseudocost& pscost,
+                                HighsInt maxCount);
+  HighsPseudocostInitialization(
+      const HighsPseudocost& pscost, HighsInt maxCount,
+      const presolve::HighsPostsolveStack& postsolveStack);
+};
+class HighsPseudocost {
+  friend struct HighsPseudocostInitialization;
+  std::vector<double> pseudocostup;
+  std::vector<double> pseudocostdown;
+  std::vector<HighsInt> nsamplesup;
+  std::vector<HighsInt> nsamplesdown;
+  std::vector<double> inferencesup;
+  std::vector<double> inferencesdown;
+  std::vector<HighsInt> ninferencesup;
+  std::vector<HighsInt> ninferencesdown;
+  std::vector<HighsInt> ncutoffsup;
+  std::vector<HighsInt> ncutoffsdown;
+  std::vector<double> conflictscoreup;
+  std::vector<double> conflictscoredown;
+
+  double conflict_weight;
+  double conflict_avg_score;
+  double cost_total;
+  double inferences_total;
+  int64_t nsamplestotal;
+  int64_t ninferencestotal;
+  int64_t ncutoffstotal;
+  HighsInt minreliable;
+  double degeneracyFactor;
+
+ public:
+  HighsPseudocost() = default;
+  HighsPseudocost(const HighsMipSolver& mipsolver);
+
+  void subtractBase(const HighsPseudocost& base) {
+    HighsInt ncols = pseudocostup.size();
+
+    for (HighsInt i = 0; i != ncols; ++i) {
+      pseudocostup[i] -= base.pseudocostup[i];
+      pseudocostdown[i] -= base.pseudocostdown[i];
+      nsamplesup[i] -= base.nsamplesup[i];
+      nsamplesdown[i] -= base.nsamplesdown[i];
+    }
+  }
+
+  void increaseConflictWeight() {
+    conflict_weight *= 1.02;
+
+    if (conflict_weight > 1000.0) {
+      double scale = 1.0 / conflict_weight;
+      conflict_weight = 1.0;
+      conflict_avg_score *= scale;
+
+      HighsInt numCol = conflictscoreup.size();
+      for (HighsInt i = 0; i < numCol; ++i) {
+        conflictscoreup[i] *= scale;
+        conflictscoredown[i] *= scale;
+      }
+    }
+  }
+
+  void setDegeneracyFactor(double degeneracyFactor) {
+    assert(degeneracyFactor >= 1.0);
+    this->degeneracyFactor = degeneracyFactor;
+  }
+
+  void increaseConflictScoreUp(HighsInt col) {
+    conflictscoreup[col] += conflict_weight;
+    conflict_avg_score += conflict_weight;
+  }
+
+  void increaseConflictScoreDown(HighsInt col) {
+    conflictscoredown[col] += conflict_weight;
+    conflict_avg_score += conflict_weight;
+  }
+
+  void setMinReliable(HighsInt minreliable) { this->minreliable = minreliable; }
+
+  HighsInt getMinReliable() const { return minreliable; }
+
+  HighsInt getNumObservations(HighsInt col) const {
+    return nsamplesup[col] + nsamplesdown[col];
+  }
+
+  HighsInt getNumObservationsUp(HighsInt col) const { return nsamplesup[col]; }
+
+  HighsInt getNumObservationsDown(HighsInt col) const {
+    return nsamplesdown[col];
+  }
+
+  void addCutoffObservation(HighsInt col, bool upbranch) {
+    ++ncutoffstotal;
+    if (upbranch)
+      ncutoffsup[col] += 1;
+    else
+      ncutoffsdown[col] += 1;
+  }
+
+  void addObservation(HighsInt col, double delta, double objdelta) {
+    assert(delta != 0.0);
+    assert(objdelta >= 0.0);
+    if (delta > 0.0) {
+      double unit_gain = objdelta / delta;
+      double d = unit_gain - pseudocostup[col];
+      nsamplesup[col] += 1;
+      pseudocostup[col] += d / nsamplesup[col];
+
+      d = unit_gain - cost_total;
+      ++nsamplestotal;
+      cost_total += d / nsamplestotal;
+    } else {
+      double unit_gain = -objdelta / delta;
+      double d = unit_gain - pseudocostdown[col];
+      nsamplesdown[col] += 1;
+      pseudocostdown[col] += d / nsamplesdown[col];
+
+      d = unit_gain - cost_total;
+      ++nsamplestotal;
+      cost_total += d / nsamplestotal;
+    }
+  }
+
+  void addInferenceObservation(HighsInt col, HighsInt ninferences,
+                               bool upbranch) {
+    double d = ninferences - inferences_total;
+    ++ninferencestotal;
+    inferences_total += d / ninferencestotal;
+    if (upbranch) {
+      d = ninferences - inferencesup[col];
+      ninferencesup[col] += 1;
+      inferencesup[col] += d / ninferencesup[col];
+    } else {
+      d = ninferences - inferencesdown[col];
+      ninferencesdown[col] += 1;
+      inferencesdown[col] += d / ninferencesdown[col];
+    }
+  }
+
+  bool isReliable(HighsInt col) const {
+    return std::min(nsamplesup[col], nsamplesdown[col]) >= minreliable;
+  }
+
+  bool isReliableUp(HighsInt col) const {
+    return nsamplesup[col] >= minreliable;
+  }
+
+  bool isReliableDown(HighsInt col) const {
+    return nsamplesdown[col] >= minreliable;
+  }
+
+  double getAvgPseudocost() const { return cost_total; }
+
+  double getPseudocostUp(HighsInt col, double frac, double offset) const {
+    double up = std::ceil(frac) - frac;
+    double cost;
+
+    if (nsamplesup[col] == 0 || nsamplesup[col] < minreliable) {
+      double weightPs = nsamplesup[col] == 0
+                            ? 0
+                            : 0.9 + 0.1 * nsamplesup[col] / (double)minreliable;
+      cost = weightPs * pseudocostup[col];
+      cost += (1.0 - weightPs) * getAvgPseudocost();
+    } else
+      cost = pseudocostup[col];
+    return up * (offset + cost);
+  }
+
+  double getPseudocostDown(HighsInt col, double frac, double offset) const {
+    double down = frac - std::floor(frac);
+    double cost;
+
+    if (nsamplesdown[col] == 0 || nsamplesdown[col] < minreliable) {
+      double weightPs = nsamplesdown[col] == 0 ? 0
+                                               : 0.9 + 0.1 * nsamplesdown[col] /
+                                                           (double)minreliable;
+      cost = weightPs * pseudocostdown[col];
+      cost += (1.0 - weightPs) * getAvgPseudocost();
+    } else
+      cost = pseudocostdown[col];
+
+    return down * (offset + cost);
+  }
+
+  double getPseudocostUp(HighsInt col, double frac) const {
+    double up = std::ceil(frac) - frac;
+    if (nsamplesup[col] == 0) return up * cost_total;
+    return up * pseudocostup[col];
+  }
+
+  double getPseudocostDown(HighsInt col, double frac) const {
+    double down = frac - std::floor(frac);
+    if (nsamplesdown[col] == 0) return down * cost_total;
+    return down * pseudocostdown[col];
+  }
+
+  double getConflictScoreUp(HighsInt col) const {
+    return conflictscoreup[col] / conflict_weight;
+  }
+
+  double getConflictScoreDown(HighsInt col) const {
+    return conflictscoredown[col] / conflict_weight;
+  }
+
+  double getScore(HighsInt col, double upcost, double downcost) const {
+    double costScore = std::max(upcost, 1e-6) * std::max(downcost, 1e-6) /
+                       std::max(1e-6, cost_total * cost_total);
+    double inferenceScore = std::max(inferencesup[col], 1e-6) *
+                            std::max(inferencesdown[col], 1e-6) /
+                            std::max(1e-6, inferences_total * inferences_total);
+
+    double cutOffScoreUp =
+        ncutoffsup[col] /
+        std::max(1.0, double(ncutoffsup[col] + nsamplesup[col]));
+    double cutOffScoreDown =
+        ncutoffsdown[col] /
+        std::max(1.0, double(ncutoffsdown[col] + nsamplesdown[col]));
+    double avgCutoffs =
+        ncutoffstotal / std::max(1.0, double(ncutoffstotal + nsamplestotal));
+
+    double cutoffScore = std::max(cutOffScoreUp, 1e-6) *
+                         std::max(cutOffScoreDown, 1e-6) /
+                         std::max(1e-6, avgCutoffs * avgCutoffs);
+
+    double conflictScoreUp = conflictscoreup[col] / conflict_weight;
+    double conflictScoreDown = conflictscoredown[col] / conflict_weight;
+    double conflictScoreAvg =
+        conflict_avg_score / (conflict_weight * conflictscoreup.size());
+    double conflictScore = std::max(conflictScoreUp, 1e-6) *
+                           std::max(conflictScoreDown, 1e-6) /
+                           std::max(1e-6, conflictScoreAvg * conflictScoreAvg);
+
+    auto mapScore = [](double score) { return 1.0 - 1.0 / (1.0 + score); };
+    return mapScore(costScore) / degeneracyFactor +
+           degeneracyFactor *
+               (1e-2 * mapScore(conflictScore) +
+                1e-4 * (mapScore(cutoffScore) + mapScore(inferenceScore)));
+  }
+
+  double getScore(HighsInt col, double frac) const {
+    double upcost = getPseudocostUp(col, frac);
+    double downcost = getPseudocostDown(col, frac);
+
+    return getScore(col, upcost, downcost);
+  }
+
+  double getScoreUp(HighsInt col, double frac) const {
+    double costScore = getPseudocostUp(col, frac) / std::max(1e-6, cost_total);
+    double inferenceScore =
+        inferencesup[col] / std::max(1e-6, inferences_total);
+
+    double cutOffScoreUp =
+        ncutoffsup[col] /
+        std::max(1.0, double(ncutoffsup[col] + nsamplesup[col]));
+    double avgCutoffs =
+        ncutoffstotal / std::max(1.0, double(ncutoffstotal + nsamplestotal));
+
+    double cutoffScore = cutOffScoreUp / std::max(1e-6, avgCutoffs);
+
+    double conflictScoreUp = conflictscoreup[col] / conflict_weight;
+    double conflictScoreAvg =
+        conflict_avg_score / (conflict_weight * conflictscoreup.size());
+    double conflictScore = conflictScoreUp / std::max(1e-6, conflictScoreAvg);
+
+    auto mapScore = [](double score) { return 1.0 - 1.0 / (1.0 + score); };
+
+    return mapScore(costScore) +
+           (1e-2 * mapScore(conflictScore) +
+            1e-4 * (mapScore(cutoffScore) + mapScore(inferenceScore)));
+  }
+
+  double getScoreDown(HighsInt col, double frac) const {
+    double costScore =
+        getPseudocostDown(col, frac) / std::max(1e-6, cost_total);
+    double inferenceScore =
+        inferencesdown[col] / std::max(1e-6, inferences_total);
+
+    double cutOffScoreDown =
+        ncutoffsdown[col] /
+        std::max(1.0, double(ncutoffsdown[col] + nsamplesdown[col]));
+    double avgCutoffs =
+        ncutoffstotal / std::max(1.0, double(ncutoffstotal + nsamplestotal));
+
+    double cutoffScore = cutOffScoreDown / std::max(1e-6, avgCutoffs);
+
+    double conflictScoreDown = conflictscoredown[col] / conflict_weight;
+    double conflictScoreAvg =
+        conflict_avg_score / (conflict_weight * conflictscoredown.size());
+    double conflictScore = conflictScoreDown / std::max(1e-6, conflictScoreAvg);
+
+    auto mapScore = [](double score) { return 1.0 - 1.0 / (1.0 + score); };
+
+    return mapScore(costScore) +
+           (1e-2 * mapScore(conflictScore) +
+            1e-4 * (mapScore(cutoffScore) + mapScore(inferenceScore)));
+  }
+
+  double getAvgInferencesUp(HighsInt col) const { return inferencesup[col]; }
+
+  double getAvgInferencesDown(HighsInt col) const {
+    return inferencesdown[col];
+  }
+};
+
+#endif

casadi/include/include/highs/mip/HighsRedcostFixing.h

@@ -0,0 +1,45 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/**@file mip/HighsRedcostFixing.h
+ * @brief reduced cost fixing using the current cutoff bound
+ */
+
+#ifndef HIGHS_REDCOST_FIXING_H_
+#define HIGHS_REDCOST_FIXING_H_
+
+#include <map>
+#include <vector>
+
+#include "mip/HighsDomainChange.h"
+
+class HighsDomain;
+class HighsMipSolver;
+class HighsLpRelaxation;
+
+class HighsRedcostFixing {
+  std::vector<std::multimap<double, int>> lurkingColUpper;
+  std::vector<std::multimap<double, int>> lurkingColLower;
+
+ public:
+  std::vector<std::pair<double, HighsDomainChange>> getLurkingBounds(
+      const HighsMipSolver& mipsolver) const;
+
+  void propagateRootRedcost(const HighsMipSolver& mipsolver);
+
+  static void propagateRedCost(const HighsMipSolver& mipsolver,
+                               HighsDomain& localdomain,
+                               const HighsLpRelaxation& lp);
+
+  void addRootRedcost(const HighsMipSolver& mipsolver,
+                      const std::vector<double>& lpredcost, double lpobjective);
+};
+
+#endif

casadi/include/include/highs/mip/HighsSearch.h

@@ -0,0 +1,243 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+#ifndef HIGHS_SEARCH_H_
+#define HIGHS_SEARCH_H_
+
+#include <cstdint>
+#include <queue>
+#include <vector>
+
+#include "mip/HighsConflictPool.h"
+#include "mip/HighsDomain.h"
+#include "mip/HighsLpRelaxation.h"
+#include "mip/HighsMipSolver.h"
+#include "mip/HighsNodeQueue.h"
+#include "mip/HighsPseudocost.h"
+#include "mip/HighsSeparation.h"
+#include "presolve/HighsSymmetry.h"
+#include "util/HighsHash.h"
+
+class HighsMipSolver;
+class HighsImplications;
+class HighsCliqueTable;
+
+class HighsSearch {
+  HighsMipSolver& mipsolver;
+  HighsLpRelaxation* lp;
+  HighsDomain localdom;
+  HighsPseudocost& pseudocost;
+  HighsRandom random;
+  int64_t nnodes;
+  int64_t lpiterations;
+  int64_t heurlpiterations;
+  int64_t sblpiterations;
+  double upper_limit;
+  HighsCDouble treeweight;
+  std::vector<HighsInt> inds;
+  std::vector<double> vals;
+  HighsInt depthoffset;
+  bool inbranching;
+  bool inheuristic;
+  bool countTreeWeight;
+
+ public:
+  enum class ChildSelectionRule {
+    kUp,
+    kDown,
+    kRootSol,
+    kObj,
+    kRandom,
+    kBestCost,
+    kWorstCost,
+    kDisjunction,
+    kHybridInferenceCost,
+  };
+
+  enum class NodeResult {
+    kBoundExceeding,
+    kDomainInfeasible,
+    kLpInfeasible,
+    kBranched,
+    kSubOptimal,
+    kOpen,
+  };
+
+ private:
+  ChildSelectionRule childselrule;
+
+  struct NodeData {
+    double lower_bound;
+    double estimate;
+    double branching_point;
+    // we store the lp objective separately to the lower bound since the lower
+    // bound could be above the LP objective when cuts age out or below when the
+    // LP is unscaled dual infeasible and it is not set. We still want to use
+    // the objective for pseudocost updates and tiebreaking of best bound node
+    // selection
+    double lp_objective;
+    double other_child_lb;
+    std::shared_ptr<const HighsBasis> nodeBasis;
+    std::shared_ptr<const StabilizerOrbits> stabilizerOrbits;
+    HighsDomainChange branchingdecision;
+    HighsInt domgchgStackPos;
+    uint8_t skipDepthCount;
+    uint8_t opensubtrees;
+
+    NodeData(double parentlb = -kHighsInf, double parentestimate = -kHighsInf,
+             std::shared_ptr<const HighsBasis> parentBasis = nullptr,
+             std::shared_ptr<const StabilizerOrbits> stabilizerOrbits = nullptr)
+        : lower_bound(parentlb),
+          estimate(parentestimate),
+          lp_objective(-kHighsInf),
+          other_child_lb(parentlb),
+          nodeBasis(std::move(parentBasis)),
+          stabilizerOrbits(std::move(stabilizerOrbits)),
+          branchingdecision{0.0, -1, HighsBoundType::kLower},
+          domgchgStackPos(-1),
+          skipDepthCount(0),
+          opensubtrees(2) {}
+  };
+
+  enum ReliableFlags {
+    kUpReliable = 1,
+    kDownReliable = 2,
+    kReliable = kDownReliable | kUpReliable,
+  };
+
+  std::vector<double> subrootsol;
+  std::vector<NodeData> nodestack;
+  HighsHashTable<HighsInt, int> reliableatnode;
+
+  int branchingVarReliableAtNodeFlags(HighsInt col) const {
+    auto it = reliableatnode.find(col);
+    if (it == nullptr) return 0;
+    return *it;
+  }
+
+  bool branchingVarReliableAtNode(HighsInt col) const {
+    auto it = reliableatnode.find(col);
+    if (it == nullptr || *it != kReliable) return false;
+
+    return true;
+  }
+
+  void markBranchingVarUpReliableAtNode(HighsInt col) {
+    reliableatnode[col] |= kUpReliable;
+  }
+
+  void markBranchingVarDownReliableAtNode(HighsInt col) {
+    reliableatnode[col] |= kDownReliable;
+  }
+
+  bool orbitsValidInChildNode(const HighsDomainChange& branchChg) const;
+
+ public:
+  HighsSearch(HighsMipSolver& mipsolver, HighsPseudocost& pseudocost);
+
+  void setRINSNeighbourhood(const std::vector<double>& basesol,
+                            const std::vector<double>& relaxsol);
+
+  void setRENSNeighbourhood(const std::vector<double>& lpsol);
+
+  double getCutoffBound() const;
+
+  void setLpRelaxation(HighsLpRelaxation* lp) { this->lp = lp; }
+
+  double checkSol(const std::vector<double>& sol, bool& integerfeasible) const;
+
+  void createNewNode();
+
+  void cutoffNode();
+
+  void branchDownwards(HighsInt col, double newub, double branchpoint);
+
+  void branchUpwards(HighsInt col, double newlb, double branchpoint);
+
+  void setMinReliable(HighsInt minreliable);
+
+  void setHeuristic(bool inheuristic) {
+    this->inheuristic = inheuristic;
+    if (inheuristic) childselrule = ChildSelectionRule::kHybridInferenceCost;
+  }
+
+  void addBoundExceedingConflict();
+
+  void resetLocalDomain();
+
+  int64_t getHeuristicLpIterations() const;
+
+  int64_t getTotalLpIterations() const;
+
+  int64_t getLocalLpIterations() const;
+
+  int64_t getLocalNodes() const;
+
+  int64_t getStrongBranchingLpIterations() const;
+
+  bool hasNode() const { return !nodestack.empty(); }
+
+  bool currentNodePruned() const { return nodestack.back().opensubtrees == 0; }
+
+  double getCurrentEstimate() const { return nodestack.back().estimate; }
+
+  double getCurrentLowerBound() const { return nodestack.back().lower_bound; }
+
+  HighsInt getCurrentDepth() const { return nodestack.size() + depthoffset; }
+
+  void openNodesToQueue(HighsNodeQueue& nodequeue);
+
+  void currentNodeToQueue(HighsNodeQueue& nodequeue);
+
+  void flushStatistics();
+
+  void installNode(HighsNodeQueue::OpenNode&& node);
+
+  void addInfeasibleConflict();
+
+  HighsInt selectBranchingCandidate(int64_t maxSbIters, double& downNodeLb,
+                                    double& upNodeLb);
+
+  void evalUnreliableBranchCands();
+
+  const NodeData* getParentNodeData() const;
+
+  NodeResult evaluateNode();
+
+  NodeResult branch();
+
+  /// backtrack one level in DFS manner
+  bool backtrack(bool recoverBasis = true);
+
+  /// backtrack an unspecified amount of depth level until the next
+  /// node that seems worthwhile to continue the plunge. Put unpromising nodes
+  /// to the node queue
+  bool backtrackPlunge(HighsNodeQueue& nodequeue);
+
+  /// for heuristics. Will discard nodes above targetDepth regardless of their
+  /// status
+  bool backtrackUntilDepth(HighsInt targetDepth);
+
+  void printDisplayLine(char first, bool header = false);
+
+  NodeResult dive();
+
+  HighsDomain& getLocalDomain() { return localdom; }
+
+  const HighsDomain& getLocalDomain() const { return localdom; }
+
+  HighsPseudocost& getPseudoCost() { return pseudocost; }
+
+  const HighsPseudocost& getPseudoCost() const { return pseudocost; }
+
+  void solveDepthFirst(int64_t maxbacktracks = 1);
+};
+
+#endif

casadi/include/include/highs/mip/HighsSeparation.h

@@ -0,0 +1,44 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+#ifndef HIGHS_SEPARATION_H_
+#define HIGHS_SEPARATION_H_
+
+#include <cstdint>
+#include <vector>
+
+#include "mip/HighsCutPool.h"
+#include "mip/HighsLpRelaxation.h"
+#include "mip/HighsSeparator.h"
+
+class HighsMipSolver;
+class HighsImplications;
+class HighsCliqueTable;
+
+class HighsSeparation {
+ public:
+  HighsInt separationRound(HighsDomain& propdomain,
+                           HighsLpRelaxation::Status& status);
+
+  void separate(HighsDomain& propdomain);
+
+  void setLpRelaxation(HighsLpRelaxation* lp) { this->lp = lp; }
+
+  HighsSeparation(const HighsMipSolver& mipsolver);
+
+ private:
+  HighsInt implBoundClock;
+  HighsInt cliqueClock;
+  std::vector<std::unique_ptr<HighsSeparator>> separators;
+  HighsCutSet cutset;
+  HighsLpRelaxation* lp;
+};
+
+#endif