Merge pull request #2594 from ERGO-Code/fix-2460

jajhall · web-flow · commit cc3e9b826973 · 2025-10-23T22:18:43.000+01:00
Renamed user_cost_scale to user_objective_scale
diff --git a/highs/highs_bindings.cpp b/highs/highs_bindings.cpp
@@ -1206,7 +1206,7 @@ PYBIND11_MODULE(_core, m, py::mod_gil_not_used()) {
       .def_readwrite("objective_target", &HighsOptions::objective_target)
       .def_readwrite("threads", &HighsOptions::threads)
       .def_readwrite("user_bound_scale", &HighsOptions::user_bound_scale)
-      .def_readwrite("user_cost_scale", &HighsOptions::user_cost_scale)
+      .def_readwrite("user_objective_scale", &HighsOptions::user_objective_scale)
       .def_readwrite("highs_debug_level", &HighsOptions::highs_debug_level)
       .def_readwrite("highs_analysis_level",
                      &HighsOptions::highs_analysis_level)
diff --git a/highs/interfaces/highs_c_api.h b/highs/interfaces/highs_c_api.h
@@ -2447,6 +2447,23 @@ HighsInt Highs_getIis(void* highs, HighsInt* iis_num_col, HighsInt* iis_num_row,
                       HighsInt* col_index, HighsInt* row_index,
                       HighsInt* col_bound, HighsInt* row_bound,
                       HighsInt* col_status, HighsInt* row_status);
+/**
+ * Identify suggested values of the options user_objective_scale and
+ * user_bound_scale to address extremely large or small objective
+ * coefficients and bound values
+ *
+ * @param highs                                A pointer to the Highs instance.
+ * @param HighsInt* suggested_objective_scale  The suggested value of
+ * user_objective_scale
+ * @param HighsInt* suggested_bound_scale      The suggested value of
+ * user_bound_scale
+ *
+ * @returns A `kHighsStatus` constant indicating whether the call succeeded.
+ */
+HighsInt Highs_getObjectiveBoundScaling(void* highs,
+                                        HighsInt* suggested_objective_scale,
+                                        HighsInt* suggested_bound_scale);
+
 /**
  * Releases all resources held by the global scheduler instance.
  *
diff --git a/highs/lp_data/Highs.cpp b/highs/lp_data/Highs.cpp
@@ -965,9 +965,33 @@ 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_objective_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);
+    // Indicate that the scaling has been applied
+    user_scale_data.applied = true;
+    // Zero the user scale values to prevent further scaling
+    this->options_.user_objective_scale = 0;
+    this->options_.user_bound_scale = 0;
+  }
+
+  // Determine coefficient ranges and possibly warn the user about
+  // excessive values, obtaining suggested values for user_objective_scale
+  // and user_bound_scale
+  assessExcessiveObjectiveBoundScaling(this->options_.log_options, this->model_,
+                                       user_scale_data);
+  // Used when deveoping unit tests in TestUserScale.cpp
+  //  this->writeModel("");
+  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_
@@ -981,6 +1005,44 @@ HighsStatus Highs::run() {
       if (this->options_.write_basis_file != "")
         status = this->writeBasis(this->options_.write_basis_file);
     }
+  } else {
+    status = this->multiobjectiveSolve();
+  }
+  if (user_scaling) {
+    // Unscale the incumbent model and solution
+    //
+    // Flip the scaling sign
+    user_scale_data.user_objective_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;
+    unscale_status = 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_objective_scale = -user_scale_data.user_objective_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",
+                 this->info_.objective_function_value);
+    if (model_status_ == HighsModelStatus::kOptimal &&
+        unscale_status != HighsStatus::kOk) {
+      // KKT errors in the unscaled optimal solution, so log a warning and
+      // return
+      highsLogUser(
+          this->options_.log_options, HighsLogType::kWarning,
+          "User scaled problem solved to optimality, but unscaled solution "
+          "does not satisfy feasibilty and optimality tolerances\n");
+      status = HighsStatus::kWarning;
+    }
     this->reportSubSolverCallTime();
     return status;
   }
diff --git a/highs/lp_data/HighsLpUtils.cpp b/highs/lp_data/HighsLpUtils.cpp
@@ -3524,3 +3524,113 @@ void getSubVectorsTranspose(const HighsIndexCollection& index_collection,
     }
   }
 }
+
+void initialiseUserScaleData(const HighsOptions& options,
+                             HighsUserScaleData& user_scale_data) {
+  user_scale_data.initialise(options.user_objective_scale,
+                             options.user_bound_scale, options.infinite_cost,
+                             options.infinite_bound, options.small_matrix_value,
+                             options.large_matrix_value);
+}
+
+void HighsUserScaleData::initialise(const HighsInt& user_objective_scale_,
+                                    const HighsInt& user_bound_scale_,
+                                    const double& infinite_cost_,
+                                    const double& infinite_bound_,
+                                    const double& small_matrix_value_,
+                                    const double& large_matrix_value_) {
+  this->user_objective_scale = user_objective_scale_;
+  this->user_bound_scale = user_bound_scale_;
+  this->infinite_cost = infinite_cost_;
+  this->infinite_bound = infinite_bound_;
+  this->small_matrix_value = small_matrix_value_;
+  this->large_matrix_value = large_matrix_value_;
+  this->num_infinite_costs = 0;
+  this->num_infinite_hessian_values = 0;
+  this->num_infinite_col_bounds = 0;
+  this->num_infinite_row_bounds = 0;
+  this->num_small_matrix_values = 0;
+  this->num_large_matrix_values = 0;
+  this->suggested_user_objective_scale = 0;
+  this->suggested_user_bound_scale = 0;
+  this->applied = false;
+}
+
+bool HighsUserScaleData::scaleError(std::string& message) const {
+  if (this->num_infinite_costs + this->num_infinite_hessian_values +
+          this->num_infinite_col_bounds + this->num_infinite_row_bounds +
+          this->num_large_matrix_values ==
+      0)
+    return false;
+  assert(this->user_objective_scale != 0 || this->user_bound_scale != 0);
+  std::stringstream ss;
+  ss.str(std::string());
+  ss << "User scaling of";
+  if (this->user_objective_scale != 0) {
+    ss << " 2**(" << this->user_objective_scale << ") for costs";
+  }
+  if (this->user_bound_scale != 0) {
+    if (this->user_objective_scale != 0) ss << " and";
+    ss << " 2**(" << this->user_bound_scale << ") for bounds";
+  }
+  ss << " yields";
+  if (this->num_infinite_costs) {
+    ss << " " << this->num_infinite_costs << " infinite cost";
+    if (this->num_infinite_costs > 1) ss << "s";
+  }
+  if (this->num_infinite_hessian_values) {
+    if (this->num_infinite_costs) {
+      if (this->num_infinite_col_bounds || this->num_infinite_row_bounds) {
+        ss << ",";
+      } else {
+        ss << " and";
+      }
+    }
+    ss << " " << this->num_infinite_hessian_values
+       << " infinite Hessian values";
+    if (this->num_infinite_hessian_values > 1) ss << "s";
+  }
+  if (this->num_infinite_col_bounds) {
+    if (this->num_infinite_costs || this->num_infinite_hessian_values) {
+      if (this->num_infinite_row_bounds) {
+        ss << ",";
+      } else {
+        ss << " and";
+      }
+    }
+    ss << " " << this->num_infinite_col_bounds << " infinite column bound";
+    if (this->num_infinite_col_bounds > 1) ss << "s";
+  }
+  if (this->num_infinite_row_bounds) {
+    if (this->num_infinite_costs || this->num_infinite_hessian_values ||
+        this->num_infinite_col_bounds)
+      ss << " and";
+    ss << " " << this->num_infinite_row_bounds << " infinite row bound";
+    if (this->num_infinite_row_bounds > 1) ss << "s";
+  }
+  if (this->num_large_matrix_values) {
+    if (this->num_infinite_costs + this->num_infinite_hessian_values +
+            this->num_infinite_col_bounds + this->num_infinite_row_bounds >
+        0)
+      ss << ", and";
+    ss << " " << this->num_large_matrix_values << " large matrix value";
+    if (this->num_large_matrix_values > 1) ss << "s";
+  }
+  ss << "\n";
+  message = ss.str();
+  return true;
+}
+
+bool HighsUserScaleData::scaleWarning(std::string& message) const {
+  if (this->num_small_matrix_values == 0) return false;
+  assert(this->user_bound_scale != 0);
+  std::stringstream ss;
+  ss.str(std::string());
+  ss << "User scaling of 2**(" << this->user_bound_scale
+     << ") for bounds yields " << this->num_small_matrix_values
+     << " small matrix value";
+  if (this->num_small_matrix_values > 1) ss << "s";
+  ss << "\n";
+  message = ss.str();
+  return true;
+}
diff --git a/highs/lp_data/HighsOptions.h b/highs/lp_data/HighsOptions.h
@@ -336,8 +336,8 @@ struct HighsOptionsStruct {
   double objective_bound;
   double objective_target;
   HighsInt threads;
+  HighsInt user_objective_scale;
   HighsInt user_bound_scale;
-  HighsInt user_cost_scale;
   HighsInt highs_debug_level;
   HighsInt highs_analysis_level;
   HighsInt simplex_strategy;
@@ -514,8 +514,8 @@ struct HighsOptionsStruct {
         objective_bound(0.0),
         objective_target(0.0),
         threads(0),
+        user_objective_scale(0),
         user_bound_scale(0),
-        user_cost_scale(0),
         highs_debug_level(0),
         highs_analysis_level(0),
         simplex_strategy(0),
@@ -825,8 +825,9 @@ class HighsOptions : public HighsOptionsStruct {
     records.push_back(record_int);
 
     record_int = new OptionRecordInt(
-        "user_cost_scale", "Exponent of power-of-two cost scaling for model",
-        advanced, &user_cost_scale, -kHighsIInf, 0, kHighsIInf);
+        "user_objective_scale",
+        "Exponent of power-of-two objective scaling for model", advanced,
+        &user_objective_scale, -kHighsIInf, 0, kHighsIInf);
     records.push_back(record_int);
 
     record_int = new OptionRecordInt("highs_debug_level",
diff --git a/highs/lp_data/HighsSolve.cpp b/highs/lp_data/HighsSolve.cpp
@@ -382,8 +382,38 @@ HighsStatus solveUnconstrainedLp(const HighsOptions& options, const HighsLp& lp,
   return HighsStatus::kOk;
 }
 
-void assessExcessiveBoundCost(const HighsLogOptions log_options,
-                              const HighsModel& model) {
+// Assuming that any user scaling in user_scale_data has been applied,
+// determine the model coefficient ranges, assess it for values
+// outside the [small, large] range, and give appropriate scaling
+// recommendations
+void assessExcessiveObjectiveBoundScaling(const HighsLogOptions log_options,
+                                          const HighsModel& model,
+                                          HighsUserScaleData& user_scale_data) {
+  const HighsLp& lp = model.lp_;
+  if (lp.num_col_ == 0 || lp.num_row_ == 0) return;
+  const bool user_cost_or_bound_scale =
+      user_scale_data.user_objective_scale || user_scale_data.user_bound_scale;
+  const double small_objective_coefficient =
+      kExcessivelySmallObjectiveCoefficient;
+  const double large_objective_coefficient =
+      kExcessivelyLargeObjectiveCoefficient;
+  const double small_bound = kExcessivelySmallBoundValue;
+  const double large_bound = kExcessivelyLargeBoundValue;
+  std::stringstream message;
+  if (user_cost_or_bound_scale) {
+    if (user_scale_data.user_objective_scale)
+      message << highsFormatToString(" user_objective_scale option value of %d",
+                                     user_scale_data.user_objective_scale);
+    if (user_scale_data.user_bound_scale) {
+      if (user_scale_data.user_objective_scale) message << " and";
+      message << highsFormatToString(" user_bound_scale option value of %d",
+                                     user_scale_data.user_bound_scale);
+    }
+    highsLogUser(log_options, HighsLogType::kInfo,
+                 "Assessing costs and bounds after applying%s\n",
+                 message.str().c_str());
+  }
+  // Lambda for assessing a finite nonzero
   auto assessFiniteNonzero = [&](const double value, double& min_value,
                                  double& max_value) {
     double abs_value = std::abs(value);
@@ -556,6 +586,9 @@ void assessExcessiveBoundCost(const HighsLogOptions log_options,
           lp.user_bound_scale_ ? "User-scaled problem" : "Problem",
           int(suggested_bound_scale_exponent), int(suggested_user_bound_scale));
     }
+    message << highsFormatToString(
+        " setting the user_objective_scale option to %d",
+        int(user_scale_data.suggested_user_objective_scale));
   }
   if (max_finite_row_bound > 0 &&
       max_finite_row_bound < kExcessivelySmallBoundValue) {
diff --git a/tests/test_highspy.py b/tests/test_highspy.py
@@ -2252,3 +2252,31 @@ def test_get_objectives(self):
         self.assertEqual(obj_expr2.vals, [1.0, 2.0, 3.0])
         self.assertEqual(obj_expr2.constant, 5.0)
         self.assertEqual(sense2, highspy.ObjSense.kMaximize)
+
+    def test_get_user_objective_bound_scale(self):
+        inf = highspy.kHighsInf
+        h = highspy.Highs()
+        h.setOptionValue("output_flag", False)
+        h.addVars(2, np.array([1e-8, 1e-8]), np.array([1e8, 1e8]))
+        h.changeColsCost(2, np.array([0, 1]), np.array([-4e6, -7e6], dtype=np.double))
+        num_cons = 2
+        lower = np.array([-inf, -2e+8], dtype=np.double)
+        upper = np.array([6e+8, inf], dtype=np.double)
+        num_new_nz = 4
+        starts = np.array([0, 2])
+        indices = np.array([0, 1, 0, 1])
+        values = np.array([1, 1, 1, -1], dtype=np.double)
+        h.addRows(num_cons, lower, upper, num_new_nz, starts, indices, values)
+        h.run()
+        unscaled_objective_value = h.getObjectiveValue()
+        [status, dual_objective_value] = h.getDualObjectiveValue()
+        self.assertAlmostEqual(unscaled_objective_value, dual_objective_value)
+        [status, suggested_objective_scale, suggested_bound_scale] = h.getObjectiveBoundScaling();
+        h.setOptionValue("user_objective_scale", suggested_objective_scale)
+        h.setOptionValue("user_bound_scale", suggested_bound_scale)
+        h.run()
+        scaled_objective_value = h.getObjectiveValue()
+        self.assertAlmostEqual(unscaled_objective_value, scaled_objective_value)
+        
+        
+        
