Merge branch 'latest' into strong-branch-refactor

Author: jajhall

FEATURES.md

@@ -12,4 +12,7 @@ The irreducible infeasibility system (IIS) facility now detects infeasibility du
 
 Prompted by [#2463](https://github.com/ERGO-Code/HiGHS/issues/2463), the HiGHS solution and basis files now match data to any column and row names in the model, only assuming that the data are aligned with column and row indices if there are no names in the model. This requires a new version (v2) of the HiGHS basis file. Basis files from v1 are still read, but deprecated. Now, when writing out a model, basis or solution, column and row names are added to the model - previously they were created temporarily and inconsistentyly on the fly. If the model has existing names, then distinctive names are created to replace any blank names, but names with spaces or duplicate names yield an error status return.
 
-Refactored strong branching to minimize duplicated code
+Refactored strong branching to minimize duplicated code
+
+As per [#2487](https://github.com/ERGO-Code/HiGHS/issues/2487), trivial heuristics now run before feasibility jump (FJ), and FJ will use any existing incumbent. FJ will clip any finite variable values in the incumbent to lower and upper bounds, and falls back to the existing logic (lower bound if finite, else upper bound if finite, else 0) for any infinite values in the incumbent.
+

README.md

@@ -46,7 +46,7 @@ linear optimization problems of the form
 
 $$ \min \quad \dfrac{1}{2}x^TQx + c^Tx \qquad \textrm{s.t.}~ \quad L \leq Ax \leq U; \quad l \leq x \leq u $$
 
-where Q must be positive semi-definite and, if Q is zero, there may be a requirement that some of the variables take integer values. Thus HiGHS can solve linear programming (LP) problems, convex quadratic programming (QP) problems, and mixed integer programming (MIP) problems. It is mainly written in C++, but also has some C. It has been developed and tested on various Linux, MacOS and Windows installations. No third-party dependencies are required.
+where $Q$ must be positive semi-definite and, if $Q$ is zero, there may be a requirement that some of the variables take integer values. Thus HiGHS can solve linear programming (LP) problems, convex quadratic programming (QP) problems, and mixed integer programming (MIP) problems. It is mainly written in C++, but also has some C. It has been developed and tested on various Linux, MacOS and Windows installations. No third-party dependencies are required.
 
 HiGHS has primal and dual revised simplex solvers, originally written by Qi Huangfu and further developed by Julian Hall. It also has an interior point solver for LP written by Lukas Schork, an active set solver for QP written by Michael Feldmeier, and a MIP solver written by Leona Gottwald. Other features have been added by Julian Hall and Ivet Galabova, who manages the software engineering of HiGHS and interfaces to C, C#, FORTRAN, Julia and Python.
 

check/TestBasis.cpp

@@ -315,3 +315,43 @@ void testBasisRestart(Highs& highs, const std::string& basis_file,
 
   REQUIRE(info.simplex_iteration_count == 0);
 }
+
+TEST_CASE("Basis-read", "[highs_basis_data]") {
+  // Duplicates test_read_basis in test_highspy.py
+  const std::string test_name = Catch::getResultCapture().getCurrentTestName();
+
+  HighsLp lp;
+  lp.num_col_ = 2;
+  lp.num_row_ = 2;
+  lp.col_cost_ = {0, 1};
+  lp.col_lower_.assign(lp.num_col_, -kHighsInf);
+  lp.col_upper_.assign(lp.num_col_, kHighsInf);
+  lp.row_lower_ = {2, 0};
+  lp.row_upper_.assign(lp.num_row_, kHighsInf);
+  lp.a_matrix_.start_ = {0, 2, 4};
+  lp.a_matrix_.index_ = {0, 1, 0, 1};
+  lp.a_matrix_.value_ = {-1, 1, 1, 1};
+
+  HighsBasisStatus status_before = HighsBasisStatus::kNonbasic;
+  HighsBasisStatus status_after = HighsBasisStatus::kBasic;
+  Highs h1;
+  const HighsBasis& basis1 = h1.getBasis();
+  h1.passModel(lp);
+  REQUIRE(basis1.col_status[0] == status_before);
+  h1.run();
+  REQUIRE(basis1.col_status[0] == status_after);
+
+  Highs h2;
+  const HighsBasis& basis2 = h2.getBasis();
+  h2.passModel(lp);
+  REQUIRE(basis2.col_status[0] == status_before);
+
+  const std::string basis_file = test_name + ".bas";
+  h1.writeBasis(basis_file);
+  h2.readBasis(basis_file);
+  REQUIRE(basis2.col_status[0] == status_after);
+
+  std::remove(basis_file.c_str());
+  h1.resetGlobalScheduler(true);
+  h2.resetGlobalScheduler(true);
+}

check/TestCallbacks.cpp

@@ -36,7 +36,7 @@ struct MipData {
 struct UserMipSolution {
   double optimal_objective_value;
   std::vector<double> optimal_solution;
-  HighsInt require_user_solution_callback_origin;
+  HighsInt require_external_solution_query_origin;
 };
 
 // Callback that saves message for comparison
@@ -193,8 +193,8 @@ HighsCallbackFunctionType userkMipUserSolution =
        void* user_callback_data) {
       UserMipSolution callback_data =
           *(static_cast<UserMipSolution*>(user_callback_data));
-      if (data_out->user_solution_callback_origin ==
-          callback_data.require_user_solution_callback_origin) {
+      if (data_out->external_solution_query_origin ==
+          callback_data.require_external_solution_query_origin) {
         if (data_out->mip_primal_bound >
             callback_data.optimal_objective_value) {
           // If current objective value is not optimal, pass the
@@ -203,7 +203,7 @@ HighsCallbackFunctionType userkMipUserSolution =
             printf(
                 "userkMipUserSolution: origin = %d; %g = mip_primal_bound > "
                 "optimal_objective_value = %g\n",
-                int(data_out->user_solution_callback_origin),
+                int(data_out->external_solution_query_origin),
                 data_out->mip_primal_bound,
                 callback_data.optimal_objective_value);
           data_in->user_has_solution = true;
@@ -218,13 +218,13 @@ HighsCallbackFunctionType userkMipUserSetSolution =
        void* user_callback_data) {
       const auto& callback_data =
           *(static_cast<UserMipSolution*>(user_callback_data));
-      if (data_out->user_solution_callback_origin ==
-          callback_data.require_user_solution_callback_origin) {
+      if (data_out->external_solution_query_origin ==
+          callback_data.require_external_solution_query_origin) {
         if (dev_run)
           printf(
               "userkMipUserSetSolution: origin = %d; %g = mip_primal_bound > "
               "optimal_objective_value = %g\n",
-              int(data_out->user_solution_callback_origin),
+              int(data_out->external_solution_query_origin),
               data_out->mip_primal_bound,
               callback_data.optimal_objective_value);
 
@@ -239,14 +239,14 @@ HighsCallbackFunctionType userkMipUserSetPartialSolution =
        void* user_callback_data) {
       const auto& callback_data =
           *(static_cast<UserMipSolution*>(user_callback_data));
-      if (data_out->user_solution_callback_origin ==
-          callback_data.require_user_solution_callback_origin) {
+      if (data_out->external_solution_query_origin ==
+          callback_data.require_external_solution_query_origin) {
         if (dev_run)
           printf(
               "userkMipUserSetPartialSolution: origin = %d; %g = "
               "mip_primal_bound > "
               "optimal_objective_value = %g\n",
-              int(data_out->user_solution_callback_origin),
+              int(data_out->external_solution_query_origin),
               data_out->mip_primal_bound,
               callback_data.optimal_objective_value);
 
@@ -511,7 +511,7 @@ static void runMipUserSolutionTest(
     UserMipSolution user_callback_data;
     user_callback_data.optimal_objective_value = objective_function_value0;
     user_callback_data.optimal_solution = optimal_solution;
-    user_callback_data.require_user_solution_callback_origin =
+    user_callback_data.require_external_solution_query_origin =
         require_origin[iModel];
     void* p_user_callback_data = (void*)(&user_callback_data);
 
@@ -597,4 +597,4 @@ TEST_CASE("highs-callback-mip-user-solution-c", "[highs-callback]") {
 
   highs.run();
   highs.resetGlobalScheduler(true);
-}
+}

check/TestIpm.cpp

@@ -200,3 +200,19 @@ TEST_CASE("test-2087", "[highs_ipm]") {
 
   h.resetGlobalScheduler(true);
 }
+
+TEST_CASE("test-2527", "[highs_ipm]") {
+  std::string filename =
+      std::string(HIGHS_DIR) + "/check/instances/primal1.mps";
+  Highs h;
+  //  h.setOptionValue("output_flag", dev_run);
+  REQUIRE(h.readModel(filename) == HighsStatus::kOk);
+  HighsLp lp = h.getLp();
+  lp.col_cost_.assign(lp.num_col_, 0);
+  REQUIRE(h.passModel(lp) == HighsStatus::kOk);
+  h.setOptionValue("solver", kIpmString);
+  h.setOptionValue("presolve", kHighsOffString);
+  REQUIRE(h.run() == HighsStatus::kOk);
+
+  h.resetGlobalScheduler(true);
+}

check/TestMipSolver.cpp

@@ -40,12 +40,16 @@ TEST_CASE("MIP-rowless-1", "[highs_test_mip_solver]") {
   Highs highs;
   if (!dev_run) highs.setOptionValue("output_flag", false);
   rowlessMIP1(highs);
+
+  highs.resetGlobalScheduler(true);
 }
 
 TEST_CASE("MIP-rowless-2", "[highs_test_mip_solver]") {
   Highs highs;
   if (!dev_run) highs.setOptionValue("output_flag", false);
   rowlessMIP2(highs);
+
+  highs.resetGlobalScheduler(true);
 }
 
 TEST_CASE("MIP-solution-limit", "[highs_test_mip_solver]") {
@@ -79,6 +83,8 @@ TEST_CASE("MIP-solution-limit", "[highs_test_mip_solver]") {
   REQUIRE(highs.getModelStatus() == HighsModelStatus::kSolutionLimit);
   highs.setOptionValue("mip_max_improving_sols", kHighsIInf);
   highs.clearSolver();
+
+  highs.resetGlobalScheduler(true);
 }
 
 TEST_CASE("MIP-integrality", "[highs_test_mip_solver]") {
@@ -173,6 +179,8 @@ TEST_CASE("MIP-integrality", "[highs_test_mip_solver]") {
   REQUIRE(info.mip_node_count == 1);
   REQUIRE(fabs(info.mip_dual_bound + 6) < double_equal_tolerance);
   REQUIRE(std::fabs(info.mip_gap) < 1e-12);
+
+  highs.resetGlobalScheduler(true);
 }
 
 TEST_CASE("MIP-clear-integrality", "[highs_test_mip_solver]") {
@@ -215,6 +223,8 @@ TEST_CASE("MIP-nmck", "[highs_test_mip_solver]") {
   REQUIRE(info.num_primal_infeasibilities == 0);
   REQUIRE(info.max_primal_infeasibility == 0);
   REQUIRE(info.sum_primal_infeasibilities == 0);
+
+  highs.resetGlobalScheduler(true);
 }
 
 TEST_CASE("MIP-maximize", "[highs_test_mip_solver]") {
@@ -295,6 +305,8 @@ TEST_CASE("MIP-maximize", "[highs_test_mip_solver]") {
   REQUIRE(std::abs(info.objective_function_value - info.mip_dual_bound) <=
           options.mip_abs_gap);
   REQUIRE(std::abs(info.mip_gap) <= options.mip_rel_gap);
+
+  highs.resetGlobalScheduler(true);
 }
 
 TEST_CASE("MIP-unbounded", "[highs_test_mip_solver]") {
@@ -403,6 +415,8 @@ TEST_CASE("MIP-unbounded", "[highs_test_mip_solver]") {
 
   model_status = highs.getModelStatus();
   REQUIRE(model_status == HighsModelStatus::kInfeasible);
+
+  highs.resetGlobalScheduler(true);
 }
 
 TEST_CASE("MIP-od", "[highs_test_mip_solver]") {
@@ -470,6 +484,8 @@ TEST_CASE("MIP-od", "[highs_test_mip_solver]") {
           double_equal_tolerance);
   REQUIRE(fabs(solution.col_value[0] - required_x0_value) <
           double_equal_tolerance);
+
+  highs.resetGlobalScheduler(true);
 }
 
 TEST_CASE("MIP-infeasible-start", "[highs_test_mip_solver]") {
@@ -513,6 +529,8 @@ TEST_CASE("MIP-infeasible-start", "[highs_test_mip_solver]") {
           HighsStatus::kOk);
   highs.run();
   REQUIRE(model_status == HighsModelStatus::kInfeasible);
+
+  highs.resetGlobalScheduler(true);
 }
 
 TEST_CASE("get-integrality", "[highs_test_mip_solver]") {}
@@ -556,6 +574,8 @@ TEST_CASE("MIP-bounds", "[highs_test_mip_solver]") {
            obj1);
   REQUIRE(obj0 == obj1);
   std::remove(test_mps.c_str());
+
+  highs.resetGlobalScheduler(true);
 }
 
 TEST_CASE("MIP-get-saved-solutions", "[highs_test_mip_solver]") {
@@ -583,6 +603,8 @@ TEST_CASE("MIP-get-saved-solutions", "[highs_test_mip_solver]") {
     REQUIRE(saved_objective_and_solution[last_saved_solution].col_value[iCol] ==
             highs.getSolution().col_value[iCol]);
   std::remove(solution_file.c_str());
+
+  highs.resetGlobalScheduler(true);
 }
 
 TEST_CASE("MIP-objective-target", "[highs_test_mip_solver]") {
@@ -597,6 +619,8 @@ TEST_CASE("MIP-objective-target", "[highs_test_mip_solver]") {
   highs.run();
   REQUIRE(highs.getModelStatus() == HighsModelStatus::kObjectiveTarget);
   REQUIRE(highs.getInfo().objective_function_value > egout_optimal_objective);
+
+  highs.resetGlobalScheduler(true);
 }
 
 TEST_CASE("MIP-max-offset-test", "[highs_test_mip_solver]") {
@@ -625,6 +649,8 @@ TEST_CASE("MIP-max-offset-test", "[highs_test_mip_solver]") {
       highs.getInfo().objective_function_value;
   REQUIRE(objectiveOk(max_offset_optimal_objective, -offset_optimal_objective,
                       dev_run));
+
+  highs.resetGlobalScheduler(true);
 }
 
 TEST_CASE("MIP-get-saved-solutions-presolve", "[highs_test_mip_solver]") {
@@ -663,6 +689,8 @@ TEST_CASE("MIP-get-saved-solutions-presolve", "[highs_test_mip_solver]") {
     REQUIRE(saved_objective_and_solution[last_saved_solution].col_value[iCol] ==
             highs.getSolution().col_value[iCol]);
   std::remove(solution_file.c_str());
+
+  highs.resetGlobalScheduler(true);
 }
 
 TEST_CASE("IP-infeasible-unbounded", "[highs_test_mip_solver]") {
@@ -720,6 +748,8 @@ TEST_CASE("IP-infeasible-unbounded", "[highs_test_mip_solver]") {
     }
     highs.setOptionValue("presolve", kHighsOnString);
   }
+
+  highs.resetGlobalScheduler(true);
 }
 
 TEST_CASE("IP-with-fract-bounds-no-presolve", "[highs_test_mip_solver]") {
@@ -755,6 +785,8 @@ TEST_CASE("IP-with-fract-bounds-no-presolve", "[highs_test_mip_solver]") {
 
   // Infeasible
   REQUIRE(highs.getModelStatus() == HighsModelStatus::kInfeasible);
+
+  highs.resetGlobalScheduler(true);
 }
 
 bool objectiveOk(const double optimal_objective,
@@ -787,6 +819,8 @@ void solve(Highs& highs, std::string presolve,
                         require_optimal_objective, dev_run));
   }
   REQUIRE(highs.resetOptions() == HighsStatus::kOk);
+
+  highs.resetGlobalScheduler(true);
 }
 
 void distillationMIP(Highs& highs) {

check/TestPresolve.cpp

@@ -735,6 +735,32 @@ TEST_CASE("presolve-issue-2446", "[highs_test_presolve]") {
   REQUIRE(highs.getModelPresolveStatus() == HighsPresolveStatus::kReduced);
 }
 
+TEST_CASE("presolve-solve-postsolve-no-col-dual", "[highs_test_presolve]") {
+  Highs highs;
+  highs.setOptionValue("output_flag", dev_run);
+  std::string model_file =
+      std::string(HIGHS_DIR) + "/check/instances/afiro.mps";
+  highs.readModel(model_file);
+  highs.presolve();
+  HighsLp presolved_lp = highs.getPresolvedLp();
+  Highs highs1;
+  highs1.setOptionValue("output_flag", dev_run);
+  highs1.setOptionValue("presolve", kHighsOffString);
+  highs1.passModel(presolved_lp);
+  highs1.run();
+  HighsSolution solution = highs1.getSolution();
+
+  // Perform postsolve using the optimal solution and basis for the
+  // presolved model
+  REQUIRE(highs.postsolve(solution) == HighsStatus::kOk);
+
+  // If row duals are supplied, then column duals must also be suppplied
+  solution.col_dual.clear();
+  REQUIRE(highs.postsolve(solution) == HighsStatus::kError);
+
+  highs.resetGlobalScheduler(true);
+}
+
 TEST_CASE("presolve-egout-ac", "[highs_test_presolve]") {
   // Tests the case where, for this model when run_crossover is off,
   // sparsify is used to reduce the LP to empty. However, when
@@ -812,3 +838,27 @@ TEST_CASE("presolve-egout-ac", "[highs_test_presolve]") {
 
   h.resetGlobalScheduler(true);
 }
+
+TEST_CASE("dual-bound-tightening", "[highs_test_presolve]") {
+  std::string model_file =
+      std::string(HIGHS_DIR) + "/check/instances/gesa2.mps";
+
+  Highs highs;
+  highs.setOptionValue("output_flag", dev_run);
+  highs.readModel(model_file);
+
+  // complement variables to get code coverage
+  HighsLp lp = highs.getLp();
+  std::transform(lp.a_matrix_.value_.begin(), lp.a_matrix_.value_.end(),
+                 lp.a_matrix_.value_.begin(), [](double v) { return -v; });
+  std::transform(lp.col_cost_.begin(), lp.col_cost_.end(), lp.col_cost_.begin(),
+                 [](double v) { return -v; });
+  std::transform(lp.col_upper_.begin(), lp.col_upper_.end(),
+                 lp.col_upper_.begin(), [](double v) { return -v; });
+  std::transform(lp.col_lower_.begin(), lp.col_lower_.end(),
+                 lp.col_lower_.begin(), [](double v) { return -v; });
+  std::swap(lp.col_lower_, lp.col_upper_);
+
+  highs.passModel(lp);
+  REQUIRE(highs.presolve() == HighsStatus::kOk);
+}

check/TestSemiVariables.cpp

@@ -17,7 +17,7 @@ TEST_CASE("semi-variable-model", "[highs_test_semi_variables]") {
   const HighsInfo& info = highs.getInfo();
   HighsStatus return_status;
   double optimal_objective_function_value;
-  if (!dev_run) highs.setOptionValue("output_flag", false);
+  highs.setOptionValue("output_flag", dev_run);
   HighsModel model;
   HighsLp& lp = model.lp_;
   semiModel0(lp);

highs/Highs.h

@@ -1700,7 +1700,7 @@ class Highs {
   bool qFormatOk(const HighsInt num_nz, const HighsInt format);
   void clearZeroHessian();
   HighsStatus checkOptimality(const std::string& solver_type);
-  HighsStatus lpKktCheck(const std::string& message);
+  HighsStatus lpKktCheck(const HighsLp& lp, const std::string& message = "");
   HighsStatus invertRequirementError(std::string method_name) const;
 
   HighsStatus handleInfCost();