casadi 3.6.7__cp313-none-macosx_10_13_x86_64.macosx_10_13_intel.whl

casadi/include/highs/mip/HighsMipSolverData.h

@@ -0,0 +1,236 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#ifndef HIGHS_MIP_SOLVER_DATA_H_
+#define HIGHS_MIP_SOLVER_DATA_H_
+
+#include <vector>
+
+#include "mip/HighsCliqueTable.h"
+#include "mip/HighsConflictPool.h"
+#include "mip/HighsCutPool.h"
+#include "mip/HighsDebugSol.h"
+#include "mip/HighsDomain.h"
+#include "mip/HighsImplications.h"
+#include "mip/HighsLpRelaxation.h"
+#include "mip/HighsNodeQueue.h"
+#include "mip/HighsObjectiveFunction.h"
+#include "mip/HighsPrimalHeuristics.h"
+#include "mip/HighsPseudocost.h"
+#include "mip/HighsRedcostFixing.h"
+#include "mip/HighsSearch.h"
+#include "mip/HighsSeparation.h"
+#include "parallel/HighsParallel.h"
+#include "presolve/HighsPostsolveStack.h"
+#include "presolve/HighsSymmetry.h"
+#include "util/HighsTimer.h"
+
+struct HighsMipSolverData {
+  HighsMipSolver& mipsolver;
+  HighsCutPool cutpool;
+  HighsConflictPool conflictPool;
+  HighsDomain domain;
+  HighsLpRelaxation lp;
+  HighsPseudocost pseudocost;
+  HighsCliqueTable cliquetable;
+  HighsImplications implications;
+  HighsPrimalHeuristics heuristics;
+  HighsRedcostFixing redcostfixing;
+  HighsObjectiveFunction objectiveFunction;
+  presolve::HighsPostsolveStack postSolveStack;
+  HighsPresolveStatus presolve_status;
+  HighsLp presolvedModel;
+  bool cliquesExtracted;
+  bool rowMatrixSet;
+  bool analyticCenterComputed;
+  HighsModelStatus analyticCenterStatus;
+  bool detectSymmetries;
+  HighsInt numRestarts;
+  HighsInt numRestartsRoot;
+  HighsInt numCliqueEntriesAfterPresolve;
+  HighsInt numCliqueEntriesAfterFirstPresolve;
+
+  std::vector<HighsInt> ARstart_;
+  std::vector<HighsInt> ARindex_;
+  std::vector<double> ARvalue_;
+  std::vector<double> maxAbsRowCoef;
+  std::vector<uint8_t> rowintegral;
+  std::vector<HighsInt> uplocks;
+  std::vector<HighsInt> downlocks;
+  std::vector<HighsInt> integer_cols;
+  std::vector<HighsInt> implint_cols;
+  std::vector<HighsInt> integral_cols;
+  std::vector<HighsInt> continuous_cols;
+
+  HighsSymmetries symmetries;
+  std::shared_ptr<const StabilizerOrbits> globalOrbits;
+
+  double feastol;
+  double epsilon;
+  double heuristic_effort;
+  int64_t dispfreq;
+  std::vector<double> analyticCenter;
+  std::vector<double> firstlpsol;
+  std::vector<double> rootlpsol;
+  double firstlpsolobj;
+  HighsBasis firstrootbasis;
+  double rootlpsolobj;
+  HighsInt numintegercols;
+  HighsInt maxTreeSizeLog2;
+
+  HighsCDouble pruned_treeweight;
+  double avgrootlpiters;
+  double last_disptime;
+  int64_t firstrootlpiters;
+  int64_t num_nodes;
+  int64_t num_leaves;
+  int64_t num_leaves_before_run;
+  int64_t num_nodes_before_run;
+  int64_t total_lp_iterations;
+  int64_t heuristic_lp_iterations;
+  int64_t sepa_lp_iterations;
+  int64_t sb_lp_iterations;
+  int64_t total_lp_iterations_before_run;
+  int64_t heuristic_lp_iterations_before_run;
+  int64_t sepa_lp_iterations_before_run;
+  int64_t sb_lp_iterations_before_run;
+  int64_t num_disp_lines;
+
+  HighsInt numImprovingSols;
+  double lower_bound;
+  double upper_bound;
+  double upper_limit;
+  double optimality_limit;
+  std::vector<double> incumbent;
+
+  HighsNodeQueue nodequeue;
+
+  HighsDebugSol debugSolution;
+
+  HighsMipSolverData(HighsMipSolver& mipsolver)
+      : mipsolver(mipsolver),
+        cutpool(mipsolver.numCol(), mipsolver.options_mip_->mip_pool_age_limit,
+                mipsolver.options_mip_->mip_pool_soft_limit),
+        conflictPool(5 * mipsolver.options_mip_->mip_pool_age_limit,
+                     mipsolver.options_mip_->mip_pool_soft_limit),
+        domain(mipsolver),
+        lp(mipsolver),
+        pseudocost(),
+        cliquetable(mipsolver.numCol()),
+        implications(mipsolver),
+        heuristics(mipsolver),
+        objectiveFunction(mipsolver),
+        presolve_status(HighsPresolveStatus::kNotSet),
+        cliquesExtracted(false),
+        rowMatrixSet(false),
+        analyticCenterComputed(false),
+        analyticCenterStatus(HighsModelStatus::kNotset),
+        detectSymmetries(false),
+        numRestarts(0),
+        numRestartsRoot(0),
+        numCliqueEntriesAfterPresolve(0),
+        numCliqueEntriesAfterFirstPresolve(0),
+        feastol(0.0),
+        epsilon(0.0),
+        heuristic_effort(0.0),
+        dispfreq(0),
+        firstlpsolobj(-kHighsInf),
+        rootlpsolobj(-kHighsInf),
+        numintegercols(0),
+        maxTreeSizeLog2(0),
+        pruned_treeweight(0),
+        avgrootlpiters(0.0),
+        last_disptime(0.0),
+        firstrootlpiters(0),
+        num_nodes(0),
+        num_leaves(0),
+        num_leaves_before_run(0),
+        num_nodes_before_run(0),
+        total_lp_iterations(0),
+        heuristic_lp_iterations(0),
+        sepa_lp_iterations(0),
+        sb_lp_iterations(0),
+        total_lp_iterations_before_run(0),
+        heuristic_lp_iterations_before_run(0),
+        sepa_lp_iterations_before_run(0),
+        sb_lp_iterations_before_run(0),
+        num_disp_lines(0),
+        numImprovingSols(0),
+        lower_bound(-kHighsInf),
+        upper_bound(kHighsInf),
+        upper_limit(kHighsInf),
+        optimality_limit(kHighsInf),
+        debugSolution(mipsolver) {
+    domain.addCutpool(cutpool);
+    domain.addConflictPool(conflictPool);
+  }
+
+  void startAnalyticCenterComputation(
+      const highs::parallel::TaskGroup& taskGroup);
+  void finishAnalyticCenterComputation(
+      const highs::parallel::TaskGroup& taskGroup);
+
+  struct SymmetryDetectionData {
+    HighsSymmetryDetection symDetection;
+    HighsSymmetries symmetries;
+    double detectionTime = 0.0;
+  };
+
+  void startSymmetryDetection(const highs::parallel::TaskGroup& taskGroup,
+                              std::unique_ptr<SymmetryDetectionData>& symData);
+  void finishSymmetryDetection(const highs::parallel::TaskGroup& taskGroup,
+                               std::unique_ptr<SymmetryDetectionData>& symData);
+
+  double computeNewUpperLimit(double upper_bound, double mip_abs_gap,
+                              double mip_rel_gap) const;
+  bool moreHeuristicsAllowed() const;
+  void removeFixedIndices();
+  void init();
+  void basisTransfer();
+  void checkObjIntegrality();
+  void runPresolve(const HighsInt presolve_reduction_limit);
+  void setupDomainPropagation();
+  void saveReportMipSolution(const double new_upper_limit = -kHighsInf);
+  void runSetup();
+  double transformNewIntegerFeasibleSolution(
+      const std::vector<double>& sol,
+      const bool possibly_store_as_new_incumbent = true);
+  double percentageInactiveIntegers() const;
+  void performRestart();
+  bool checkSolution(const std::vector<double>& solution) const;
+  bool trySolution(const std::vector<double>& solution, char source = ' ');
+  bool rootSeparationRound(HighsSeparation& sepa, HighsInt& ncuts,
+                           HighsLpRelaxation::Status& status);
+  HighsLpRelaxation::Status evaluateRootLp();
+  void evaluateRootNode();
+  bool addIncumbent(const std::vector<double>& sol, double solobj, char source);
+
+  const std::vector<double>& getSolution() const;
+
+  void printDisplayLine(char first = ' ');
+
+  void getRow(HighsInt row, HighsInt& rowlen, const HighsInt*& rowinds,
+              const double*& rowvals) const {
+    HighsInt start = ARstart_[row];
+    rowlen = ARstart_[row + 1] - start;
+    rowinds = ARindex_.data() + start;
+    rowvals = ARvalue_.data() + start;
+  }
+
+  bool checkLimits(int64_t nodeOffset = 0) const;
+  void limitsToBounds(double& dual_bound, double& primal_bound,
+                      double& mip_rel_gap) const;
+  bool interruptFromCallbackWithData(const int callback_type,
+                                     const double mipsolver_objective_value,
+                                     const std::string message = "") const;
+};
+
+#endif

casadi/include/highs/mip/HighsModkSeparator.h

@@ -0,0 +1,63 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/**@file mip/HighsModkSeparator.h
+ * @brief Class for separating maximally violated mod-k MIR cuts.
+ *
+ * Contrary to mod-k CG cuts as described in the literature, continuous
+ * variables are allowed to appear in the rows used for separation. In case an
+ * LP row is already an integral row it is included into the congruence system
+ * in the same way as for mod-k CG cuts. Should the LP row contain continuous
+ * variables that have a non-zero solution value after bound substitution, then
+ * it is discarded, as it can not participate in a maximally violated mod-K MIR
+ * cut.
+ *
+ * If a row contains continuous variables that sit at zero after bound
+ * substitution, then those rows are included in the congruence system, as the
+ * presence of such variables does not reduce the cuts violation when applying
+ * the MIR procedure. In order to handle their presence the row must simply be
+ * scaled, such that all integer variables that have a non-zero solution value
+ * after bound substitution, as well as the right hand side value, attain an
+ * integral value. If we succeed in finding such a scale that is not too large,
+ * the resulting row might get a non-zero weight in the solution of the
+ * congruence system. The aggregated row therefore can contain continuous
+ * variables. These variables, however, all sit at zero in the current LP
+ * solution. Using the weights from the solution of the congruence system all
+ * integer variables with non-zero solution value will attain a coefficient that
+ * is divisible by k, and the integral right hand side value will have a
+ * remainder of k - 1 when dividing by k. All other variables do not contribute
+ * to the activity of the cut in this LP solution, hence applying the MIR
+ * procedure will yield a cut that is violated by (k-1)/k. However, we prefer to
+ * generate inequalities with superadditive lifting from the aggregated row
+ * whenever all integer variables are bounded.
+ *
+ */
+
+#ifndef MIP_HIGHS_MODK_SEPARATOR_H_
+#define MIP_HIGHS_MODK_SEPARATOR_H_
+
+#include <vector>
+
+#include "mip/HighsSeparator.h"
+
+/// Helper class to compute single-row relaxations from the current LP
+/// relaxation by substituting bounds and aggregating rows
+class HighsModkSeparator : public HighsSeparator {
+ public:
+  void separateLpSolution(HighsLpRelaxation& lpRelaxation,
+                          HighsLpAggregator& lpAggregator,
+                          HighsTransformedLp& transLp,
+                          HighsCutPool& cutpool) override;
+
+  HighsModkSeparator(const HighsMipSolver& mipsolver)
+      : HighsSeparator(mipsolver, "Mod-k sepa", "Mod") {}
+};
+
+#endif

casadi/include/highs/mip/HighsNodeQueue.h

@@ -0,0 +1,314 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#ifndef HIGHS_NODE_QUEUE_H_
+#define HIGHS_NODE_QUEUE_H_
+
+#include <cassert>
+#include <cstddef>
+#include <memory>
+#include <queue>
+#include <set>
+#include <vector>
+
+#include "lp_data/HConst.h"
+#include "mip/HighsDomainChange.h"
+#include "util/HighsCDouble.h"
+#include "util/HighsRbTree.h"
+
+class HighsDomain;
+class HighsLpRelaxation;
+
+class HighsNodeQueue {
+ public:
+  template <int S>
+  struct ChunkWithSize {
+    ChunkWithSize* next;
+    typename std::aligned_storage<S, alignof(std::max_align_t)>::type storage;
+  };
+
+  using Chunk =
+      ChunkWithSize<4096 - offsetof(ChunkWithSize<sizeof(void*)>, storage)>;
+
+  struct AllocatorState {
+    void* freeListHead = nullptr;
+    char* currChunkStart = nullptr;
+    char* currChunkEnd = nullptr;
+    Chunk* chunkListHead = nullptr;
+
+    AllocatorState() = default;
+    AllocatorState(const AllocatorState&) = delete;
+    AllocatorState(AllocatorState&& other)
+        : freeListHead(other.freeListHead),
+          currChunkStart(other.currChunkStart),
+          currChunkEnd(other.currChunkEnd),
+          chunkListHead(other.chunkListHead) {
+      other.chunkListHead = nullptr;
+    }
+
+    AllocatorState& operator=(const AllocatorState&) = delete;
+
+    AllocatorState& operator=(AllocatorState&& other) {
+      freeListHead = other.freeListHead;
+      currChunkStart = other.currChunkStart;
+      currChunkEnd = other.currChunkEnd;
+      chunkListHead = other.chunkListHead;
+
+      other.chunkListHead = nullptr;
+      return *this;
+    }
+
+    ~AllocatorState() {
+      while (chunkListHead) {
+        Chunk* delChunk = chunkListHead;
+        chunkListHead = delChunk->next;
+        delete delChunk;
+      }
+    }
+  };
+
+  template <typename T>
+  class NodesetAllocator {
+    union FreelistNode {
+      FreelistNode* next;
+      typename std::aligned_storage<sizeof(T), alignof(T)>::type storage;
+    };
+
+   public:
+    AllocatorState* state;
+    using value_type = T;
+    using size_type = std::size_t;
+    using propagate_on_container_move_assignment = std::true_type;
+
+    NodesetAllocator(AllocatorState* state) : state(state) {}
+    NodesetAllocator(const NodesetAllocator& other) noexcept = default;
+    template <typename U>
+    NodesetAllocator(const NodesetAllocator<U>& other) noexcept
+        : state(other.state) {}
+    NodesetAllocator(NodesetAllocator&& other) noexcept = default;
+    NodesetAllocator& operator=(const NodesetAllocator&) noexcept = default;
+    NodesetAllocator& operator=(NodesetAllocator&& other) noexcept = default;
+    ~NodesetAllocator() noexcept = default;
+
+    T* allocate(size_type n) {
+      if (n == 1) {
+        T* ptr = reinterpret_cast<T*>(state->freeListHead);
+        if (ptr) {
+          state->freeListHead =
+              reinterpret_cast<FreelistNode*>(state->freeListHead)->next;
+        } else {
+          ptr = reinterpret_cast<T*>(state->currChunkStart);
+          if (!ptr || state->currChunkStart + sizeof(FreelistNode) >
+                          state->currChunkEnd) {
+            auto newChunk = new Chunk;
+            newChunk->next = state->chunkListHead;
+            state->chunkListHead = newChunk;
+            state->currChunkStart = reinterpret_cast<char*>(&newChunk->storage);
+            state->currChunkEnd =
+                state->currChunkStart + sizeof(newChunk->storage);
+            ptr = reinterpret_cast<T*>(state->currChunkStart);
+            state->currChunkStart += sizeof(FreelistNode);
+          } else {
+            state->currChunkStart += sizeof(FreelistNode);
+          }
+        }
+        return ptr;
+      }
+
+      return static_cast<T*>(::operator new(n * sizeof(T)));
+    }
+
+    void deallocate(T* ptr, size_type n) noexcept {
+      if (n == 1) {
+        FreelistNode* node = reinterpret_cast<FreelistNode*>(ptr);
+        node->next = reinterpret_cast<FreelistNode*>(state->freeListHead);
+        state->freeListHead = node;
+      } else {
+        ::operator delete(ptr);
+      }
+    }
+  };
+
+  using NodeSet = std::set<std::pair<double, int64_t>,
+                           std::less<std::pair<double, int64_t>>,
+                           NodesetAllocator<std::pair<double, int64_t>>>;
+
+  struct OpenNode {
+    std::vector<HighsDomainChange> domchgstack;
+    std::vector<HighsInt> branchings;
+    std::vector<NodeSet::iterator> domchglinks;
+    double lower_bound;
+    double estimate;
+    HighsInt depth;
+    highs::RbTreeLinks<int64_t> lowerLinks;
+    highs::RbTreeLinks<int64_t> hybridEstimLinks;
+
+    OpenNode()
+        : domchgstack(),
+          branchings(),
+          domchglinks(),
+          lower_bound(-kHighsInf),
+          estimate(-kHighsInf),
+          depth(0),
+          lowerLinks(),
+          hybridEstimLinks() {}
+
+    OpenNode(std::vector<HighsDomainChange>&& domchgstack,
+             std::vector<HighsInt>&& branchings, double lower_bound,
+             double estimate, HighsInt depth)
+        : domchgstack(domchgstack),
+          branchings(branchings),
+          lower_bound(lower_bound),
+          estimate(estimate),
+          depth(depth),
+          lowerLinks(),
+          hybridEstimLinks() {}
+
+    OpenNode& operator=(OpenNode&& other) = default;
+    OpenNode(OpenNode&&) = default;
+
+    OpenNode& operator=(const OpenNode& other) = delete;
+    OpenNode(const OpenNode&) = delete;
+  };
+
+  void checkGlobalBounds(HighsInt col, double lb, double ub, double feastol,
+                         HighsCDouble& treeweight);
+
+ private:
+  class NodeLowerRbTree;
+  class NodeHybridEstimRbTree;
+  class SuboptimalNodeRbTree;
+
+  std::unique_ptr<AllocatorState> allocatorState;
+  std::vector<OpenNode> nodes;
+  std::priority_queue<int64_t, std::vector<int64_t>, std::greater<int64_t>>
+      freeslots;
+
+  struct GlobalOperatorDelete {
+    template <typename T>
+    void operator()(T* x) const {
+      ::operator delete(x);
+    }
+  };
+  using NodeSetArray = std::unique_ptr<NodeSet, GlobalOperatorDelete>;
+  NodeSetArray colLowerNodesPtr;
+  NodeSetArray colUpperNodesPtr;
+  int64_t lowerRoot = -1;
+  int64_t lowerMin = -1;
+  int64_t hybridEstimRoot = -1;
+  int64_t hybridEstimMin = -1;
+  int64_t suboptimalRoot = -1;
+  int64_t suboptimalMin = -1;
+  int64_t numSuboptimal = 0;
+  double optimality_limit = kHighsInf;
+  HighsInt numCol = 0;
+
+  void link_estim(int64_t node);
+
+  void unlink_estim(int64_t node);
+
+  void link_lower(int64_t node);
+
+  void unlink_lower(int64_t node);
+
+  void link_suboptimal(int64_t node);
+
+  void unlink_suboptimal(int64_t node);
+
+  void link_domchgs(int64_t node);
+
+  void unlink_domchgs(int64_t node);
+
+  double link(int64_t node);
+
+  void unlink(int64_t node);
+
+ public:
+  void setOptimalityLimit(double optimality_limit) {
+    this->optimality_limit = optimality_limit;
+  }
+
+  double performBounding(double upper_limit);
+
+  void setNumCol(HighsInt numcol);
+
+  double emplaceNode(std::vector<HighsDomainChange>&& domchgs,
+                     std::vector<HighsInt>&& branchings, double lower_bound,
+                     double estimate, HighsInt depth);
+
+  OpenNode&& popBestNode();
+
+  OpenNode&& popBestBoundNode();
+
+  int64_t numNodesUp(HighsInt col) const {
+    return colLowerNodesPtr.get()[col].size();
+  }
+
+  int64_t numNodesDown(HighsInt col) const {
+    return colUpperNodesPtr.get()[col].size();
+  }
+
+  int64_t numNodesUp(HighsInt col, double val) const {
+    assert(numCol > col);
+    auto colLowerNodes = colLowerNodesPtr.get();
+    auto it = colLowerNodes[col].upper_bound(std::make_pair(val, kHighsIInf));
+    if (it == colLowerNodes[col].begin()) return colLowerNodes[col].size();
+    return std::distance(it, colLowerNodes[col].end());
+  }
+
+  int64_t numNodesDown(HighsInt col, double val) const {
+    assert(numCol > col);
+    auto colUpperNodes = colUpperNodesPtr.get();
+    auto it = colUpperNodes[col].lower_bound(std::make_pair(val, -1));
+    if (it == colUpperNodes[col].end()) return colUpperNodes[col].size();
+    return std::distance(colUpperNodes[col].begin(), it);
+  }
+
+  const NodeSet& getUpNodes(HighsInt col) const {
+    return colLowerNodesPtr.get()[col];
+  }
+
+  const NodeSet& getDownNodes(HighsInt col) const {
+    return colUpperNodesPtr.get()[col];
+  }
+
+  double pruneInfeasibleNodes(HighsDomain& globaldomain, double feastol);
+
+  double pruneNode(int64_t nodeId);
+
+  double getBestLowerBound() const;
+
+  HighsInt getBestBoundDomchgStackSize() const;
+
+  void clear();
+
+  int64_t numNodes() const { return nodes.size() - freeslots.size(); }
+
+  int64_t numActiveNodes() const {
+    return nodes.size() - freeslots.size() - numSuboptimal;
+  }
+
+  bool empty() const { return numActiveNodes() == 0; }
+};
+
+template <typename T, typename U>
+bool operator==(const HighsNodeQueue::NodesetAllocator<T>&,
+                const HighsNodeQueue::NodesetAllocator<U>&) {
+  return true;
+}
+
+template <typename T, typename U>
+bool operator!=(const HighsNodeQueue::NodesetAllocator<T>&,
+                const HighsNodeQueue::NodesetAllocator<U>&) {
+  return false;
+}
+
+#endif

casadi/include/highs/mip/HighsObjectiveFunction.h

@@ -0,0 +1,74 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+#ifndef HIGHS_OBJECTIVE_FUNCTION_H_
+#define HIGHS_OBJECTIVE_FUNCTION_H_
+
+#include <algorithm>
+#include <cassert>
+#include <vector>
+
+#include "util/HighsInt.h"
+
+class HighsCliqueTable;
+class HighsDomain;
+class HighsLp;
+class HighsMipSolver;
+
+class HighsObjectiveFunction {
+  const HighsLp* model;
+  double objIntScale;
+  HighsInt numIntegral;
+  HighsInt numBinary;
+  std::vector<HighsInt> objectiveNonzeros;
+  std::vector<double> objectiveVals;
+  std::vector<HighsInt> cliquePartitionStart;
+  std::vector<HighsInt> colToPartition;
+
+ public:
+  HighsObjectiveFunction(const HighsMipSolver& mipsolver);
+
+  void setupCliquePartition(const HighsDomain& globaldom,
+                            HighsCliqueTable& cliqueTable);
+
+  void checkIntegrality(double epsilon);
+
+  /// returns the vector of column indices with nonzero objective value
+  /// They will be ordered so that binary columns come first
+  const std::vector<HighsInt>& getObjectiveNonzeros() const {
+    return objectiveNonzeros;
+  }
+
+  const std::vector<double>& getObjectiveValuesPacked() const {
+    return objectiveVals;
+  }
+
+  HighsInt getNumBinariesInObjective() const { return numBinary; }
+
+  const std::vector<HighsInt>& getCliquePartitionStarts() const {
+    return cliquePartitionStart;
+  }
+
+  HighsInt getNumCliquePartitions() const {
+    return cliquePartitionStart.size() - 1;
+  }
+
+  HighsInt getColCliquePartition(HighsInt col) const {
+    return colToPartition[col];
+  }
+
+  double integralScale() const { return objIntScale; }
+
+  bool isIntegral() const { return objIntScale != 0.0; }
+
+  bool isZero() const { return objectiveNonzeros.empty(); }
+};
+
+#endif