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

Author: fwesselm

check/TestCheckSolution.cpp

@@ -78,7 +78,9 @@ TEST_CASE("check-set-mip-solution", "[highs_check_solution]") {
       std::string(HIGHS_DIR) + "/check/instances/" + model + ".mps";
   Highs highs;
   const HighsInfo& info = highs.getInfo();
-  if (dev_run) printf("\n********************\nSolving from scratch\n");
+  if (dev_run)
+    printf(
+        "\n********************\nSolving from scratch\n********************\n");
   highs.setOptionValue("output_flag", dev_run);
   highs.readModel(model_file);
   HighsLp lp = highs.getLp();
@@ -92,7 +94,7 @@ TEST_CASE("check-set-mip-solution", "[highs_check_solution]") {
 
   std::string solution_file = test_name + model + ".sol";
   if (dev_run) REQUIRE(highs.writeSolution("") == HighsStatus::kOk);
-  ;
+
   REQUIRE(highs.writeSolution(solution_file) == HighsStatus::kOk);
 
   highs.clear();
@@ -102,7 +104,9 @@ TEST_CASE("check-set-mip-solution", "[highs_check_solution]") {
   bool valid, integral, feasible;
   if (test0) {
     if (dev_run)
-      printf("\n***************************\nSolving from saved solution\n");
+      printf(
+          "\n***************************\nSolving from saved "
+          "solution\n***************************\n");
     highs.setOptionValue("output_flag", dev_run);
     highs.readModel(model_file);
 
@@ -124,7 +128,9 @@ TEST_CASE("check-set-mip-solution", "[highs_check_solution]") {
   const bool test1 = other_tests;
   if (test1) {
     if (dev_run)
-      printf("\n***************************\nSolving from solution file\n");
+      printf(
+          "\n**************************\nSolving from solution "
+          "file\n**************************\n");
     highs.setOptionValue("output_flag", dev_run);
     highs.readModel(model_file);
 
@@ -147,8 +153,8 @@ TEST_CASE("check-set-mip-solution", "[highs_check_solution]") {
   if (test2) {
     if (dev_run)
       printf(
-          "\n***************************\nSolving from saved integer "
-          "solution\n");
+          "\n***********************************\nSolving from saved integer "
+          "solution\n***********************************\n");
     highs.setOptionValue("output_flag", dev_run);
     highs.readModel(model_file);
 
@@ -180,7 +186,8 @@ TEST_CASE("check-set-mip-solution", "[highs_check_solution]") {
   if (test3) {
     if (dev_run)
       printf(
-          "\n***************************\nSolving from column solution file\n");
+          "\n*********************************\nSolving from column solution "
+          "file\n*********************************\n");
     std::string column_solution_file =
         std::string(HIGHS_DIR) + "/check/instances/flugpl_integer.sol";
 
@@ -206,8 +213,9 @@ TEST_CASE("check-set-mip-solution", "[highs_check_solution]") {
   if (test4) {
     if (dev_run)
       printf(
-          "\n***************************\nSolving from illegal column solution "
-          "file\n");
+          "\n*****************************************\nSolving from illegal "
+          "column solution "
+          "file\n*****************************************\n");
     std::string column_solution_file =
         std::string(HIGHS_DIR) + "/check/instances/flugpl_illegal_integer.sol";
 
@@ -225,8 +233,9 @@ TEST_CASE("check-set-mip-solution", "[highs_check_solution]") {
     HighsSolution starting_solution = optimal_solution;
     if (dev_run)
       printf(
-          "\n***************************\nSolving from partial integer "
-          "solution\n");
+          "\n*************************************\nSolving from partial "
+          "integer "
+          "solution\n*************************************\n");
     highs.setOptionValue("output_flag", dev_run);
     highs.readModel(model_file);
 
@@ -256,8 +265,8 @@ TEST_CASE("check-set-mip-solution", "[highs_check_solution]") {
   if (test6) {
     if (dev_run)
       printf(
-          "\n***************************\nSolving from sparse integer "
-          "solution\n");
+          "\n************************************\nSolving from sparse integer "
+          "solution\n************************************\n");
     HighsInt num_integer_variable = 0;
     for (HighsInt iCol = 0; iCol < lp.num_col_; iCol++)
       if (lp.integrality_[iCol] == HighsVarType::kInteger)

check/TestMipSolver.cpp

@@ -1483,3 +1483,125 @@ TEST_CASE("issue-2975", "[highs_test_mip_solver]") {
 
   highs.resetGlobalScheduler(true);
 }
+
+TEST_CASE("issue-3118", "[highs_test_mip_solver]") {
+  const double M = 1e10;
+  //   min    x +   y
+  //   s.t.   x + M*y = 1
+  //        M*x +   y = 1
+  //          x, y binary
+  //   Initial "solution" x = y = 1/M
+  //
+  // This problem is found infeasible in presolve, but the point x = y
+  // = 1/M is integer feasible to within the tolerances, so is
+  // acccepted as an optimal solution to the problem
+  Highs highs;
+  highs.setOptionValue("output_flag", dev_run);
+
+  HighsInt x = 0;
+  HighsInt y = 1;
+  HighsLp lp;
+  lp.num_col_ = 2;
+  lp.num_row_ = 2;
+  lp.col_lower_ = {0., 0.};
+  lp.col_upper_ = {1., 1.};
+  lp.col_cost_ = {1., 1.};
+  lp.integrality_ = {HighsVarType::kInteger, HighsVarType::kInteger};
+  lp.row_lower_ = {1., 1.};
+  lp.row_upper_ = {1., 1.};
+  lp.a_matrix_.format_ = MatrixFormat::kRowwise;
+  lp.a_matrix_.start_ = {0, 2, 4};
+  lp.a_matrix_.index_ = {x, y, x, y};
+  lp.a_matrix_.value_ = {1., M, M, 1};
+  highs.passModel(lp);
+
+  std::vector<double> solution_values(lp.num_col_, 1 / M);
+  highs.setSolution(2, nullptr, solution_values.data());
+
+  highs.run();
+  REQUIRE(highs.getModelStatus() == HighsModelStatus::kOptimal);
+  REQUIRE(std::abs(2 / M - highs.getInfo().objective_function_value) < 1e-9);
+  if (dev_run) highs.writeSolution("", 1);
+
+  highs.resetGlobalScheduler(true);
+}
+
+TEST_CASE("issue-3118a", "[highs_test_mip_solver]") {
+  const double M = 1e10;
+  //   max f = x
+  //   s.t.    x - M*y  = -1
+  //           x       <=  b
+  //           x, y integer in [0, 2]x[0, 1]
+  //
+  // The MIP is not feasible over the integers for any b
+  //
+  // With initial "solution" x = 0; y = 1/M
+  //
+  // For b = 0: (0, 1/M) with f = 0 is the only feasible solution of
+  // the relaxation, and it's also feasible for the MIP, so claiming
+  // it is optimal when presolve identifies infeasibility is clearly
+  // justified
+  //
+  // For b = 1: (1, 2/M) with f = 1 is the optimal solution of the
+  // relaxation, and it's also feasible for the MIP. However, claiming
+  // that the initial "solution" (0, 1/M) with f = 0 is optimal when
+  // presolve identifies infeasibility is still justified, because
+  // it's a point that is feasible for a MIP that is deemed infeasible
+  // by presolve
+  Highs highs;
+  highs.setOptionValue("output_flag", dev_run);
+
+  HighsInt x = 0;
+  HighsInt y = 1;
+  HighsLp lp;
+  lp.sense_ = ObjSense::kMaximize;
+  lp.num_col_ = 2;
+  lp.num_row_ = 2;
+  lp.col_lower_ = {0, 0};
+  lp.col_upper_ = {2, 1};
+  lp.col_cost_ = {1, 0};
+  lp.integrality_ = {HighsVarType::kInteger, HighsVarType::kInteger};
+  lp.row_lower_ = {-1, -kHighsInf};
+  lp.row_upper_ = {-1, 0};
+  lp.a_matrix_.format_ = MatrixFormat::kRowwise;
+  lp.a_matrix_.start_ = {0, 2, 3};
+  lp.a_matrix_.index_ = {x, y, x};
+  lp.a_matrix_.value_ = {1., -M, 1};
+
+  for (HighsInt k = 0; k < 2; k++) {
+    HighsInt b = k == 0 ? 0 : 1;
+    lp.row_upper_[1] = b;
+
+    highs.passModel(lp);
+
+    // Solve as MIP
+    if (dev_run)
+      printf("================\nCase b = %d (MIP)\n================\n", int(b));
+    highs.setOptionValue("solve_relaxation", false);
+    std::vector<double> solution_values = {0, 1 / M};
+    highs.setSolution(2, nullptr, solution_values.data());
+
+    highs.run();
+    if (dev_run) highs.writeSolution("", 1);
+    REQUIRE(highs.getModelStatus() == HighsModelStatus::kOptimal);
+
+    // Solve as LP
+    if (dev_run)
+      printf("===============\nCase b = %d (LP)\n===============\n", int(b));
+    highs.setOptionValue("solve_relaxation", true);
+    highs.clearSolver();
+    highs.run();
+    highs.writeSolution("", 1);
+    REQUIRE(highs.getModelStatus() == HighsModelStatus::kOptimal);
+    double lp_objective_value = highs.getInfo().objective_function_value;
+
+    solution_values = highs.getSolution().col_value;
+    highs.setSolution(2, nullptr, solution_values.data());
+
+    bool valid, integral, feasible;
+    REQUIRE(highs.assessPrimalSolution(valid, integral, feasible) ==
+            HighsStatus::kOk);
+  }
+
+  highs.resetGlobalScheduler(true);
+}

docs/src/callbacks.md

@@ -154,7 +154,7 @@ The `HighsCallbackDataOut` struct supplies data to the user that is
 relevant to the particular callback. The general data are
 
 * `log_type`: An integer cast of the `HighsLogType` value, indicating the severity of the logging message--relevant to the logging callback.
-* `running_time`: The excution time of HiGHS--relevant to the interrupt callbacks.
+* `running_time`: The execution time of HiGHS--relevant to the interrupt callbacks.
 * `simplex_iteration_count`: The number of simplex iterations performed--relevant to the simplex interrupt callback.
 * `ipm_iteration_count`: The number of IPM iterations performed--relevant to the IPM interrupt callback.
 * `pdlp_iteration_count`: The number of PDLP iterations performed--relevant to the PDLP interrupt callback.

docs/src/guide/further.md

@@ -139,11 +139,11 @@ lexicographic optimization according to the truth of the
 linear objective is represented by the following data, held in the
 [HighsLinearObjective](@ref HighsLinearObjective) structure
 
-- weight: Scalar of type double - The weight of this objective when blending 
+- weight: Scalar of type double - The weight of this objective when blending
 - offset: Scalar of type double - The offset of this objective
 - coefficients: Vector of type double - The coefficients of this objective
-- abs\_tolerance: Scalar of type double - The absolute tolerance on this objective when performing lexicographic optimization 
-- rel\_tolerance: Scalar of type double - The relative tolerance on this objective when performing lexicographic optimization 
+- abs\_tolerance: Scalar of type double - The absolute tolerance on this objective when performing lexicographic optimization
+- rel\_tolerance: Scalar of type double - The relative tolerance on this objective when performing lexicographic optimization
 - priority: Scalar of type HighsInt - The priority of this objective when performing lexicographic optimization
 
 ### Methods
@@ -174,7 +174,7 @@ priority values must be distinct_.
 
 * Minimize/maximize with respect to the linear objective of highest priority value, according to whether its `weight` is positive/negative
 
-* Add a constraint to the model so that the value of the linear objective of highest priority satsifies a bound given by the values of `abs_tolerance` and/or `rel_tolerance`.
+* Add a constraint to the model so that the value of the linear objective of highest priority satisfies a bound given by the values of `abs_tolerance` and/or `rel_tolerance`.
     + If the objective was minimized to a value ``f^*\ge0``, then the constraint ensures that the this objective value is no greater than ``\min(f^*+abs\_tolerance,~f^*\times[1+rel\_tolerance]).``
 
     + If the objective was minimized to a value ``f^*<0``, then the constraint ensures that the this objective value is no greater than ``\min(f^*+abs\_tolerance,~f^*\times[1-rel\_tolerance]).``
@@ -189,5 +189,3 @@ Note
 
 * Negative values of `abs_tolerance` and `rel_tolerance` will be ignored. This is a convenient way of "switching off" a bounding technique that is not of interest.
 * When the model is continuous, no dual information will be returned if there is more than one linear objective.
-
-

docs/src/guide/numerics.md

@@ -2,7 +2,7 @@
 
 Optimization solvers cannot be expected to find the exact solution of
 a problem, since it may not be possible to represent that solution
-using floating-point arithemtic. However, solvers will typically run
+using floating-point arithmetic. However, solvers will typically run
 faster and find more accurate solutions if the problem has good
 numerical properties. Ideally the optimal value of all primal
 variables (and dual variables when relevant) will be of order
@@ -52,4 +52,4 @@ is achieved implicitly by scaling their cost and matrix
 coefficients. Also, when bounds on variables in a quadratic
 programming problem are scaled up (down), the values in the Hessian
 matrix must be scaled down (up) so that the overall scaling of the
-objective is uniform.
+objective is uniform.

docs/src/installation.md

@@ -89,7 +89,7 @@ cmake -S. -B build -DHIPO=ON -DCMAKE_TOOLCHAIN_FILE="C:/vcpkg/scripts/buildsyste
 
 ##### Path to BLAS
 
-To specify explicitly which BLAS vendor to look for, `BLA_VENDOR` coud be set in CMake, e.g. `-DBLA_VENDOR=Apple` or `-DBLA_VENDOR=OpenBLAS`. Alternatively, to specify which BLAS library to use, set `BLAS_LIBRARIES` to the full path of the library e.g. `-DBLAS_LIBRARIES=/path_to/libopenblas.so`.
+To specify explicitly which BLAS vendor to look for, `BLA_VENDOR` could be set in CMake, e.g. `-DBLA_VENDOR=Apple` or `-DBLA_VENDOR=OpenBLAS`. Alternatively, to specify which BLAS library to use, set `BLAS_LIBRARIES` to the full path of the library e.g. `-DBLAS_LIBRARIES=/path_to/libopenblas.so`.
 
 
 ## [Building HiGHS with NVidia GPU support](@id gpu-build)
@@ -129,4 +129,4 @@ It may be necessary to also specify the architecture, e.g.
 
 ```
 bazel build //... --//:cupdlp_gpu --@rules_cuda//cuda:archs=sm_89
-```
+```

docs/src/interfaces/python/model-py.md

@@ -1,6 +1,6 @@
 # [Modelling](@id model-py)
 
-HiGHS has a rudimentry modelling language that allows models to be built and run using `highspy`. 
+HiGHS has a rudimentary modelling language that allows models to be built and run using `highspy`.
 
 Below is an example of building a mathematical LP. The functions used are documented in detail below
 ```
@@ -84,7 +84,3 @@ vals(vars)
 ```
 
 ## MIP Example
-
-
-
-

docs/src/terminology.md

@@ -58,7 +58,7 @@ which case the optimal solution is said to be __non-unique__.
 
 ## Primal values
 
-The values of the decision variables are referred to as __primal__ values to distingush them from __dual__ values.
+The values of the decision variables are referred to as __primal__ values to distinguish them from __dual__ values.
 
 ## Dual values
 
@@ -160,4 +160,3 @@ relative to the primal bound is a better measure. When the gap reaches
 zero then the MIP is solved to optimality. However, it is often
 preferable to stop the MIP solver when the relative gap is below a
 specified tolerance.
-

highs/Highs.h

@@ -266,8 +266,11 @@ class Highs {
 
   /**
    * @brief Assess the validity, integrality and feasibility of the
-   * current primal solution. Of value after calling
-   * Highs::readSolution
+   * current primal solution. Row values are computed and checked
+   * against what's in Highs::solution_.row_value and, if the
+   * differences exceed a tolerance, valid returns false.  If any of
+   * valid, integral or feasible is false, then assessPrimalSolution
+   * returns HighsStatus::kWarning.
    */
   HighsStatus assessPrimalSolution(bool& valid, bool& integral,
                                    bool& feasible) const;
@@ -1245,7 +1248,15 @@ class Highs {
   HighsStatus setSolution(const HighsSolution& solution);
 
   /**
-   * @brief Pass a sparse primal solution
+   * @brief Pass a primal solution. If index is not a null pointer,
+   * then it is assumed that value contains num_entries of packed
+   * values, with index defing the corresponding primal solution
+   * components. If index is a null pointer, then value is assumed to
+   * be a full primal solution.
+   *
+   * It allows a full primal solution to be passed (for MIPs) without
+   * requiring either a HighsSolution that contains (empty vectors of)
+   * spurious dual information, or a full list of indices
    */
   HighsStatus setSolution(const HighsInt num_entries, const HighsInt* index,
                           const double* value);