Assed applied to HighsUserScaleData

Author: jajhall

check/TestUserScale.cpp

@@ -79,7 +79,15 @@ TEST_CASE("user-small-cost-scale", "[highs_user_scale]") {
   lp.a_matrix_.start_ = {0, 2, 4};
   lp.a_matrix_.index_ = {0, 1, 0, 1};
   lp.a_matrix_.value_ = {1, 1, 2, 4};
+
+  HighsInt suggested_cost_scale;
+  HighsInt suggested_bound_scale;
+  highs.getCostBoundScaling(suggested_cost_scale, suggested_bound_scale);
+
   highs.passModel(lp);
+
+  highs.getCostBoundScaling(suggested_cost_scale, suggested_bound_scale);
+
   highs.run();
   REQUIRE(solution.col_value[0] == 40);
   REQUIRE(solution.col_value[1] == 20);

highs/Highs.h

@@ -575,6 +575,12 @@ class Highs {
                                  const HighsInt method = 0,
                                  const double ill_conditioning_bound = 1e-4);
 
+  /**
+   * @brief Get the suggested cost and bound scaling for the incumbent model
+   */
+  HighsStatus getCostBoundScaling(HighsInt& suggested_cost_scale,
+				  HighsInt& suggested_bound_scale);
+
   /**
    * @brief Get (any) irreducible infeasible subsystem (IIS)
    * information for the incumbent model

highs/lp_data/HConst.h

@@ -34,10 +34,16 @@ const std::string kHighsOnString = "on";
 const HighsInt kHighsMaxStringLength = 512;
 const HighsInt kSimplexConcurrencyLimit = 8;
 const double kRunningAverageMultiplier = 0.05;
-const double kExcessivelyLargeBoundValue = 1e10;
-const double kExcessivelyLargeCostValue = 1e10;
-const double kExcessivelySmallBoundValue = 1e-4;
+
 const double kExcessivelySmallCostValue = 1e-4;
+const double kExcessivelySmallBoundValue = 1e-4;
+const double kExcessivelyLargeCostValue = 1e10;
+const double kExcessivelyLargeBoundValue = 1e10;
+
+const double kOkSmallCostValue = 0.5;
+const double kOkSmallBoundValue = 0.5;
+const double kOkLargeCostValue = 2.0;
+const double kOkLargeBoundValue = 2.0;
 
 const HighsInt kNoThreadInstance = -1;
 const bool kAllowDeveloperAssert = false;

highs/lp_data/HStruct.h

@@ -198,6 +198,7 @@ struct HighsUserScaleData {
   HighsInt num_large_matrix_values;
   HighsInt suggested_user_cost_scale;
   HighsInt suggested_user_bound_scale;
+  bool applied;
   void initialise(const HighsInt& user_cost_scale_,
                   const HighsInt& user_bound_scale_,
                   const double& infinite_cost_, const double& infinite_bound_,

highs/lp_data/Highs.cpp

@@ -951,17 +951,16 @@ HighsStatus Highs::run() {
     if (this->userScaleModel(user_scale_data) == HighsStatus::kError)
       return HighsStatus::kError;
     this->userScaleSolution(user_scale_data);
+    // Indicate that the scaling has been applied
+    user_scale_data.applied = true;
     // Zero the user scale values to prevent further scaling
     this->options_.user_cost_scale = 0;
     this->options_.user_bound_scale = 0;
   }
 
   // Assess whether to warn the user about excessive bounds and costs
-  assessCostBoundScaling(this->options_.log_options, this->model_,
-			 kExcessivelySmallCostValue,
-			 kExcessivelyLargeCostValue,
-			 kExcessivelySmallBoundValue,
-			 kExcessivelyLargeBoundValue,
+  assessCostBoundScaling(this->options_.log_options,
+			 this->model_,
 			 user_scale_data);
 
   HighsStatus status;
@@ -1002,6 +1001,8 @@ HighsStatus Highs::run() {
     // negated to undo user scaling
     this->options_.user_cost_scale = -user_scale_data.user_cost_scale;
     this->options_.user_bound_scale = -user_scale_data.user_bound_scale;
+    // Indicate that the scaling has not been applied
+    user_scale_data.applied = false;
     highsLogUser(this->options_.log_options, HighsLogType::kInfo,
                  "After solving the user-scaled model, the unscaled solution "
                  "has objective value %.12g\n",
@@ -2009,6 +2010,20 @@ HighsStatus Highs::getIllConditioning(HighsIllConditioning& ill_conditioning,
                                 ill_conditioning_bound);
 }
 
+HighsStatus Highs::getCostBoundScaling(HighsInt& suggested_cost_scale,
+				       HighsInt& suggested_bound_scale) {
+  this->logHeader();
+  HighsUserScaleData data;
+  initialiseUserScaleData(this->options_, data);
+  assessCostBoundScaling(this->options_.log_options, this->model_,
+			 data, false);
+  suggested_cost_scale = data.suggested_user_cost_scale;
+  suggested_bound_scale = data.suggested_user_bound_scale;
+  printf("Highs::getCostBoundScaling suggested cost / bound scale values of %d / %d\n",
+	 int(suggested_cost_scale), int(suggested_bound_scale));
+  return HighsStatus::kOk;
+}
+
 HighsStatus Highs::getIis(HighsIis& iis) {
   HighsStatus return_status = this->getIisInterface();
   if (return_status != HighsStatus::kError) iis = this->iis_;

highs/lp_data/HighsLpUtils.cpp

@@ -3686,6 +3686,7 @@ void HighsUserScaleData::initialise(const HighsInt& user_cost_scale_,
   this->num_large_matrix_values = 0;
   this->suggested_user_cost_scale = 0;
   this->suggested_user_bound_scale = 0;
+  this->applied = false;
 }
 
 bool HighsUserScaleData::scaleError(std::string& message) const {

highs/lp_data/HighsSolve.cpp

@@ -349,12 +349,13 @@ HighsStatus solveUnconstrainedLp(const HighsOptions& options, const HighsLp& lp,
 // recommendations
 void assessCostBoundScaling(const HighsLogOptions log_options,
 			    const HighsModel& model,
-			    const double small_cost,
-			    const double large_cost,
-			    const double small_bound,
-			    const double large_bound,
-			    HighsUserScaleData& user_scale_data) {
+			    HighsUserScaleData& user_scale_data,
+			    const bool excessive) {
   const bool user_cost_or_bound_scale = user_scale_data.user_cost_scale || user_scale_data.user_bound_scale;
+  const double small_cost = excessive ? kExcessivelySmallCostValue : kOkSmallCostValue;
+  const double large_cost = excessive ? kExcessivelyLargeCostValue : kOkLargeCostValue;
+  const double small_bound = excessive ? kExcessivelySmallBoundValue : kOkSmallBoundValue;
+  const double large_bound = excessive ? kExcessivelyLargeBoundValue : kOkLargeBoundValue;
   std::stringstream message;
   if (user_cost_or_bound_scale) {
     if (user_scale_data.user_cost_scale)
@@ -502,7 +503,7 @@ void assessCostBoundScaling(const HighsLogOptions log_options,
       // All scalable values are excessively large, so obviously suggest
       // scaling them down
       ratio = 1.0 / min_value;
-      assert(0 == 11);
+      //assert(0 == 11);
     } else if (0 < max_value && max_value < small_value) {
       // All scalable values are excessively small, so obviously suggest
       // scaling them up
@@ -516,12 +517,12 @@ void assessCostBoundScaling(const HighsLogOptions log_options,
 	  ratio = 1.0 / max_value;
 	  if (ratio * min_value < small_value) {
 	    ratio = std::sqrt(1.0 / (max_value * min_value));
-	    assert(0 == 325);
+	    //assert(0 == 325);
 	  }
-	  assert(0 == 33);
+	  //assert(0 == 33);
 	} else {
 	  ratio = 1.0 / max_value;
-	  assert(0 == 44);
+	  //assert(0 == 44);
 	}
       } else if (0 < min_value && min_value < small_value) {
 	// Min value is excessively small, so look to scale it up,
@@ -531,12 +532,12 @@ void assessCostBoundScaling(const HighsLogOptions log_options,
 	  ratio = 1.0 / min_value;
 	  if (ratio * max_value > large_value) {
 	    ratio = std::sqrt(1.0 / (max_value * min_value));
-	    assert(0 == 545);
+	    //assert(0 == 545);
 	  }
-	  assert(0 == 55);
+	  //assert(0 == 55);
 	} else {
 	  ratio = 1.0 / min_value;	  
-	  assert(0 == 66);
+	  //assert(0 == 66);
 	}
       }	
     }

highs/lp_data/HighsSolve.h

@@ -20,9 +20,6 @@ HighsStatus solveUnconstrainedLp(const HighsOptions& options, const HighsLp& lp,
                                  HighsBasis& basis);
 void assessCostBoundScaling(const HighsLogOptions log_options,
 			    const HighsModel& model,
-			    const double small_cost,
-			    const double large_cost,
-			    const double small_bound,
-			    const double large_bound,
-			    HighsUserScaleData& user_scale_data);
+			    HighsUserScaleData& user_scale_data,
+			    const bool excesive = true);
 #endif  // LP_DATA_HIGHSSOLVE_H_