use local conflict pool and worker sols in heur

Opt-Mucca · Opt-Mucca · commit 0408d1045f9a · 2025-10-01T17:22:05.000+02:00
diff --git a/highs/mip/HighsMipSolver.cpp b/highs/mip/HighsMipSolver.cpp
@@ -137,6 +137,10 @@ void HighsMipSolver::run() {
   // Initialize master worker.
   // Now the worker lives in mipdata.
   // The master worker is used in evaluateRootNode.
+  if (mipdata_->domain.infeasible()) {
+    cleanupSolve();
+    return;
+  }
   mipdata_->workers.emplace_back(*this, &mipdata_->lp, mipdata_->domain,
                                  &mipdata_->cutpool, &mipdata_->conflictPool);
 
diff --git a/highs/mip/HighsMipWorker.cpp b/highs/mip/HighsMipWorker.cpp
@@ -148,4 +148,39 @@ std::pair<bool, double> HighsMipWorker::transformNewIntegerFeasibleSolution(
       mipsolver_.model_->offset_);
 
   return std::make_pair(feasible, transformed_solobj);
+}
+
+bool HighsMipWorker::trySolution(const std::vector<double>& solution,
+                                 const int solution_source) {
+  if (static_cast<int>(solution.size()) != mipsolver_.model_->num_col_)
+    return false;
+
+  HighsCDouble obj = 0;
+
+  for (HighsInt i = 0; i != mipsolver_.model_->num_col_; ++i) {
+    if (solution[i] < mipsolver_.model_->col_lower_[i] - mipdata_.feastol)
+      return false;
+    if (solution[i] > mipsolver_.model_->col_upper_[i] + mipdata_.feastol)
+      return false;
+    if (mipsolver_.variableType(i) == HighsVarType::kInteger &&
+        fractionality(solution[i]) > mipdata_.feastol)
+      return false;
+
+    obj += mipsolver_.colCost(i) * solution[i];
+  }
+
+  for (HighsInt i = 0; i != mipsolver_.model_->num_row_; ++i) {
+    double rowactivity = 0.0;
+
+    HighsInt start = mipdata_.ARstart_[i];
+    HighsInt end = mipdata_.ARstart_[i + 1];
+
+    for (HighsInt j = start; j != end; ++j)
+      rowactivity += solution[mipdata_.ARindex_[j]] * mipdata_.ARvalue_[j];
+
+    if (rowactivity > mipsolver_.rowUpper(i) + mipdata_.feastol) return false;
+    if (rowactivity < mipsolver_.rowLower(i) - mipdata_.feastol) return false;
+  }
+
+  return addIncumbent(solution, static_cast<double>(obj), solution_source);
 }
diff --git a/highs/mip/HighsMipWorker.h b/highs/mip/HighsMipWorker.h
@@ -45,10 +45,8 @@ class HighsMipWorker {
   HighsRandom randgen;
 
   // HighsMipWorker(const HighsMipSolver& mipsolver__);
-  HighsMipWorker(const HighsMipSolver& mipsolver__,
-                 HighsLpRelaxation* lprelax_,
-                 HighsDomain& domain,
-                 HighsCutPool* cutpool,
+  HighsMipWorker(const HighsMipSolver& mipsolver__, HighsLpRelaxation* lprelax_,
+                 HighsDomain& domain, HighsCutPool* cutpool,
                  HighsConflictPool* conflictpool);
 
   ~HighsMipWorker() {
@@ -67,11 +65,15 @@ class HighsMipWorker {
   //                   const int solution_source,
   //                   const bool print_display_line = true);
 
-  bool addIncumbent(const std::vector<double>& sol, double solobj, int solution_source);
+  bool addIncumbent(const std::vector<double>& sol, double solobj,
+                    int solution_source);
 
   std::pair<bool, double> transformNewIntegerFeasibleSolution(
       const std::vector<double>& sol);
 
+  bool trySolution(const std::vector<double>& solution,
+                   const int solution_source);
+
   // todo:
   // timer_
   // sync too
diff --git a/highs/mip/HighsPrimalHeuristics.cpp b/highs/mip/HighsPrimalHeuristics.cpp
@@ -176,8 +176,7 @@ bool HighsPrimalHeuristics::solveSubMip(
   HighsInt oldNumImprovingSols = mipsolver.mipdata_->numImprovingSols;
   if (submipsolver.modelstatus_ != HighsModelStatus::kInfeasible &&
       !submipsolver.solution_.empty()) {
-    mipsolver.mipdata_->trySolution(submipsolver.solution_,
-                                    kSolutionSourceSubMip);
+    worker.trySolution(submipsolver.solution_, kSolutionSourceSubMip);
   }
 
   if (mipsolver.mipdata_->numImprovingSols != oldNumImprovingSols) {
@@ -283,8 +282,7 @@ void HighsPrimalHeuristics::rootReducedCost(HighsMipWorker& worker) {
     while (true) {
       localdom.propagate();
       if (localdom.infeasible()) {
-        localdom.conflictAnalysis(mipsolver.mipdata_->conflictPool,
-                                  worker.globaldom_);
+        localdom.conflictAnalysis(*worker.conflictpool_, worker.globaldom_);
 
         double prev_lower_bound = mipsolver.mipdata_->lower_bound;
 
@@ -420,8 +418,7 @@ void HighsPrimalHeuristics::RENS(HighsMipWorker& worker,
         heur.branchUpwards(i, downval, downval - 0.5);
         localdom.propagate();
         if (localdom.infeasible()) {
-          localdom.conflictAnalysis(mipsolver.mipdata_->conflictPool,
-                                    worker.globaldom_);
+          localdom.conflictAnalysis(*worker.conflictpool_, worker.globaldom_);
           break;
         }
       }
@@ -430,8 +427,7 @@ void HighsPrimalHeuristics::RENS(HighsMipWorker& worker,
         heur.branchDownwards(i, upval, upval + 0.5);
         localdom.propagate();
         if (localdom.infeasible()) {
-          localdom.conflictAnalysis(mipsolver.mipdata_->conflictPool,
-                                    worker.globaldom_);
+          localdom.conflictAnalysis(*worker.conflictpool_, worker.globaldom_);
           break;
         }
       }
@@ -492,8 +488,7 @@ void HighsPrimalHeuristics::RENS(HighsMipWorker& worker,
           heur.branchUpwards(fracint.first, fixval, fracint.second);
           localdom.propagate();
           if (localdom.infeasible()) {
-            localdom.conflictAnalysis(mipsolver.mipdata_->conflictPool,
-                                      worker.globaldom_);
+            localdom.conflictAnalysis(*worker.conflictpool_, worker.globaldom_);
             break;
           }
 
@@ -505,8 +500,7 @@ void HighsPrimalHeuristics::RENS(HighsMipWorker& worker,
           heur.branchDownwards(fracint.first, fixval, fracint.second);
           localdom.propagate();
           if (localdom.infeasible()) {
-            localdom.conflictAnalysis(mipsolver.mipdata_->conflictPool,
-                                      worker.globaldom_);
+            localdom.conflictAnalysis(*worker.conflictpool_, worker.globaldom_);
             break;
           }
 
@@ -724,7 +718,7 @@ void HighsPrimalHeuristics::RINS(HighsMipWorker& worker,
             heur.branchUpwards(i, fixval, fixval - 0.5);
             localdom.propagate();
             if (localdom.infeasible()) {
-              localdom.conflictAnalysis(mipsolver.mipdata_->conflictPool,
+              localdom.conflictAnalysis(*worker.conflictpool_,
                                         worker.globaldom_);
               break;
             }
@@ -736,7 +730,7 @@ void HighsPrimalHeuristics::RINS(HighsMipWorker& worker,
             heur.branchDownwards(i, fixval, fixval + 0.5);
             localdom.propagate();
             if (localdom.infeasible()) {
-              localdom.conflictAnalysis(mipsolver.mipdata_->conflictPool,
+              localdom.conflictAnalysis(*worker.conflictpool_,
                                         worker.globaldom_);
               break;
             }
@@ -793,8 +787,7 @@ void HighsPrimalHeuristics::RINS(HighsMipWorker& worker,
         ++numBranched;
         heur.branchUpwards(fracint->first, fixval, fracint->second);
         if (localdom.infeasible()) {
-          localdom.conflictAnalysis(mipsolver.mipdata_->conflictPool,
-                                    worker.globaldom_);
+          localdom.conflictAnalysis(*worker.conflictpool_, worker.globaldom_);
           break;
         }
 
@@ -805,8 +798,7 @@ void HighsPrimalHeuristics::RINS(HighsMipWorker& worker,
         ++numBranched;
         heur.branchDownwards(fracint->first, fixval, fracint->second);
         if (localdom.infeasible()) {
-          localdom.conflictAnalysis(mipsolver.mipdata_->conflictPool,
-                                    worker.globaldom_);
+          localdom.conflictAnalysis(*worker.conflictpool_, worker.globaldom_);
           break;
         }
 
@@ -906,14 +898,12 @@ bool HighsPrimalHeuristics::tryRoundedPoint(HighsMipWorker& worker,
 
     localdom.fixCol(col, intval, HighsDomain::Reason::branching());
     if (localdom.infeasible()) {
-      localdom.conflictAnalysis(mipsolver.mipdata_->conflictPool,
-                                worker.globaldom_);
+      localdom.conflictAnalysis(*worker.conflictpool_, worker.globaldom_);
       return false;
     }
     localdom.propagate();
     if (localdom.infeasible()) {
-      localdom.conflictAnalysis(mipsolver.mipdata_->conflictPool,
-                                worker.globaldom_);
+      localdom.conflictAnalysis(*worker.conflictpool_, worker.globaldom_);
       return false;
     }
   }
@@ -953,17 +943,16 @@ bool HighsPrimalHeuristics::tryRoundedPoint(HighsMipWorker& worker,
       if (!integerFeasible) {
         // there may be fractional integer variables -> try ziRound heuristic
         ziRound(worker, lpsol);
-        return mipsolver.mipdata_->trySolution(lpsol, solution_source);
+        return worker.trySolution(lpsol, solution_source);
       } else {
         // all integer variables are fixed -> add incumbent
-        mipsolver.mipdata_->addIncumbent(lpsol, lprelax.getObjective(),
-                                         solution_source);
+        worker.addIncumbent(lpsol, lprelax.getObjective(), solution_source);
         return true;
       }
     }
   }
 
-  return mipsolver.mipdata_->trySolution(localdom.col_lower_, solution_source);
+  return worker.trySolution(localdom.col_lower_, solution_source);
 }
 
 bool HighsPrimalHeuristics::linesearchRounding(
@@ -1042,14 +1031,12 @@ void HighsPrimalHeuristics::randomizedRounding(
 
     localdom.fixCol(i, intval, HighsDomain::Reason::branching());
     if (localdom.infeasible()) {
-      localdom.conflictAnalysis(mipsolver.mipdata_->conflictPool,
-                                worker.globaldom_);
+      localdom.conflictAnalysis(*worker.conflictpool_, worker.globaldom_);
       return;
     }
     localdom.propagate();
     if (localdom.infeasible()) {
-      localdom.conflictAnalysis(mipsolver.mipdata_->conflictPool,
-                                worker.globaldom_);
+      localdom.conflictAnalysis(*worker.conflictpool_, worker.globaldom_);
       return;
     }
   }
@@ -1087,12 +1074,11 @@ void HighsPrimalHeuristics::randomizedRounding(
       }
 
     } else if (lprelax.unscaledPrimalFeasible(st))
-      mipsolver.mipdata_->addIncumbent(
-          lprelax.getLpSolver().getSolution().col_value, lprelax.getObjective(),
-          kSolutionSourceRandomizedRounding);
+      worker.addIncumbent(lprelax.getLpSolver().getSolution().col_value,
+                          lprelax.getObjective(),
+                          kSolutionSourceRandomizedRounding);
   } else {
-    mipsolver.mipdata_->trySolution(localdom.col_lower_,
-                                    kSolutionSourceRandomizedRounding);
+    worker.trySolution(localdom.col_lower_, kSolutionSourceRandomizedRounding);
   }
 }
 
@@ -1345,8 +1331,7 @@ void HighsPrimalHeuristics::shifting(HighsMipWorker& worker,
     if (current_fractional_integers.size() > 0)
       ziRound(worker, current_relax_solution);
     else
-      mipsolver.mipdata_->trySolution(current_relax_solution,
-                                      kSolutionSourceShifting);
+      worker.trySolution(current_relax_solution, kSolutionSourceShifting);
   }
 }
 
@@ -1460,8 +1445,7 @@ void HighsPrimalHeuristics::ziRound(HighsMipWorker& worker,
     improvement_in_feasibility = previous_zi_total - zi_total;
   }
   // re-check for feasibility and add incumbent
-  mipsolver.mipdata_->trySolution(current_relax_solution,
-                                  kSolutionSourceZiRound);
+  worker.trySolution(current_relax_solution, kSolutionSourceZiRound);
 }
 
 void HighsPrimalHeuristics::feasibilityPump(HighsMipWorker& worker) {
@@ -1504,14 +1488,12 @@ void HighsPrimalHeuristics::feasibilityPump(HighsMipWorker& worker) {
       if (!localdom.infeasible()) {
         localdom.fixCol(i, intval, HighsDomain::Reason::branching());
         if (localdom.infeasible()) {
-          localdom.conflictAnalysis(mipsolver.mipdata_->conflictPool,
-                                    worker.globaldom_);
+          localdom.conflictAnalysis(*worker.conflictpool_, worker.globaldom_);
           continue;
         }
         localdom.propagate();
         if (localdom.infeasible()) {
-          localdom.conflictAnalysis(mipsolver.mipdata_->conflictPool,
-                                    worker.globaldom_);
+          localdom.conflictAnalysis(*worker.conflictpool_, worker.globaldom_);
           continue;
         }
       }
@@ -1569,9 +1551,8 @@ void HighsPrimalHeuristics::feasibilityPump(HighsMipWorker& worker) {
 
   if (lprelax.getFractionalIntegers().empty() &&
       lprelax.unscaledPrimalFeasible(status))
-    mipsolver.mipdata_->addIncumbent(
-        lprelax.getLpSolver().getSolution().col_value, lprelax.getObjective(),
-        kSolutionSourceFeasibilityPump);
+    worker.addIncumbent(lprelax.getLpSolver().getSolution().col_value,
+                        lprelax.getObjective(), kSolutionSourceFeasibilityPump);
 }
 
 void HighsPrimalHeuristics::centralRounding(HighsMipWorker& worker) {
