Large bounds test OK for LP/MIP/QP

Author: jajhall

check/TestUserScale.cpp

@@ -4,7 +4,7 @@
 #include "Highs.h"
 #include "catch.hpp"
 
-const bool dev_run = false;
+const bool dev_run = true;//false;
 const double inf = kHighsInf;
 
 bool doubleEqual0(const double v0, const double v1) {
@@ -283,41 +283,57 @@ TEST_CASE("ill-scaled-model", "[highs_user_scale]") {
     h.run();
   }
 
-  const bool all_test = true;
-  const bool lp_test = all_test || false;
-  const bool mip_test = all_test || true;
+  const bool all_test = true;//false;//
+  const bool lp_test = all_test || true;
+  const bool mip_test = all_test || false;
   const bool qp_test = all_test || false;
 
+  const bool ok_test = all_test || false;
   const double ok_cost = 1.0;
   const double ok_hessian = 1.0;
   const double ok_col_lower = 0.0;
   const double ok_bound = 1.0;
 
   // If the costs are too small, it becomes a feasibility problem,
   // so don't get the same objective value in testUserScale
-  const bool small_cost_test = true;
+  const bool small_cost_test = all_test || false;
   const double small_cost = 0.5e-4;
   const double small_hessian = 1e-4;
   const double small_col_lower = 1e-8;
+  const double large_cost = 1e8;
+  const double large_hessian = 1e4;
+  const double large_bound = 1e8;
   if (lp_test) {
-    if (dev_run)
-      printf(
-          "\n================\nill-scaled-model: LP test\n================\n");
-    testLp(h, ok_cost, ok_col_lower, ok_bound);
+    if (ok_test) {
+      if (dev_run)
+	printf(
+	       "\n================\nill-scaled-model: LP test\n================\n");
+      testLp(h, ok_cost, ok_col_lower, ok_bound);
+    }
     if (small_cost_test) {
       if (dev_run)
         printf(
             "\n================\nill-scaled-model: LP test - small costs and "
             "column LB\n================\n");
       testLp(h, small_cost, small_col_lower, ok_bound);
     }
+    if (dev_run)
+        printf(
+            "\n================\nill-scaled-model: LP test - large costs\n================\n");
+      testLp(h, large_cost, small_col_lower, ok_bound);
+    if (dev_run)
+        printf(
+            "\n================\nill-scaled-model: LP test - large bounds\n================\n");
+      testLp(h, ok_cost, small_col_lower, large_bound);
   }
 
   if (mip_test) {
-    if (dev_run)
-      printf(
-          "\n================\nill-scaled-model: MIP test\n================\n");
-    testMip(h, ok_cost, ok_col_lower, ok_bound);
+    if (ok_test) {
+      if (dev_run)
+	printf(
+	       "\n================\nill-scaled-model: MIP test\n================\n");
+      testMip(h, ok_cost, ok_col_lower, ok_bound);
+    }
 
     if (small_cost_test) {
       if (dev_run)
@@ -326,14 +342,32 @@ TEST_CASE("ill-scaled-model", "[highs_user_scale]") {
             "column LB\n================\n");
       testMip(h, small_cost, small_col_lower, ok_bound);
     }
+    if (dev_run)
+        printf(
+            "\n================\nill-scaled-model: MIP test - large costs\n================\n");
+      testMip(h, large_cost, small_col_lower, ok_bound);
+    if (dev_run)
+        printf(
+            "\n================\nill-scaled-model: MIP test - large bounds\n================\n");
+      testMip(h, ok_cost, small_col_lower, large_bound);
   }
 
   if (qp_test) {
-    if (dev_run)
-      printf(
-          "\n================\nill-scaled-model: QP test\n================\n");
-    testQp(h, ok_cost, ok_hessian, ok_col_lower, ok_bound);
+    if (ok_test) {
+      if (dev_run)
+	printf(
+	       "\n================\nill-scaled-model: QP test\n================\n");
+      testQp(h, ok_cost, ok_hessian, ok_col_lower, ok_bound);
+    }
     // QP solver can't handle small costs and Hessian
+    if (dev_run)
+        printf(
+            "\n================\nill-scaled-model: QP test - large costs\n================\n");
+      testQp(h, large_cost, ok_hessian, ok_col_lower, ok_bound);
+    if (dev_run)
+        printf(
+            "\n================\nill-scaled-model: QP test - large bounds\n================\n");
+      testQp(h, ok_cost, ok_hessian, small_col_lower, large_bound);
   }
 
   h.resetGlobalScheduler(true);

highs/lp_data/Highs.cpp

@@ -963,7 +963,7 @@ HighsStatus Highs::run() {
   // and user_bound_scale
   assessExcessiveObjectiveBoundScaling(this->options_.log_options, this->model_,
                                        user_scale_data);
-  //  this->writeModel("");
+  this->writeModel("");
   HighsStatus status;
   if (!this->multi_linear_objective_.size()) {
     status = this->optimizeModel();

highs/lp_data/HighsSolve.cpp

@@ -526,7 +526,7 @@ void assessExcessiveObjectiveBoundScaling(const HighsLogOptions log_options,
     highsLogUser(log_options, HighsLogType::kWarning,
                  "%s has some excessively large row bounds\n", problem.c_str());
 
-  // Determine recommended user scaling values
+  // Lambda to determine recommended user scaling values
   auto suggestScaling = [&](double min_value, double max_value,
                             double small_value, double large_value) {
     double ratio = 1;
@@ -543,17 +543,33 @@ void assessExcessiveObjectiveBoundScaling(const HighsLogOptions log_options,
     return ratio;
   };
 
+  // Lambda to for outward rounding of log
+  auto outerRoundedLog = [&](const double value, const HighsInt base) {
+    assert(value > 0);
+    assert(base == 2 || base == 10);
+    HighsInt rounded_log = 0;
+    if (base == 2) {
+      rounded_log = value < 1 ?
+	std::floor(std::log2(value)) :
+	std::ceil(std::log2(value));
+    } else {
+      rounded_log = value < 1 ?
+	std::floor(std::log10(value)) :
+	std::ceil(std::log10(value));
+    }
+    return rounded_log;
+  };
   double suggested_bound_scaling = suggestScaling(
       min_scalable_bound, max_scalable_bound, small_bound, large_bound);
   // Determine the suggested (new) value for user_bound_scale,
   // allowing for the fact that the current value has been applied
-  HighsInt dl_user_bound_scale = std::ceil(std::log2(suggested_bound_scaling));
+  HighsInt dl_user_bound_scale = outerRoundedLog(suggested_bound_scaling, 2);
   user_scale_data.suggested_user_bound_scale =
       user_scale_data.user_bound_scale + dl_user_bound_scale;
   // Determine the order of magnitude of the suggested bound scaling -
   // just for logging
   HighsInt suggested_bound_scale_order_of_magnitude =
-      std::ceil(std::log10(suggested_bound_scaling));
+    outerRoundedLog(suggested_bound_scaling, 10);
   // Applying the suggested bound scaling requires the costs and
   // matrix columns of non-continuous variables to be scaled, and any
   // Hessian entries are also scaled
@@ -582,14 +598,13 @@ void assessExcessiveObjectiveBoundScaling(const HighsLogOptions log_options,
                      small_objective_coefficient, large_objective_coefficient);
   // Determine the suggested (new) value for user_objective_scale,
   // allowing for the fact that the current value has been applied
-  HighsInt dl_user_objective_scale =
-      std::ceil(std::log2(suggested_objective_scaling));
+  HighsInt dl_user_objective_scale = outerRoundedLog(suggested_objective_scaling, 2);
   user_scale_data.suggested_user_objective_scale =
       user_scale_data.user_objective_scale + dl_user_objective_scale;
   // Determine the order of magnitude of the suggested objective scaling -
   // just for logging
   HighsInt suggested_objective_scale_order_of_magnitude =
-      std::ceil(std::log10(suggested_objective_scaling));
+      outerRoundedLog(suggested_objective_scaling, 10);
 
   // Only report the order of magnitude scaling if there is no user
   // scaling