Merge branch 'latest' of https://github.com/ERGO-Code/HiGHS into coeffStren

fwesselm · fwesselm · commit 0cac3fdd846e · 2025-04-11T08:39:10.000+02:00
diff --git a/.github/julia/build_tarballs.jl b/.github/julia/build_tarballs.jl
@@ -0,0 +1,77 @@
+# !!! note
+#     This file is a version of the file we use to package HiGHS for the Julia
+#     ecosystem. If you make changes to this file during the development of
+#     HiGHS, please tag `@odow` so we can make the correponding changes to:
+#     https://github.com/JuliaPackaging/Yggdrasil/blob/master/H/HiGHS
+
+using BinaryBuilder, Pkg
+
+name = "HiGHS"
+version = VersionNumber(ENV["HIGHS_RELEASE"])
+
+sources = [GitSource(ENV["HIGHS_URL"], ENV["HIGHS_COMMIT"])]
+
+script = raw"""
+export BUILD_SHARED="ON"
+export BUILD_STATIC="OFF"
+
+cd $WORKSPACE/srcdir/HiGHS
+
+# Remove system CMake to use the jll version
+apk del cmake
+
+mkdir -p build
+cd build
+
+# Do fully static build only on Windows
+if [[ "${BUILD_SHARED}" == "OFF" ]] && [[ "${target}" == *-mingw* ]]; then
+    export CXXFLAGS="-static"
+fi
+
+cmake -DCMAKE_INSTALL_PREFIX=${prefix} \
+    -DCMAKE_TOOLCHAIN_FILE=${CMAKE_TARGET_TOOLCHAIN} \
+    -DCMAKE_BUILD_TYPE=Release \
+    -DBUILD_SHARED_LIBS=${BUILD_SHARED} \
+    -DZLIB_USE_STATIC_LIBS=${BUILD_STATIC} \
+    -DFAST_BUILD=ON ..
+
+if [[ "${target}" == *-linux-* ]]; then
+        make -j ${nproc}
+else
+    if [[ "${target}" == *-mingw* ]]; then
+        cmake --build . --config Release
+    else
+        cmake --build . --config Release --parallel
+    fi
+fi
+make install
+
+install_license ../LICENSE.txt
+"""
+
+products = [
+    LibraryProduct("libhighs", :libhighs),
+    ExecutableProduct("highs", :highs),
+]
+
+platforms = supported_platforms()
+platforms = expand_cxxstring_abis(platforms)
+
+dependencies = [
+    Dependency("CompilerSupportLibraries_jll"),
+    Dependency("Zlib_jll"),
+    HostBuildDependency(PackageSpec(; name="CMake_jll")),
+]
+
+build_tarballs(
+    ARGS,
+    name,
+    version,
+    sources,
+    script,
+    platforms,
+    products,
+    dependencies;
+    preferred_gcc_version = v"6",
+    julia_compat = "1.6",
+)
diff --git a/.github/workflows/julia-tests-ubuntu.yml b/.github/workflows/julia-tests-ubuntu.yml
@@ -0,0 +1,63 @@
+name: JuliaCompileAndTest
+on:
+  push:
+    branches: [master, latest]
+  pull_request:
+    types: [opened, synchronize, ready_for_review, reopened]
+# needed to allow julia-actions/cache to delete old caches that it has created
+permissions:
+  actions: write
+  contents: read
+jobs:
+  test:
+    name: Julia - ${{ github.event_name }}
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      # Install Julia 1.7 for BinaryBuilder. Note that this is an old version of
+      # Julia, but it is required for compatibility with BinaryBuilder.
+      - uses: julia-actions/setup-julia@v2
+        with:
+          version: "1.7"
+          arch: x64
+      - uses: julia-actions/cache@v2
+      # Set the environment variables required by BinaryBuilder.
+      - run: |
+          git fetch --tags
+          echo "HIGHS_RELEASE=$(git describe --tags $(git rev-list --tags --max-count=1) | sed 's/^v//')" >> $GITHUB_ENV
+          if [ "${{ github.event_name }}" = "pull_request" ]; then
+            echo "HIGHS_COMMIT=${{ github.event.pull_request.head.sha }}" >> $GITHUB_ENV
+            echo "HIGHS_URL=${{ github.event.pull_request.head.repo.clone_url }}" >> $GITHUB_ENV
+          else
+            echo "HIGHS_COMMIT=${{ github.sha }}" >> $GITHUB_ENV
+            echo "HIGHS_URL=https://github.com/${{ github.repository }}.git" >> $GITHUB_ENV
+          fi
+      - run: |
+          julia --color=yes -e 'using Pkg; Pkg.add("BinaryBuilder")'
+          julia --color=yes .github/julia/build_tarballs.jl x86_64-linux-gnu-cxx11 --verbose --deploy="local"
+      # Now install a newer version of Julia to actually test HiGHS_jll. We
+      # choose v1.10 because it is the current Long-Term Support (LTS).
+      - uses: julia-actions/setup-julia@v2
+        with:
+          version: "1.10"
+          arch: x64
+      # We want to install the latest version of HiGHS.jl, but we also want it
+      # to be compatible with our newly compiled HiGHS_jll. To do so, we
+      # manually edit HiGHS.jl's Project.toml file to allow any v1.X.Y version
+      # of HiGHS_jll
+      - shell: julia --color=yes {0}
+        run: |
+          using Pkg
+          Pkg.develop("HiGHS")
+          project_filename = "/home/runner/.julia/dev/HiGHS/Project.toml"
+          project = read(project_filename, String)
+          write(
+            project_filename,
+            replace(project, r"HiGHS_jll = \"=.+?\"" => "HiGHS_jll = \"1\""),
+          )
+      # Now we can add HiGHS_jll and run the tests for HiGHS.
+      - shell: julia --color=yes {0}
+        run: |
+          using Pkg
+          Pkg.develop(; path="/home/runner/.julia/dev/HiGHS_jll")
+          Pkg.test("HiGHS")
diff --git a/check/TestMipSolver.cpp b/check/TestMipSolver.cpp
@@ -833,3 +833,18 @@ TEST_CASE("issue-2204", "[highs_test_mip_solver]") {
   const double optimal_objective = 6.0;
   solve(highs, kHighsOnString, require_model_status, optimal_objective);
 }
+
+TEST_CASE("ZI Round and Shifting Heuristics", "[highs_test_mip_solver]") {
+  std::string model_file =
+      std::string(HIGHS_DIR) + "/check/instances/rgn.mps";
+
+  Highs highs;
+  highs.setOptionValue("output_flag", dev_run);
+  // Enable both heuristics
+  highs.setOptionValue("mip_heuristic_run_zi_round", true);
+  highs.setOptionValue("mip_heuristic_run_shifting", true);  
+  highs.readModel(model_file);
+  const HighsModelStatus require_model_status = HighsModelStatus::kOptimal;
+  const double optimal_objective = 82.19999924;
+  solve(highs, kHighsOnString, require_model_status, optimal_objective);
+}
diff --git a/highs/lp_data/HighsOptions.h b/highs/lp_data/HighsOptions.h
@@ -437,6 +437,12 @@ struct HighsOptionsStruct {
   double mip_abs_gap;
   double mip_heuristic_effort;
   double mip_min_logging_interval;
+  bool mip_heuristic_run_rins;
+  bool mip_heuristic_run_rens;
+  bool mip_heuristic_run_root_reduced_cost;
+  bool mip_heuristic_run_zi_round;
+  bool mip_heuristic_run_shifting;
+
 #ifdef HIGHS_DEBUGSOL
   std::string mip_debug_solution_file;
 #endif
@@ -1109,6 +1115,32 @@ class HighsOptions : public HighsOptionsStruct {
         &mip_heuristic_effort, 0.0, 0.05, 1.0);
     records.push_back(record_double);
 
+    record_bool = new OptionRecordBool("mip_heuristic_run_rins",
+                                       "Run RINS heuristic: Default = true",
+                                       advanced, &mip_heuristic_run_rins, true);
+    records.push_back(record_bool);
+
+    record_bool = new OptionRecordBool("mip_heuristic_run_rens",
+                                       "Run RENS heuristic: Default = true",
+                                       advanced, &mip_heuristic_run_rens, true);
+    records.push_back(record_bool);
+
+    record_bool = new OptionRecordBool(
+        "mip_heuristic_run_root_reduced_cost",
+        "Run rootReducedCost heuristic: Default = true", advanced,
+        &mip_heuristic_run_root_reduced_cost, true);
+    records.push_back(record_bool);
+
+    record_bool = new OptionRecordBool(
+        "mip_heuristic_run_zi_round", "Run ZI Round heuristic: Default = false",
+        advanced, &mip_heuristic_run_zi_round, false);
+    records.push_back(record_bool);
+
+    record_bool = new OptionRecordBool(
+        "mip_heuristic_run_shifting", "Run Shifting heuristic: Default = false",
+        advanced, &mip_heuristic_run_shifting, false);
+    records.push_back(record_bool);
+
     record_double = new OptionRecordDouble(
         "mip_rel_gap",
         "Tolerance on relative gap, |ub-lb|/|ub|, to determine whether "
diff --git a/highs/mip/HighsMipSolver.cpp b/highs/mip/HighsMipSolver.cpp
@@ -257,15 +257,19 @@ void HighsMipSolver::run() {
           }
 
           if (mipdata_->incumbent.empty()) {
-            analysis_.mipTimerStart(kMipClockDiveRens);
-            mipdata_->heuristics.RENS(
-                mipdata_->lp.getLpSolver().getSolution().col_value);
-            analysis_.mipTimerStop(kMipClockDiveRens);
+            if (options_mip_->mip_heuristic_run_rens) {
+              analysis_.mipTimerStart(kMipClockDiveRens);
+              mipdata_->heuristics.RENS(
+                  mipdata_->lp.getLpSolver().getSolution().col_value);
+              analysis_.mipTimerStop(kMipClockDiveRens);
+            }
           } else {
-            analysis_.mipTimerStart(kMipClockDiveRins);
-            mipdata_->heuristics.RINS(
-                mipdata_->lp.getLpSolver().getSolution().col_value);
-            analysis_.mipTimerStop(kMipClockDiveRins);
+            if (options_mip_->mip_heuristic_run_rins) {
+              analysis_.mipTimerStart(kMipClockDiveRins);
+              mipdata_->heuristics.RINS(
+                  mipdata_->lp.getLpSolver().getSolution().col_value);
+              analysis_.mipTimerStop(kMipClockDiveRins);
+            }
           }
 
           mipdata_->heuristics.flushStatistics();
diff --git a/highs/mip/HighsMipSolverData.cpp b/highs/mip/HighsMipSolverData.cpp
@@ -48,6 +48,12 @@ std::string HighsMipSolverData::solutionSourceToString(
   } else if (solution_source == kSolutionSourceRandomizedRounding) {
     if (code) return "R";
     return "Randomized rounding";
+  } else if (solution_source == kSolutionSourceZiRound) {
+    if (code) return "Z";
+    return "ZI Round";
+  } else if (solution_source == kSolutionSourceShifting) {
+    if (code) return "I";
+    return "Shifting";
   } else if (solution_source == kSolutionSourceSolveLp) {
     if (code) return "S";
     return "Solve LP";
@@ -110,6 +116,32 @@ bool HighsMipSolverData::checkSolution(
   return true;
 }
 
+std::vector<std::tuple<HighsInt, HighsInt, double>>
+HighsMipSolverData::getInfeasibleRows(
+    const std::vector<double>& solution) const {
+  std::vector<std::tuple<HighsInt, HighsInt, double>> infeasibleRows;
+  for (HighsInt i = 0; i != mipsolver.model_->num_row_; ++i) {
+    HighsInt start = ARstart_[i];
+    HighsInt end = ARstart_[i + 1];
+
+    HighsCDouble row_activity_quad = 0.0;
+    for (HighsInt j = start; j != end; ++j)
+      row_activity_quad +=
+          static_cast<HighsCDouble>(solution[ARindex_[j]]) * ARvalue_[j];
+
+    double row_activity = static_cast<double>(row_activity_quad);
+    if (row_activity > mipsolver.rowUpper(i) + feastol) {
+      double difference = std::abs(row_activity - mipsolver.rowUpper(i));
+      infeasibleRows.push_back({i, +1, difference});
+    }
+    if (row_activity < mipsolver.rowLower(i) - feastol) {
+      double difference = std::abs(mipsolver.rowLower(i) - row_activity);
+      infeasibleRows.push_back({i, -1, difference});
+    }
+  }
+  return infeasibleRows;
+}
+
 bool HighsMipSolverData::trySolution(const std::vector<double>& solution,
                                      const int solution_source) {
   if (int(solution.size()) != mipsolver.model_->num_col_) return false;
@@ -1601,6 +1633,8 @@ bool HighsMipSolverData::rootSeparationRound(
 
   if (mipsolver.submip || incumbent.empty()) {
     heuristics.randomizedRounding(solvals);
+    if (mipsolver.options_mip_->mip_heuristic_run_shifting)
+      heuristics.shifting(solvals);
     heuristics.flushStatistics();
     status = evaluateRootLp();
     if (status == HighsLpRelaxation::Status::kInfeasible) return true;
@@ -1680,6 +1714,11 @@ HighsLpRelaxation::Status HighsMipSolverData::evaluateRootLp() {
         num_leaves += 1;
         return HighsLpRelaxation::Status::kInfeasible;
       }
+
+      if (status == HighsLpRelaxation::Status::kOptimal &&
+          mipsolver.options_mip_->mip_heuristic_run_zi_round)
+        heuristics.ziRound(lp.getLpSolver().getSolution().col_value);
+
     } else
       status = lp.getStatus();
 
@@ -1876,9 +1915,14 @@ void HighsMipSolverData::evaluateRootNode() {
   last_disptime = -kHighsInf;
   disptime = 0;
 
+  if (mipsolver.options_mip_->mip_heuristic_run_zi_round)
+    heuristics.ziRound(firstlpsol);
   analysis.mipTimerStart(kMipClockRandomizedRounding);
   heuristics.randomizedRounding(firstlpsol);
   analysis.mipTimerStop(kMipClockRandomizedRounding);
+  if (mipsolver.options_mip_->mip_heuristic_run_shifting)
+    heuristics.shifting(firstlpsol);
+
   heuristics.flushStatistics();
 
   analysis.mipTimerStart(kMipClockEvaluateRootLp);
@@ -2068,6 +2112,15 @@ void HighsMipSolverData::evaluateRootNode() {
   rootlpsolobj = lp.getObjective();
   lp.setIterationLimit(std::max(10000, int(10 * avgrootlpiters)));
 
+  if (mipsolver.options_mip_->mip_heuristic_run_zi_round) {
+    heuristics.ziRound(firstlpsol);
+    heuristics.flushStatistics();
+  }
+  if (mipsolver.options_mip_->mip_heuristic_run_shifting) {
+    heuristics.shifting(rootlpsol);
+    heuristics.flushStatistics();
+  }
+
   if (!analyticCenterComputed && compute_analytic_centre) {
     if (checkLimits()) return clockOff(analysis);
 
@@ -2122,10 +2175,12 @@ void HighsMipSolverData::evaluateRootNode() {
     if (rootlpsol.empty()) break;
     if (upper_limit != kHighsInf && !moreHeuristicsAllowed()) break;
 
-    analysis.mipTimerStart(kMipClockRootHeuristicsReducedCost);
-    heuristics.rootReducedCost();
-    analysis.mipTimerStop(kMipClockRootHeuristicsReducedCost);
-    heuristics.flushStatistics();
+    if (mipsolver.options_mip_->mip_heuristic_run_root_reduced_cost) {
+      analysis.mipTimerStart(kMipClockRootHeuristicsReducedCost);
+      heuristics.rootReducedCost();
+      analysis.mipTimerStop(kMipClockRootHeuristicsReducedCost);
+      heuristics.flushStatistics();
+    }
 
     if (checkLimits()) return clockOff(analysis);
 
@@ -2151,10 +2206,12 @@ void HighsMipSolverData::evaluateRootNode() {
     if (upper_limit != kHighsInf && !moreHeuristicsAllowed()) break;
 
     if (checkLimits()) return clockOff(analysis);
-    analysis.mipTimerStart(kMipClockRootHeuristicsRens);
-    heuristics.RENS(rootlpsol);
-    analysis.mipTimerStop(kMipClockRootHeuristicsRens);
-    heuristics.flushStatistics();
+    if (mipsolver.options_mip_->mip_heuristic_run_rens) {
+      analysis.mipTimerStart(kMipClockRootHeuristicsRens);
+      heuristics.RENS(rootlpsol);
+      analysis.mipTimerStop(kMipClockRootHeuristicsRens);
+      heuristics.flushStatistics();
+    }
 
     if (checkLimits()) return clockOff(analysis);
     // if there are new global bound changes we re-evaluate the LP and do one
diff --git a/highs/mip/HighsMipSolverData.h b/highs/mip/HighsMipSolverData.h
@@ -50,6 +50,8 @@ enum MipSolutionSource : int {
   kSolutionSourceSubMip,
   kSolutionSourceEmptyMip,
   kSolutionSourceRandomizedRounding,
+  kSolutionSourceZiRound,
+  kSolutionSourceShifting,
   kSolutionSourceSolveLp,
   kSolutionSourceEvaluateNode,
   kSolutionSourceUnbounded,
@@ -257,6 +259,8 @@ struct HighsMipSolverData {
   double percentageInactiveIntegers() const;
   void performRestart();
   bool checkSolution(const std::vector<double>& solution) const;
+  std::vector<std::tuple<HighsInt, HighsInt, double>> getInfeasibleRows(
+      const std::vector<double>& solution) const;
   bool trySolution(const std::vector<double>& solution,
                    const int solution_source = kSolutionSourceNone);
   bool rootSeparationRound(HighsSeparation& sepa, HighsInt& ncuts,
diff --git a/highs/mip/HighsPrimalHeuristics.cpp b/highs/mip/HighsPrimalHeuristics.cpp
diff --git a/highs/mip/HighsPrimalHeuristics.h b/highs/mip/HighsPrimalHeuristics.h
