Now setting HEkk::cost_scale_ from lp_.scale_.cost if lp_.is_scaled_

Author: jajhall

check/TestBasisSolves.cpp

@@ -639,7 +639,7 @@ TEST_CASE("scaling-kappa", "[highs_basis_solves]") {
   highs.run();
   */
   }
-  const bool lp_test = false;
+  const bool lp_test = true;
   if (lp_test) {
     const double cost = 1e6;
     HighsLp lp;
@@ -659,5 +659,6 @@ TEST_CASE("scaling-kappa", "[highs_basis_solves]") {
     highs.setOptionValue("simplex_scale_strategy",
 			 kSimplexScaleStrategyMaxValueMatrixAndCost);
     highs.run();
+    highs.writeSolution("", 1);
   }
 }

highs/lp_data/HighsLpUtils.cpp

@@ -219,10 +219,20 @@ bool lpDimensionsOk(std::string message, const HighsLp& lp,
   bool legal_scale_row_size = false;
   bool legal_scale_col_size = false;
   if (lp.scale_.has_scaling) {
-    legal_scale_num_col = lp.scale_.num_col == num_col;
-    legal_scale_num_row = lp.scale_.num_row == num_row;
-    legal_scale_row_size = scale_row_size >= num_row;
-    legal_scale_col_size = scale_col_size >= num_col;
+    if (scale_col_size) {
+      legal_scale_num_col = lp.scale_.num_col == num_col;
+      legal_scale_col_size = scale_col_size >= num_col;
+    } else {
+      legal_scale_num_col = lp.scale_.num_col == 0;
+      legal_scale_col_size = true; // Since scale_col_size = 0
+    }
+    if (scale_row_size) {
+      legal_scale_num_row = lp.scale_.num_row == num_row;
+      legal_scale_row_size = scale_row_size >= num_row;
+    } else {
+      legal_scale_num_row = lp.scale_.num_row == 0;
+      legal_scale_row_size = true; // Since scale_row_size = 0
+    }
   } else {
     legal_scale_num_col = lp.scale_.num_col == 0;
     legal_scale_num_row = lp.scale_.num_row == 0;

highs/simplex/HEkk.cpp

@@ -414,6 +414,9 @@ void HEkk::moveLp(HighsLpSolverObject& solver_object) {
   // The simplex algorithm runs in the same space as the LP that has
   // just been moved in. This is a scaled space if the LP is scaled.
   this->simplex_in_scaled_space_ = this->lp_.is_scaled_;
+  // Set the cost scale value so internal primal and dual objectives
+  // are computed using the unscaled costs
+  this->cost_scale_ = this->lp_.is_scaled_ ? this->lp_.scale_.cost : 1.0;
   //
   // Update other EKK pointers. Currently just pointers to the
   // HighsOptions and HighsTimer members of the Highs class that are
@@ -1297,16 +1300,21 @@ void HEkk::deleteRows(const HighsIndexCollection& index_collection) {
 
 void HEkk::unscaleSimplex(const HighsLp& incumbent_lp) {
   if (!this->simplex_in_scaled_space_) return;
-  assert(incumbent_lp.scale_.has_scaling);
+  const HighsScale& scale = incumbent_lp.scale_;
+  assert(scale.has_scaling);
+  const bool has_cost_scaling = scale.cost > 1.0;
+  const bool has_matrix_scaling = scale.col.size() && scale.row.size();
+  assert(has_cost_scaling || has_matrix_scaling);
+  assert(scale.cost);
   const HighsInt num_col = incumbent_lp.num_col_;
   const HighsInt num_row = incumbent_lp.num_row_;
-  const vector<double>& col_scale = incumbent_lp.scale_.col;
-  const vector<double>& row_scale = incumbent_lp.scale_.row;
+  const vector<double>& col_scale = scale.col;
+  const vector<double>& row_scale = scale.row;
   for (HighsInt iCol = 0; iCol < num_col; iCol++) {
     const HighsInt iVar = iCol;
-    const double factor = col_scale[iCol];
-    this->info_.workCost_[iVar] /= factor;
-    this->info_.workDual_[iVar] /= factor;
+    const double factor = has_matrix_scaling ? col_scale[iCol] : 1.0;
+    this->info_.workCost_[iVar] /= (factor / scale.cost);
+    this->info_.workDual_[iVar] /= (factor / scale.cost);
     this->info_.workShift_[iVar] /= factor;
     this->info_.workLower_[iVar] *= factor;
     this->info_.workUpper_[iVar] *= factor;
@@ -1317,9 +1325,9 @@ void HEkk::unscaleSimplex(const HighsLp& incumbent_lp) {
   }
   for (HighsInt iRow = 0; iRow < num_row; iRow++) {
     const HighsInt iVar = num_col + iRow;
-    const double factor = row_scale[iRow];
-    this->info_.workCost_[iVar] *= factor;
-    this->info_.workDual_[iVar] *= factor;
+    const double factor = has_matrix_scaling ? row_scale[iRow] : 1.0;
+    this->info_.workCost_[iVar] *= (factor * scale.cost);
+    this->info_.workDual_[iVar] *= (factor * scale.cost);
     this->info_.workShift_[iVar] *= factor;
     this->info_.workLower_[iVar] /= factor;
     this->info_.workUpper_[iVar] /= factor;
@@ -1328,17 +1336,19 @@ void HEkk::unscaleSimplex(const HighsLp& incumbent_lp) {
     this->info_.workLowerShift_[iVar] /= factor;
     this->info_.workUpperShift_[iVar] /= factor;
   }
-  for (HighsInt iRow = 0; iRow < num_row; iRow++) {
-    double factor;
-    const HighsInt iVar = this->basis_.basicIndex_[iRow];
-    if (iVar < num_col) {
-      factor = col_scale[iVar];
-    } else {
-      factor = 1.0 / row_scale[iVar - num_col];
+  if (has_matrix_scaling) {
+    for (HighsInt iRow = 0; iRow < num_row; iRow++) {
+      double factor;
+      const HighsInt iVar = this->basis_.basicIndex_[iRow];
+      if (iVar < num_col) {
+	factor = col_scale[iVar];
+      } else {
+	factor = 1.0 / row_scale[iVar - num_col];
+      }
+      this->info_.baseLower_[iRow] *= factor;
+      this->info_.baseUpper_[iRow] *= factor;
+      this->info_.baseValue_[iRow] *= factor;
     }
-    this->info_.baseLower_[iRow] *= factor;
-    this->info_.baseUpper_[iRow] *= factor;
-    this->info_.baseValue_[iRow] *= factor;
   }
   this->simplex_in_scaled_space_ = false;
 }

highs/simplex/HSimplex.cpp

@@ -1058,6 +1058,7 @@ void simplexUnscaleSolution(HighsSolution& solution, const HighsScale& scale) {
   assert(scale.has_scaling);
   const bool has_cost_scaling = scale.cost > 1.0;
   const bool has_matrix_scaling = scale.col.size() && scale.row.size();
+  assert(scale.cost);
   assert(has_cost_scaling || has_matrix_scaling);
   HighsInt num_col = solution.col_value.size();
   HighsInt num_row = solution.row_value.size();