Consider that bounds of free variables may have changed

Author: filikat

highs/ipm/hipo/ipm/Iterate.cpp

@@ -28,7 +28,7 @@ void NewtonDir::add(const NewtonDir& d) {
   vectorAdd(zu, d.zu);
 }
 
-Iterate::Iterate(const Model& model_input, Regularisation& r)
+Iterate::Iterate(Model& model_input, Regularisation& r)
     : model{model_input}, delta(model.m(), model.n()), regul{r} {
   clearIter();
   clearRes();
@@ -608,6 +608,7 @@ void Iterate::saveBest(double feas_tol, double opt_tol, Int iter) {
     best_zu = zu;
     best_violation = violation;
     best_iter = iter;
+    model.saveBounds();
   }
 }
 
@@ -620,6 +621,7 @@ bool Iterate::resetBest(Int iter) {
   y = best_y;
   zl = best_zl;
   zu = best_zu;
+  model.resetBounds();
 
   computeMu();
   residual1234();

highs/ipm/hipo/ipm/Iterate.h

@@ -30,7 +30,7 @@ struct Residuals {
 };
 
 struct Iterate {
-  const Model& model;
+  Model& model;
   IpmData data;
   std::vector<double> x, xl, xu, y, zl, zu;
   Residuals res;
@@ -57,7 +57,7 @@ struct Iterate {
   // ===================================================================================
   // Functions to construct, clear and check for nan or inf
   // ===================================================================================
-  Iterate(const Model& model_input, Regularisation& r);
+  Iterate(Model& model_input, Regularisation& r);
 
   // clear existing data
   void clearIter();

highs/ipm/hipo/ipm/Model.cpp

@@ -424,21 +424,40 @@ void Model::adjustFreeVars(std::vector<double>& x, std::vector<double>& xl,
       // getting close to lower bound
       const double new_lower = x[i] / kFreeVarsCloseRatio;
       logger.printDetailed(
-          "Free var %5d is at %8.1e with lb %8.1e, lb changed to %8.1e\n", i, x[i],
-          lower_[i], new_lower);
+          "Free var %5d is at %8.1e with lb %8.1e, lb changed to %8.1e\n", i,
+          x[i], lower_[i], new_lower);
       lower_[i] = new_lower;
       xl[i] = x[i] - lower_[i];
     }
     if (x[i] > upper_[i] * kFreeVarsCloseRatio) {
       // getting close to upper bound
       const double new_upper = x[i] / kFreeVarsCloseRatio;
       logger.printDetailed(
-          "Free var %5d is at %8.1e with ub %8.1e, ub changed to %8.1e\n", i, x[i],
-          upper_[i], new_upper);
+          "Free var %5d is at %8.1e with ub %8.1e, ub changed to %8.1e\n", i,
+          x[i], upper_[i], new_upper);
       upper_[i] = new_upper;
       xu[i] = upper_[i] - x[i];
     }
   }
 }
 
+void Model::saveBounds() {
+  best_lower_.resize(free_variables_.size());
+  best_upper_.resize(free_variables_.size());
+  Int next = 0;
+  for (Int i : free_variables_) {
+    best_lower_[next] = lower_[i];
+    best_upper_[next] = upper_[i];
+    ++next;
+  }
+}
+void Model::resetBounds() {
+  Int next = 0;
+  for (Int i : free_variables_) {
+    lower_[i] = best_lower_[next];
+    upper_[i] = best_upper_[next];
+    ++next;
+  }
+}
+
 }  // namespace hipo

highs/ipm/hipo/ipm/Model.h

@@ -67,6 +67,8 @@ class Model {
 
   std::vector<Int> free_variables_;
 
+  std::vector<double> best_lower_, best_upper_;
+
   void preprocess();
   Int checkData() const;
   void computeNorms();
@@ -95,6 +97,9 @@ class Model {
   void adjustFreeVars(std::vector<double>& x, std::vector<double>& xl,
                       std::vector<double>& xu, const Logger& logger);
 
+  void saveBounds();
+  void resetBounds();
+
   // Check if variable has finite lower/upper bound
   bool hasLb(Int j) const { return std::isfinite(lower_[j]); }
   bool hasUb(Int j) const { return std::isfinite(upper_[j]); }

highs/ipm/hipo/ipm/Solver.cpp

@@ -167,8 +167,6 @@ bool Solver::initialise() {
       (LS_->nz() < kUplookNzPerColUpper * kkt_->n() &&
        LS_->flops() < kUplookSpopsRatioUpper * LS_->spops());
 
-  switch_to_uplooking = true;
-
   if (switch_to_uplooking) {
     LS_.reset(new UpLookingSolver(*kkt_, info_, it_->data, regul_, model_));
     LS_->setup();
@@ -368,6 +366,7 @@ bool Solver::solveNewtonSystem(NewtonDir& delta) {
       }
       LS_->clear();
       it_->data.back().factorisation_used = LS_->type();
+      it_->bad_iter_ = 0;
       logger_.printInfo("Switching to FactorHighs because of bad direction\n");
       resetToBestIter(iter_ - 1);