wip

Author: Yanyu000

highs/pdlp/hipdlp/pdhg.cc

@@ -785,7 +785,7 @@ double PDLPSolver::computeFixedPointErrorGpu() {
   // 2. delta_y = y_next_ - reflected_y_
   CUDA_CHECK(cudaMemcpyAsync(d_delta_y_, d_pdhg_dual_, 
                              a_num_rows_ * sizeof(double),
-                             cudaMemcpyDeviceToDevice, gpu_stream_));
+                              cudaMemcpyDeviceToDevice, gpu_stream_));
   CUBLAS_CHECK(cublasDaxpy(cublas_handle_, a_num_rows_, &alpha_minus_one,
                            d_y_next_, 1, d_delta_y_, 1));
 
@@ -1361,8 +1361,7 @@ double PDLPSolver::computePrimalFeasibility(
     }
   }
 
-  return linalg::vectorNorm(primal_residual) /
-         scaling_.getConstraintBoundScaling();
+  return linalg::vectorNorm(primal_residual);
 }
 
 void PDLPSolver::computeDualSlacks(const std::vector<double>& dualResidual,
@@ -1448,8 +1447,7 @@ double PDLPSolver::computeDualFeasibility(const std::vector<double>& ATy_vector,
     }
   }
 
-  double dual_feasibility = linalg::vectorNorm(dual_residual) /
-                            scaling_.getObjectiveVectorScaling();
+  double dual_feasibility = linalg::vectorNorm(dual_residual);
 
   return dual_feasibility;
 }
@@ -1515,10 +1513,7 @@ double PDLPSolver::computeDualObjective(const std::vector<double>& y,
     }
   }
 
-  return dual_obj /
-             (scaling_.getConstraintBoundScaling() *
-              scaling_.getObjectiveVectorScaling()) +
-         lp_.offset_;
+  return dual_obj;
 }
 
 bool PDLPSolver::checkConvergence(
@@ -1545,10 +1540,7 @@ bool PDLPSolver::checkConvergence(
   for (HighsInt i = 0; i < lp_.num_col_; ++i) {
     primal_obj += lp_.col_cost_[i] * x[i];
   }
-  primal_obj /=
-      scaling_.getConstraintBoundScaling() *
-      scaling_.getObjectiveVectorScaling();
-  results.primal_obj = primal_obj + lp_.offset_;
+  results.primal_obj = primal_obj;
 
   // Pass the now-populated slack vectors to computeDualObjective
   double dual_obj = computeDualObjective(y, dSlackPos, dSlackNeg);
@@ -1944,11 +1936,10 @@ void PDLPSolver::unscaleSolution(std::vector<double>& x,
   y_current_ = y;
 
   const std::vector<double>& col_scale = scaling_.getColScaling();
-  const double objective_scale = scaling_.getObjectiveVectorScaling();
   if (!dSlackPos_.empty() && col_scale.size() == dSlackPos_.size()) {
     for (size_t i = 0; i < dSlackPos_.size(); ++i) {
-      dSlackPos_[i] *= col_scale[i] / objective_scale;
-      dSlackNeg_[i] *= col_scale[i] / objective_scale;
+      dSlackPos_[i] *= col_scale[i];
+      dSlackNeg_[i] *= col_scale[i];
     }
   }
 }
@@ -2837,16 +2828,13 @@ bool PDLPSolver::checkConvergenceGpu(const HighsInt iter, const double* d_x,
                              cudaMemcpyDeviceToHost, gpu_stream_));
   CUDA_CHECK(cudaStreamSynchronize(gpu_stream_));
 
-  const double constraint_scale = scaling_.getConstraintBoundScaling();
-  const double objective_scale = scaling_.getObjectiveVectorScaling();
-  const double combined_scale = constraint_scale * objective_scale;
   double primal_feas_sq = h_results[0];
   double dual_feas_sq = h_results[1];
-  double primal_obj = h_results[2] / combined_scale + lp_.offset_;
-  double dual_obj = h_results[3] / combined_scale + lp_.offset_;
+  double primal_obj = h_results[2] + lp_.offset_;
+  double dual_obj = h_results[3] + lp_.offset_;
 
-  results.primal_feasibility = std::sqrt(primal_feas_sq) / constraint_scale;
-  results.dual_feasibility = std::sqrt(dual_feas_sq) / objective_scale;
+  results.primal_feasibility = std::sqrt(primal_feas_sq);
+  results.dual_feasibility = std::sqrt(dual_feas_sq);
   results.primal_obj = primal_obj;
   results.dual_obj = dual_obj;
 

highs/pdlp/hipdlp/scaling.cc

@@ -22,8 +22,6 @@ void Scaling::initialize(const HighsLp& lp) {
   col_scale_.assign(lp.num_col_, 1.0);
   row_scale_.assign(lp.num_row_, 1.0);
   is_scaled_ = false;
-  constraint_bound_scale_ = 1.0;
-  objective_vector_scale_ = 1.0;
 
   // use linalg to compute norms
   norm_cost_ = linalg::computeCostNorm(lp, 2.0);
@@ -53,10 +51,6 @@ void Scaling::scaleProblem() {
     applyL2Scaling();
     is_scaled_ = true;
   }
-
-  highsLogDev(params_->log_options_, HighsLogType::kInfo,
-              "Applying bound-objective scaling...\n");
-  applyBoundObjectiveScaling();
 }
 
 void Scaling::applyRuizScaling() {
@@ -234,45 +228,6 @@ void Scaling::applyL2Scaling() {
   }
 }
 
-void Scaling::applyBoundObjectiveScaling() {
-  double rhs_norm_sq = 0.0;
-  for (HighsInt i = 0; i < lp_->num_row_; ++i) {
-    const double lower = lp_->row_lower_[i];
-    const double upper = lp_->row_upper_[i];
-    if (std::isfinite(lower) && lower != upper) rhs_norm_sq += lower * lower;
-    if (std::isfinite(upper)) rhs_norm_sq += upper * upper;
-  }
-
-  const double rhs_norm = std::sqrt(rhs_norm_sq);
-  const double obj_norm = computeNorm(lp_->col_cost_.data(), lp_->num_col_, 2.0);
-
-  constraint_bound_scale_ = 1.0 / (1.0 + rhs_norm);
-  objective_vector_scale_ = 1.0 / (1.0 + obj_norm);
-
-  for (HighsInt i = 0; i < lp_->num_row_; ++i) {
-    if (lp_->row_lower_[i] > -kHighsInf) {
-      lp_->row_lower_[i] *= constraint_bound_scale_;
-    }
-    if (lp_->row_upper_[i] < kHighsInf) {
-      lp_->row_upper_[i] *= constraint_bound_scale_;
-    }
-  }
-
-  for (HighsInt i = 0; i < lp_->num_col_; ++i) {
-    lp_->col_cost_[i] *= objective_vector_scale_;
-    if (lp_->col_lower_[i] > -kHighsInf) {
-      lp_->col_lower_[i] *= constraint_bound_scale_;
-    }
-    if (lp_->col_upper_[i] < kHighsInf) {
-      lp_->col_upper_[i] *= constraint_bound_scale_;
-    }
-  }
-
-  if (constraint_bound_scale_ != 1.0 || objective_vector_scale_ != 1.0) {
-    is_scaled_ = true;
-  }
-}
-
 void Scaling::applyScaling(const std::vector<double>& col_scaling,
                            const std::vector<double>& row_scaling) {
   // Scale cost vector: c_scaled = c / col_scaling
@@ -318,12 +273,12 @@ void Scaling::unscaleSolution(std::vector<double>& x,
 
   // Unscale primal variables: x_original = x_scaled / col_scale
   for (size_t i = 0; i < x.size(); ++i) {
-    x[i] /= (col_scale_[i] * constraint_bound_scale_);
+    x[i] /= col_scale_[i];
   }
 
   // Unscale dual variables: y_original = y_scaled / row_scale
   for (size_t i = 0; i < y.size(); ++i) {
-    y[i] /= (row_scale_[i] * objective_vector_scale_);
+    y[i] /= row_scale_[i];
   }
 }
 

highs/pdlp/hipdlp/scaling.hpp

@@ -41,8 +41,6 @@ class Scaling {
   bool isScaled() const { return is_scaled_; }
   const std::vector<double>& getColScaling() const { return col_scale_; }
   const std::vector<double>& getRowScaling() const { return row_scale_; }
-  double getConstraintBoundScaling() const { return constraint_bound_scale_; }
-  double getObjectiveVectorScaling() const { return objective_vector_scale_; }
 
   double getNormCost() const { return norm_cost_; }
   double getNormRhs() const { return norm_rhs_; }
@@ -53,8 +51,6 @@ class Scaling {
   std::vector<double> col_scale_;
   std::vector<double> row_scale_;
   bool is_scaled_ = false;
-  double constraint_bound_scale_ = 1.0;
-  double objective_vector_scale_ = 1.0;
 
   double norm_cost_;
   double norm_rhs_;
@@ -63,7 +59,6 @@ class Scaling {
   void applyRuizScaling();
   void applyPockChambolleScaling();
   void applyL2Scaling();
-  void applyBoundObjectiveScaling();
 
   // Helper function to apply scaling factors to the problem
   void applyScaling(const std::vector<double>& col_scaling,