Moved isKnapsack to HighsMipSolverData::mipIsKnapsack

Author: jajhall

highs/lp_data/HighsLp.cpp

@@ -38,32 +38,6 @@ bool HighsLp::isBip() const {
   return true;
 }
 
-bool HighsLp::isKnapsack(HighsInt& capacity) const {
-  // Has to kave one constraint
-  if (this->num_row_ != 1) return false;
-  // Has to be a binary integer programming problem
-  if (!this->isBip()) return false;
-  // Must be one-sided constraint
-  if (this->row_lower_[0] > -kHighsInf && this->row_upper_[0] < kHighsInf)
-    return false;
-  const bool upper = this->row_upper_[0] < kHighsInf;
-  const HighsInt constraint_sign = upper ? 1 : -1;
-  // Now check that all the (signed) coefficients are integer and non-negative
-  for (HighsInt iEl = 0; iEl < this->a_matrix_.numNz(); iEl++) {
-    double coeff = constraint_sign * this->a_matrix_.value_[iEl];
-    if (coeff < 0) return false;
-    if (fractionality(coeff) > 0) return false;
-  }
-  // Capacity must be integer, but OK to round down any fractional
-  // values since activity of constraint is integer
-  double double_capacity =
-      upper ? this->row_upper_[0] : constraint_sign * this->row_lower_[0];
-  const double capacity_margin = 1e-6;
-  capacity = std::floor(double_capacity + capacity_margin);
-  // Problem is knapsack!
-  return true;
-}
-
 bool HighsLp::hasInfiniteCost(const double infinite_cost) const {
   for (HighsInt iCol = 0; iCol < this->num_col_; iCol++) {
     if (this->col_cost_[iCol] >= infinite_cost) return true;

highs/lp_data/HighsLp.h

@@ -66,7 +66,6 @@ class HighsLp {
   bool equalScaling(const HighsLp& lp) const;
   bool isMip() const;
   bool isBip() const;
-  bool isKnapsack(HighsInt& capacity) const;
   bool hasSemiVariables() const;
   bool hasInfiniteCost(const double infinite_cost) const;
   bool hasMods() const;

highs/mip/HighsMipSolver.cpp

@@ -91,7 +91,7 @@ void HighsMipSolver::run() {
   // Determine whether this is a knapsack problem and, if so, at least
   // update the data on knapsack sub-MIPs
   HighsInt capacity = 0;
-  if (orig_model_->isKnapsack(capacity)) {
+  if (mipdata_->mipIsKnapsack(capacity)) {
     mipdata_->knapsack_data_.num_problem++;
     mipdata_->knapsack_data_.sum_variables += orig_model_->num_col_;
     mipdata_->knapsack_data_.sum_capacity += capacity;

highs/mip/HighsMipSolverData.cpp

@@ -2651,6 +2651,33 @@ void HighsMipSolverData::callbackUserSolution(
   }
 }
 
+bool HighsMipSolverData::mipIsKnapsack(HighsInt& capacity) {
+  const HighsLp& lp = *(mipsolver.model_);
+  // Has to have one constraint
+  if (lp.num_row_ != 1) return false;
+  // Has to be a binary integer programming problem
+  if (!lp.isBip()) return false;
+  // Must be one-sided constraint
+  if (lp.row_lower_[0] > -kHighsInf && lp.row_upper_[0] < kHighsInf)
+    return false;
+  const bool upper = lp.row_upper_[0] < kHighsInf;
+  const HighsInt constraint_sign = upper ? 1 : -1;
+  // Now check that all the (signed) coefficients are integer and non-negative
+  for (HighsInt iEl = 0; iEl < lp.a_matrix_.numNz(); iEl++) {
+    double coeff = constraint_sign * lp.a_matrix_.value_[iEl];
+    if (coeff < 0) return false;
+    if (fractionality(coeff) > 0) return false;
+  }
+  // Capacity must be integer, but OK to round down any fractional
+  // values since activity of constraint is integer
+  double double_capacity =
+      upper ? lp.row_upper_[0] : constraint_sign * lp.row_lower_[0];
+  const double capacity_margin = 1e-6;
+  capacity = std::floor(double_capacity + capacity_margin);
+  // Problem is knapsack!
+  return true;
+}
+
 static double possInfRelDiff(const double v0, const double v1,
                              const double den) {
   double rel_diff;

highs/mip/HighsMipSolverData.h

@@ -309,6 +309,7 @@ struct HighsMipSolverData {
   void callbackUserSolution(
       const double mipsolver_objective_value,
       const userMipSolutionCallbackOrigin user_solution_callback_origin);
+  bool mipIsKnapsack(HighsInt& capacity);
 };
 
 #endif

highs/mip/HighsPrimalHeuristics.cpp

@@ -1787,11 +1787,10 @@ HighsStatus HighsPrimalHeuristics::solveMipKnapsackReturn(
 }
 
 HighsStatus HighsPrimalHeuristics::solveMipKnapsack() {
-  HighsLp lp = *(mipsolver.model_);
-  //  const HighsLp& lp = mipsolver.mipdata_->model_;
+  const HighsLp& lp = *(mipsolver.model_);
   const HighsLogOptions& log_options = mipsolver.options_mip_->log_options;
   HighsInt capacity_;
-  assert(lp.isKnapsack(capacity_));
+  assert(mipsolver.mipdata_->mipIsKnapsack(capacity_));
 
   const bool upper = lp.row_upper_[0] < kHighsInf;
   const HighsInt constraint_sign = upper ? 1 : -1;