Now handling user scaling in Highs::run

Author: jajhall

highs/Highs.h

@@ -1705,7 +1705,11 @@ class Highs {
 
   HighsStatus handleInfCost();
   void restoreInfCost(HighsStatus& return_status);
-  HighsStatus optionChangeAction();
+  // Retain trivial optionChangeAction() in case it's useful later
+  HighsStatus optionChangeAction() const { return HighsStatus::kOk; };
+
+  HighsStatus userScaleModel(HighsUserScaleData& data);
+  HighsStatus userScaleSolution(HighsUserScaleData& data, bool update_kkt = false);
   HighsStatus computeIllConditioning(HighsIllConditioning& ill_conditioning,
                                      const bool constraint,
                                      const HighsInt method,

highs/lp_data/Highs.cpp

@@ -941,9 +941,23 @@ HighsStatus Highs::run() {
 
   if (!options_.use_warm_start) this->clearSolver();
   this->reportModelStats();
-  HighsInt num_linear_objective = this->multi_linear_objective_.size();
-  if (num_linear_objective == 0) {
-    HighsStatus status = this->optimizeModel();
+
+  // Possibly apply user-defined scaling to the incumbent model and solution
+  HighsUserScaleData user_scale_data;
+  initialiseUserScaleData(this->options_, user_scale_data);
+  const bool user_scaling =
+    user_scale_data.user_cost_scale ||
+    user_scale_data.user_bound_scale;
+  if (user_scaling) {
+    if (this->userScaleModel(user_scale_data) == HighsStatus::kError) return HighsStatus::kError;
+    this->userScaleSolution(user_scale_data);
+    // Zero the user scale values to prevent further scaling
+    this->options_.user_cost_scale = 0;
+    this->options_.user_bound_scale = 0;
+  }
+  HighsStatus status;
+  if (!this->multi_linear_objective_.size()) {
+    status = this->optimizeModel();
     if (options_had_highs_files) {
       // This call to Highs::run() had HiGHS files in options, so
       // recover HiGHS files to options_
@@ -957,9 +971,29 @@ HighsStatus Highs::run() {
       if (this->options_.write_basis_file != "")
         status = this->writeBasis(this->options_.write_basis_file);
     }
-    return status;
+  } else {
+    status = this->multiobjectiveSolve();
   }
-  return this->multiobjectiveSolve();
+  if (user_scaling) {
+    // Unscale the incumbent model and solution
+    //
+    // Flip the scaling sign 
+    user_scale_data.user_cost_scale *= -1;
+    user_scale_data.user_bound_scale *= -1;
+    HighsStatus unscale_status = this->userScaleModel(user_scale_data);
+    if (unscale_status == HighsStatus::kError) {
+      highsLogUser(this->options_.log_options, HighsLogType::kError,
+		   "Unexpected error removing user scaling from the incumbent model\n");
+      assert(unscale_status != HighsStatus::kError);
+    }
+    const bool update_kkt = true;
+    this->userScaleSolution(user_scale_data, update_kkt);
+    // Restore the user scale values, remembering that they've been
+    // 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;
+  }
+  return status;
 }
 
 // Checks the options calls presolve and postsolve if needed. Solvers are called

highs/lp_data/HighsInterface.cpp

@@ -2984,41 +2984,45 @@ 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_;
-  HighsOptions& options = this->options_;
-  HighsInt dl_user_cost_scale = options.user_cost_scale - lp.user_cost_scale_;
-  HighsInt dl_user_bound_scale =
-      options.user_bound_scale - lp.user_bound_scale_;
-  
-  if (dl_user_cost_scale || dl_user_bound_scale) {
-    HighsUserScaleData user_scale_data;
-    initialiseUserScaleData(lp, options_, user_scale_data);
-    user_scale_data.user_cost_scale = dl_user_cost_scale;
-    user_scale_data.user_bound_scale = dl_user_bound_scale;
-    HighsStatus return_status = userScaleModel(model, user_scale_data, options.log_options);
-    if (return_status == HighsStatus::kError) {
-      options.user_cost_scale = lp.user_cost_scale_;
-      options.user_bound_scale = lp.user_bound_scale_;
-      highsLogUser(
-          options_.log_options, HighsLogType::kError,
-          "New user cost/bound scaling yields excessive costs/bounds: "
-          "reverting user cost scaling to %d, and user bound scaling to %d\n",
-          int(lp.user_cost_scale_), int(lp.user_bound_scale_));
-      return HighsStatus::kError;
+HighsStatus Highs::userScaleModel(HighsUserScaleData& data) {
+  userScaleLp(this->model_.lp_, data, false);
+  userScaleHessian(this->model_.hessian_, data, false);
+  HighsStatus return_status = userScaleStatus(this->options_.log_options, data);
+  if (return_status == HighsStatus::kError) return HighsStatus::kError;
+  userScaleLp(this->model_.lp_, data);
+  userScaleHessian(this->model_.hessian_, data);
+  return return_status;
+}
+
+HighsStatus Highs::userScaleSolution(HighsUserScaleData& data, bool update_kkt) {
+  HighsStatus return_status = HighsStatus::kOk;
+  if (!data.user_cost_scale && !data.user_bound_scale) return HighsStatus::kOk;
+  double cost_scale_value = std::pow(2, data.user_cost_scale);
+  double bound_scale_value = std::pow(2, data.user_bound_scale);
+  const HighsLp& lp = this->model_.lp_;
+  const bool has_integrality = lp.integrality_.size();
+  if (info_.primal_solution_status != kSolutionStatusNone) {
+    if (data.user_bound_scale) {
+      for (HighsInt iCol = 0; iCol < lp.num_col_; iCol++) {
+	if (has_integrality && lp.integrality_[iCol] != HighsVarType::kContinuous) continue;
+	this->solution_.col_value[iCol] *= bound_scale_value;
+      }
+      for (HighsInt iRow = 0; iRow < lp.num_row_; iRow++) 
+	this->solution_.row_value[iRow] *= bound_scale_value;
     }
-    this->invalidateModelStatusSolutionAndInfo();
-    this->invalidateSolverData();
-    lp.user_cost_scale_ = options.user_cost_scale;
-    lp.user_bound_scale_ = options.user_bound_scale;
   }
-  */
-  return HighsStatus::kOk;
+  if (info_.dual_solution_status != kSolutionStatusNone) {
+    if (data.user_cost_scale) {
+      for (HighsInt iCol = 0; iCol < lp.num_col_; iCol++) 
+	this->solution_.col_dual[iCol] *= cost_scale_value;
+      for (HighsInt iRow = 0; iRow < lp.num_row_; iRow++) 
+	this->solution_.row_dual[iRow] *= cost_scale_value;
+    }
+  }
+  if (!update_kkt) return return_status;
+  info_.objective_function_value *= (bound_scale_value*cost_scale_value);
+  getKktFailures(options_, model_, solution_, basis_, info_);
+  return return_status;
 }
 
 void HighsIllConditioning::clear() { this->record.clear(); }

highs/lp_data/HighsLpUtils.h

@@ -323,6 +323,6 @@ void getSubVectorsTranspose(const HighsIndexCollection& index_collection,
                             HighsInt* sub_matrix_index,
                             double* sub_matrix_value);
 
-void initialiseUserScaleData(const HighsLp& lp, const HighsOptions& options,
+void initialiseUserScaleData(const HighsOptions& options,
                              HighsUserScaleData& user_scale_data);
 #endif  // LP_DATA_HIGHSLPUTILS_H_

highs/lp_data/HighsModelUtils.cpp

@@ -1591,15 +1591,3 @@ bool repeatedNames(const std::vector<std::string> name) {
 }
 */
 
-HighsStatus userScaleModel(HighsModel& model,
-			   HighsUserScaleData& data,
-			   const HighsLogOptions& log_options) {
-  userScaleLp(model.lp_, data, false);
-  userScaleHessian(model.hessian_, data, false);
-  HighsStatus return_status = userScaleStatus(log_options, data);
-  if (return_status == HighsStatus::kError) return HighsStatus::kError;
-  userScaleLp(model.lp_, data);
-  userScaleHessian(model.hessian_, data);
-  return return_status;
-}
-

highs/lp_data/HighsModelUtils.h

@@ -114,7 +114,4 @@ std::string findModelObjectiveName(const HighsLp* lp,
 
 // bool repeatedNames(const std::vector<std::string> name);
 
-HighsStatus userScaleModel(HighsModel& model,
-			   HighsUserScaleData& data,
-			   const HighsLogOptions& log_options);
 #endif