Removed user_cost_scale_ and user_bound_scale_ from HighsLp

Author: jajhall

check/TestUserScale.cpp

@@ -167,8 +167,6 @@ void checkLpScaling(const HighsInt user_bound_scale,
   const double user_cost_scale_value = std::pow(2, user_cost_scale);
   REQUIRE(unscaled_lp.num_col_ == scaled_lp.num_col_);
   REQUIRE(unscaled_lp.num_row_ == scaled_lp.num_row_);
-  REQUIRE(scaled_lp.user_cost_scale_ == user_cost_scale);
-  REQUIRE(scaled_lp.user_bound_scale_ == user_bound_scale);
   const bool has_integrality = scaled_lp.integrality_.size() > 0;
   const HighsSparseMatrix& unscaled_matrix = unscaled_lp.a_matrix_;
   REQUIRE(unscaled_matrix.isColwise());

highs/lp_data/Highs.cpp

@@ -379,10 +379,6 @@ HighsStatus Highs::passModel(HighsModel model) {
   // model object for this LP
   return_status = interpretCallStatus(options_.log_options, clearSolver(),
                                       return_status, "clearSolver");
-  // Apply any user scaling in call to optionChangeAction
-  return_status =
-      interpretCallStatus(options_.log_options, optionChangeAction(),
-                          return_status, "optionChangeAction");
   return returnFromHighs(return_status);
 }
 
@@ -536,20 +532,6 @@ HighsStatus Highs::passHessian(HighsHessian hessian_) {
   // number of columns in the model is completed
   if (hessian.dim_) completeHessian(this->model_.lp_.num_col_, hessian);
 
-  if (this->model_.lp_.user_cost_scale_) {
-    // Assess and apply any user cost scaling
-    if (!hessian.scaleOk(this->model_.lp_.user_cost_scale_,
-                         this->options_.small_matrix_value,
-                         this->options_.large_matrix_value)) {
-      highsLogUser(
-          options_.log_options, HighsLogType::kError,
-          "User cost scaling yields zeroed or excessive Hessian values\n");
-      return HighsStatus::kError;
-    }
-    double cost_scale_value = std::pow(2, this->model_.lp_.user_cost_scale_);
-    for (HighsInt iEl = 0; iEl < hessian.numNz(); iEl++)
-      hessian.value_[iEl] *= cost_scale_value;
-  }
   return_status = interpretCallStatus(options_.log_options, clearSolver(),
                                       return_status, "clearSolver");
   return returnFromHighs(return_status);
@@ -1055,11 +1037,8 @@ HighsStatus Highs::optimizeModel() {
     return HighsStatus::kError;
   }
 
-  // Check whether model is consistent with any user bound/cost scaling
-  assert(this->model_.lp_.user_bound_scale_ == this->options_.user_bound_scale);
-  assert(this->model_.lp_.user_cost_scale_ == this->options_.user_cost_scale);
   // Assess whether to warn the user about excessive bounds and costs
-  assessExcessiveBoundCost(options_.log_options, this->model_);
+  assessExcessiveBoundCost(this->options_, this->model_);
 
   // HiGHS solvers require models with no infinite costs, and no semi-variables
   //

highs/lp_data/HighsInterface.cpp

@@ -2987,6 +2987,7 @@ void Highs::restoreInfCost(HighsStatus& return_status) {
 // Update model status, data and solution with respect to non-trivial
 // user bound/cost scaling
 HighsStatus Highs::optionChangeAction() {
+  /*
   HighsModel& model = this->model_;
   HighsLp& lp = model.lp_;
   HighsInfo& info = this->info_;
@@ -3016,6 +3017,7 @@ HighsStatus Highs::optionChangeAction() {
     lp.user_cost_scale_ = options.user_cost_scale;
     lp.user_bound_scale_ = options.user_bound_scale;
   }
+  */
   return HighsStatus::kOk;
 }
 

highs/lp_data/HighsLp.cpp

@@ -220,9 +220,6 @@ void HighsLp::clear() {
   this->col_hash_.clear();
   this->row_hash_.clear();
 
-  this->user_cost_scale_ = 0;
-  this->user_bound_scale_ = 0;
-
   this->clearScale();
   this->is_scaled_ = false;
   this->is_moved_ = false;

highs/lp_data/HighsLp.h

@@ -50,8 +50,6 @@ class HighsLp {
   HighsNameHash col_hash_;
   HighsNameHash row_hash_;
 
-  HighsInt user_bound_scale_;
-  HighsInt user_cost_scale_;
   HighsScale scale_;
   bool is_scaled_;
   bool is_moved_;

highs/lp_data/HighsLpUtils.cpp

@@ -1734,31 +1734,11 @@ HighsStatus changeLpIntegrality(HighsLp& lp,
   HighsInt lp_col;
   HighsInt usr_col = -1;
 
-  HighsUserScaleData user_scale_data;
-  std::vector<HighsVarType> save_integrality;
-  if (lp.integrality_.size() == 0) {
-    // Changing integrality for a problem without an integrality
-    // vector (ie an LP), have to create it for the incumbent columns
-    // - which are naturally continuous
+ // If changing integrality for a problem without an integrality
+ // vector (ie an LP), have to create it for the incumbent columns -
+ // which are naturally continuous
+  if (lp.integrality_.size() == 0) 
     lp.integrality_.assign(lp.num_col_, HighsVarType::kContinuous);
-  } else if (lp.user_bound_scale_) {
-    // Save a copy of lp.integrality_ in case it needs to be reverted
-    // due to ultimate illegal scaling
-    save_integrality = lp.integrality_;
-    // Revert the user bound scaling to correspond to an LP...
-    //
-    // Use -lp.user_bound_scale_U to unscale the costs and matrix
-    // columns, and the continuous bounds
-    //
-    // Set up HighsUserScaleData, noting that any user cost scaling is
-    // unaffected
-    initialiseUserScaleData(lp, options, user_scale_data);
-    user_scale_data.user_cost_scale = 0;
-    user_scale_data.user_bound_scale = -lp.user_bound_scale_;
-    // Scale, forcing changes of value
-    const bool apply = true;
-    userScaleLp(lp, user_scale_data, apply);
-  }
 
   assert(HighsInt(lp.integrality_.size()) == lp.num_col_);
   for (HighsInt k = from_k; k < to_k + 1; k++) {
@@ -1778,23 +1758,7 @@ HighsStatus changeLpIntegrality(HighsLp& lp,
   }
   // If integrality_ contains only HighsVarType::kContinuous then
   // clear it
-  if (!lp.isMip()) {
-    lp.integrality_.clear();
-  } else if (lp.user_bound_scale_) {
-    // ... and then reapply corresponding to the new integrality
-    //
-    // Use lp.user_bound_scale_ to scale the costs and matrix columns,
-    // and the continuous bounds
-    user_scale_data.user_bound_scale = lp.user_bound_scale_;
-    
-    // Scale, first checking and reporting illegal values, then
-    // forcing changes of value if no illegal values
-    return_status = userScaleLp(lp, user_scale_data, options.log_options);
-    if (return_status == HighsStatus::kError) {
-      lp.integrality_ = save_integrality;
-      return HighsStatus::kError;
-    }
-  }
+  if (!lp.isMip()) lp.integrality_.clear();
   return return_status;
 }
 
@@ -3695,9 +3659,9 @@ void getSubVectorsTranspose(const HighsIndexCollection& index_collection,
   }
 }
 
-void initialiseUserScaleData(const HighsLp& lp, const HighsOptions& options,
+void initialiseUserScaleData(const HighsOptions& options,
                              HighsUserScaleData& user_scale_data) {
-  user_scale_data.initialise(lp.user_cost_scale_, lp.user_bound_scale_,
+  user_scale_data.initialise(options.user_cost_scale, options.user_bound_scale,
                              options.infinite_cost, options.infinite_bound,
                              options.small_matrix_value,
                              options.large_matrix_value);

highs/lp_data/HighsSolve.cpp

@@ -341,7 +341,7 @@ HighsStatus solveUnconstrainedLp(const HighsOptions& options, const HighsLp& lp,
   return HighsStatus::kOk;
 }
 
-void assessExcessiveBoundCost(const HighsLogOptions log_options,
+void assessExcessiveBoundCost(const HighsOptions options,
                               const HighsModel& model) {
   auto assessFiniteNonzero = [&](const double value, double& min_value,
                                  double& max_value) {
@@ -352,6 +352,7 @@ void assessExcessiveBoundCost(const HighsLogOptions log_options,
     }
   };
   const HighsLp& lp = model.lp_;
+  const HighsLogOptions& log_options = options.log_options;
   double min_finite_col_cost = kHighsInf;
   double max_finite_col_cost = -kHighsInf;
   double min_finite_col_bound = kHighsInf;
@@ -403,7 +404,7 @@ void assessExcessiveBoundCost(const HighsLogOptions log_options,
   // max_finite_col_cost = 0
   assert(max_finite_col_cost >= 0);
   if (max_finite_col_cost > kExcessivelyLargeCostValue) {
-    double user_cost_scale_value = std::pow(2, lp.user_cost_scale_);
+    double user_cost_scale_value = std::pow(2, options.user_cost_scale);
     // Warn that costs are excessively large, and suggest scaling
     double ratio = kExcessivelyLargeCostValue /
                    (max_finite_col_cost / user_cost_scale_value);
@@ -413,15 +414,15 @@ void assessExcessiveBoundCost(const HighsLogOptions log_options,
         log_options, HighsLogType::kWarning,
         "%s has excessively large costs: consider scaling the costs "
         "by 1e%+1d or less, or setting option user_cost_scale to %d or less\n",
-        lp.user_cost_scale_ ? "User-scaled problem" : "Problem",
+        options.user_cost_scale ? "User-scaled problem" : "Problem",
         int(-suggested_cost_scale_exponent),
         int(suggested_user_cost_scale_setting));
   }
   // LPs with no columns or no finite nonzero bounds will have
   // max_finite_col_bound = 0
   assert(max_finite_col_bound >= 0);
   if (max_finite_col_bound > kExcessivelyLargeBoundValue) {
-    double user_bound_scale_value = std::pow(2, lp.user_bound_scale_);
+    double user_bound_scale_value = std::pow(2, options.user_bound_scale);
     // Warn that bounds are excessively large, and suggest scaling
     double ratio = kExcessivelyLargeBoundValue /
                    (max_finite_col_bound / user_bound_scale_value);
@@ -432,15 +433,15 @@ void assessExcessiveBoundCost(const HighsLogOptions log_options,
           log_options, HighsLogType::kWarning,
           "%s has excessively large bounds: consider scaling the bounds "
           "by 1e%+1d or less\n",
-          lp.user_bound_scale_ ? "User-scaled problem" : "Problem",
+          options.user_bound_scale ? "User-scaled problem" : "Problem",
           int(-suggested_bound_scale_exponent));
     } else {
       highsLogUser(
           log_options, HighsLogType::kWarning,
           "%s has excessively large bounds: consider scaling the bounds "
           "by 1e%+1d or less, "
           "or setting option user_bound_scale to %d or less\n",
-          lp.user_bound_scale_ ? "User-scaled problem" : "Problem",
+          options.user_bound_scale ? "User-scaled problem" : "Problem",
           int(-suggested_bound_scale_exponent),
           int(suggested_user_bound_scale));
     }
@@ -449,7 +450,7 @@ void assessExcessiveBoundCost(const HighsLogOptions log_options,
   // max_finite_row_bound = 0
   assert(max_finite_row_bound >= 0);
   if (max_finite_row_bound > kExcessivelyLargeBoundValue) {
-    double user_bound_scale_value = std::pow(2, lp.user_bound_scale_);
+    double user_bound_scale_value = std::pow(2, options.user_bound_scale);
     // Warn that bounds are excessively large, and suggest scaling
     double ratio = kExcessivelyLargeBoundValue /
                    (max_finite_row_bound / user_bound_scale_value);
@@ -460,23 +461,23 @@ void assessExcessiveBoundCost(const HighsLogOptions log_options,
           log_options, HighsLogType::kWarning,
           "%s has excessively large bounds: consider scaling the bounds "
           "by 1e%+1d or less\n",
-          lp.user_bound_scale_ ? "User-scaled problem" : "Problem",
+          options.user_bound_scale ? "User-scaled problem" : "Problem",
           int(-suggested_bound_scale_exponent));
     } else {
       highsLogUser(
           log_options, HighsLogType::kWarning,
           "%s has excessively large bounds: consider scaling the bounds "
           "by 1e%+1d or less, "
           "or setting option user_bound_scale to %d or less\n",
-          lp.user_bound_scale_ ? "User-scaled problem" : "Problem",
+          options.user_bound_scale ? "User-scaled problem" : "Problem",
           int(-suggested_bound_scale_exponent),
           int(suggested_user_bound_scale));
     }
   }
   // Now consider warning relating to small maximum costs and bounds
   if (max_finite_col_cost > 0 &&
       max_finite_col_cost < kExcessivelySmallCostValue) {
-    double user_cost_scale_value = std::pow(2, lp.user_cost_scale_);
+    double user_cost_scale_value = std::pow(2, options.user_cost_scale);
     // Warn that costs are excessively small, and suggest scaling
     double ratio = kExcessivelySmallCostValue /
                    (max_finite_col_cost / user_cost_scale_value);
@@ -487,13 +488,13 @@ void assessExcessiveBoundCost(const HighsLogOptions log_options,
         "%s has excessively small costs: consider scaling the costs up "
         "by 1e%+1d or more, "
         "or setting option user_cost_scale to %d or more\n",
-        lp.user_cost_scale_ ? "User-scaled problem" : "Problem",
+        options.user_cost_scale ? "User-scaled problem" : "Problem",
         int(suggested_cost_scale_exponent),
         int(suggested_user_cost_scale_setting));
   }
   if (max_finite_col_bound > 0 &&
       max_finite_col_bound < kExcessivelySmallBoundValue) {
-    double user_bound_scale_value = std::pow(2, lp.user_bound_scale_);
+    double user_bound_scale_value = std::pow(2, options.user_bound_scale);
     // Warn that bounds are excessively small, and suggest scaling
     double ratio = kExcessivelySmallBoundValue /
                    (max_finite_col_bound / user_bound_scale_value);
@@ -504,21 +505,21 @@ void assessExcessiveBoundCost(const HighsLogOptions log_options,
           log_options, HighsLogType::kWarning,
           "%s has excessively small bounds: consider scaling the bounds "
           "by 1e%+1d or more\n",
-          lp.user_bound_scale_ ? "User-scaled problem" : "Problem",
+          options.user_bound_scale ? "User-scaled problem" : "Problem",
           int(suggested_bound_scale_exponent));
     } else {
       highsLogUser(
           log_options, HighsLogType::kWarning,
           "%s has excessively small bounds: consider scaling the bounds "
           "by 1e%+1d or more, "
           "or setting option user_bound_scale to %d or more\n",
-          lp.user_bound_scale_ ? "User-scaled problem" : "Problem",
+          options.user_bound_scale ? "User-scaled problem" : "Problem",
           int(suggested_bound_scale_exponent), int(suggested_user_bound_scale));
     }
   }
   if (max_finite_row_bound > 0 &&
       max_finite_row_bound < kExcessivelySmallBoundValue) {
-    double user_bound_scale_value = std::pow(2, lp.user_bound_scale_);
+    double user_bound_scale_value = std::pow(2, options.user_bound_scale);
     // Warn that bounds are excessively small, and suggest scaling
     double ratio = kExcessivelySmallBoundValue /
                    (max_finite_row_bound / user_bound_scale_value);
@@ -529,15 +530,15 @@ void assessExcessiveBoundCost(const HighsLogOptions log_options,
           log_options, HighsLogType::kWarning,
           "%s has excessively small bounds: consider scaling the bounds "
           "by 1e%+1d or more\n",
-          lp.user_bound_scale_ ? "User-scaled problem" : "Problem",
+          options.user_bound_scale ? "User-scaled problem" : "Problem",
           int(suggested_bound_scale_exponent));
     } else {
       highsLogUser(
           log_options, HighsLogType::kWarning,
           "%s has excessively small bounds: consider scaling the bounds "
           "by 1e%+1d or more, "
           "or setting option user_bound_scale to %d or more\n",
-          lp.user_bound_scale_ ? "User-scaled problem" : "Problem",
+          options.user_bound_scale ? "User-scaled problem" : "Problem",
           int(suggested_bound_scale_exponent), int(suggested_user_bound_scale));
     }
   }

highs/lp_data/HighsSolve.h

@@ -18,6 +18,5 @@ HighsStatus solveUnconstrainedLp(const HighsOptions& options, const HighsLp& lp,
                                  HighsModelStatus& model_status,
                                  HighsInfo& highs_info, HighsSolution& solution,
                                  HighsBasis& basis);
-void assessExcessiveBoundCost(const HighsLogOptions log_options,
-                              const HighsModel& model);
+void assessExcessiveBoundCost(const HighsOptions options, const HighsModel& model);
 #endif  // LP_DATA_HIGHSSOLVE_H_