Merge branch 'hipo-status' into hipo-uplook

Author: filikat

highs/ipm/IpxWrapper.cpp

@@ -491,15 +491,8 @@ HighsStatus solveHipo(const HighsOptions& options, HighsTimer& timer,
   // const bool report_solve_data =
   //    kHighsAnalysisLevelSolverSummaryData & options.highs_analysis_level;
 
-  // Differently from IPX, HiPO returns a single status. So, dealing with
-  // statuses is a bit different.
   // hipo.solved(), hipo.stopped(), hipo.failed() can be used to query if the
   // status belongs to the solved, stopped or failed group.
-  // If primal-dual feasible solution is found (non-vertex solution), then the
-  // status is kStatusPDfeas.
-  // If crossover is successful, then the status is kStatusBasic.
-  // Otherwise, the specific crossover status can be accessed through the
-  // ipx_info stored in hipo_info.
 
   // Get solver and solution information.
   const hipo::Info hipo_info = hipo.getInfo();
@@ -584,16 +577,14 @@ HighsStatus solveHipo(const HighsOptions& options, HighsTimer& timer,
   }
 
   // Status should be optimal or imprecise
-  if (ipxStatusError(solve_status != hipo::kStatusPDFeas &&
-                         solve_status != hipo::kStatusBasic &&
+  if (ipxStatusError(solve_status != hipo::kStatusOptimal &&
                          solve_status != hipo::kStatusImprecise,
                      options, "Hipo",
                      "status should be optimal or imprecise but value is",
                      solve_status))
     return HighsStatus::kError;
 
   const bool have_basic_solution =
-      hipo_info.ipx_used &&
       hipo_info.ipx_info.status_crossover != IPX_STATUS_not_run;
 
   const bool imprecise_solution =
@@ -1397,51 +1388,15 @@ HighsStatus reportHipoStatus(const HighsOptions& options,
     return HighsStatus::kOk;
   }
 
-  // these are warnings
-  else if (status == hipo::kStatusTimeLimit) {
-    highsLogUser(options.log_options, HighsLogType::kWarning,
-                 "Hipo: Time limit\n");
-    return HighsStatus::kWarning;
-  } else if (status == hipo::kStatusUserInterrupt) {
-    highsLogUser(options.log_options, HighsLogType::kWarning,
-                 "Hipo: User interrupt\n");
-    return HighsStatus::kWarning;
-  } else if (status == hipo::kStatusMaxIter) {
-    highsLogUser(options.log_options, HighsLogType::kWarning,
-                 "Hipo: Reached maximum iterations\n");
-    return HighsStatus::kWarning;
-  } else if (status == hipo::kStatusNoProgress) {
-    highsLogUser(options.log_options, HighsLogType::kWarning,
-                 "Hipo: No progress\n");
-    return HighsStatus::kWarning;
-  } else if (status == hipo::kStatusImprecise) {
-    highsLogUser(options.log_options, HighsLogType::kWarning,
-                 "Hipo: Imprecise solution\n");
+  else if (hipo.stopped()) {
+    highsLogUser(options.log_options, HighsLogType::kWarning, "Hipo: %s\n",
+                 hipo::statusString((hipo::Status)status).c_str());
     return HighsStatus::kWarning;
   }
 
-  // these are errors
-  else if (status == hipo::kStatusError) {
-    highsLogUser(options.log_options, HighsLogType::kError,
-                 "Hipo: Internal error\n");
-  } else if (status == hipo::kStatusOverflow) {
-    highsLogUser(options.log_options, HighsLogType::kError,
-                 "Hipo: Integer overflow\n");
-  } else if (status == hipo::kStatusErrorAnalyse) {
-    highsLogUser(options.log_options, HighsLogType::kError,
-                 "Hipo: Error in analyse phase\n");
-  } else if (status == hipo::kStatusErrorFactorise) {
-    highsLogUser(options.log_options, HighsLogType::kError,
-                 "Hipo: Error in factorise phase\n");
-  } else if (status == hipo::kStatusErrorSolve) {
-    highsLogUser(options.log_options, HighsLogType::kError,
-                 "Hipo: Error in solve phase\n");
-  } else if (status == hipo::kStatusBadModel) {
-    highsLogUser(options.log_options, HighsLogType::kError,
-                 "Hipo: Invalid model\n");
-  } else {
-    highsLogUser(options.log_options, HighsLogType::kError,
-                 "Hipo: Unrecognized status\n");
+  else if (hipo.failed()) {
+    highsLogUser(options.log_options, HighsLogType::kError, "Hipo: %s\n",
+                 hipo::statusString((hipo::Status)status).c_str());
   }
   return HighsStatus::kError;
 }

highs/ipm/hipo/ipm/FactorHighsSolver.cpp

@@ -40,12 +40,11 @@ Int FactorHighsSolver::analyseAS(Symbolic& S) {
   // Perform analyse phase of augmented system and return symbolic factorisation
   // in object S and the status.
 
-  if (kkt_.rowsAS.empty() || kkt_.ptrAS.empty()) return kStatusErrorAnalyse;
+  if (kkt_.rowsAS.empty() || kkt_.ptrAS.empty()) return kErrorAnalyse;
 
   const Int m = model_.A().num_row_;
   const Int n = model_.A().num_col_;
 
-  // create vector of signs of pivots
   std::vector<Int> pivot_signs(n + m, -1);
   for (Int i = 0; i < m; ++i) pivot_signs[n + i] = 1;
 
@@ -64,9 +63,8 @@ Int FactorHighsSolver::analyseNE(Symbolic& S) {
   // in object S and the status. Structure of the matrix must be already
   // computed.
 
-  if (kkt_.rowsNE.empty() || kkt_.ptrNE.empty()) return kStatusErrorAnalyse;
+  if (kkt_.rowsNE.empty() || kkt_.ptrNE.empty()) return kErrorAnalyse;
 
-  // create vector of signs of pivots
   std::vector<Int> pivot_signs(model_.A().num_row_, 1);
 
   logger_.printInfo("Performing NE analyse phase\n");
@@ -84,7 +82,6 @@ Int FactorHighsSolver::analyseNE(Symbolic& S) {
 // =========================================================================
 
 Int FactorHighsSolver::factorAS(const std::vector<double>& scaling) {
-  // only execute factorisation if it has not been done yet
   assert(!this->valid_);
 
   kkt_.buildASvalues(scaling);
@@ -95,16 +92,15 @@ Int FactorHighsSolver::factorAS(const std::vector<double>& scaling) {
   Clock clock;
   if (FH_.factorise(kkt_.S, kkt_.n(), kkt_.nz(), kkt_.rowsAS.data(),
                     kkt_.ptrAS.data(), kkt_.valAS.data()))
-    return kStatusErrorFactorise;
+    return kErrorFactorise;
   info_.factor_time += clock.stop();
   info_.factor_number++;
 
   this->valid_ = true;
-  return kStatusOk;
+  return kOk;
 }
 
 Int FactorHighsSolver::factorNE(const std::vector<double>& scaling) {
-  // only execute factorisation if it has not been done yet
   assert(!this->valid_);
 
   kkt_.buildNEvalues(scaling);
@@ -115,12 +111,12 @@ Int FactorHighsSolver::factorNE(const std::vector<double>& scaling) {
   Clock clock;
   if (FH_.factorise(kkt_.S, kkt_.n(), kkt_.nz(), kkt_.rowsNE.data(),
                     kkt_.ptrNE.data(), kkt_.valNE.data()))
-    return kStatusErrorFactorise;
+    return kErrorFactorise;
   info_.factor_time += clock.stop();
   info_.factor_number++;
 
   this->valid_ = true;
-  return kStatusOk;
+  return kOk;
 }
 
 // =========================================================================
@@ -131,48 +127,43 @@ Int FactorHighsSolver::solveAS(const std::vector<double>& rhs_x,
                                const std::vector<double>& rhs_y,
                                std::vector<double>& lhs_x,
                                std::vector<double>& lhs_y) {
-  // only execute the solve if factorisation is valid
   assert(this->valid_);
 
   Int n = rhs_x.size();
 
-  // create single rhs
   std::vector<double> rhs;
   rhs.insert(rhs.end(), rhs_x.begin(), rhs_x.end());
   rhs.insert(rhs.end(), rhs_y.begin(), rhs_y.end());
 
   Clock clock;
-  if (FH_.solve(rhs.data())) return kStatusErrorSolve;
+  if (FH_.solve(rhs.data())) return kErrorSolve;
 
   info_.solve_time += clock.stop();
   info_.solve_number++;
 
   data_.back().num_solves++;
 
-  // split lhs
   lhs_x = std::vector<double>(rhs.begin(), rhs.begin() + n);
   lhs_y = std::vector<double>(rhs.begin() + n, rhs.end());
 
-  return kStatusOk;
+  return kOk;
 }
 
 Int FactorHighsSolver::solveNE(const std::vector<double>& rhs,
                                std::vector<double>& lhs) {
-  // only execute the solve if factorisation is valid
   assert(this->valid_);
 
-  // initialise lhs with rhs
   lhs = rhs;
 
   Clock clock;
-  if (FH_.solve(lhs.data())) return kStatusErrorSolve;
+  if (FH_.solve(lhs.data())) return kErrorSolve;
 
   info_.solve_time += clock.stop();
   info_.solve_number++;
 
   data_.back().num_solves++;
 
-  return kStatusOk;
+  return kOk;
 }
 
 // =========================================================================
@@ -195,20 +186,17 @@ Int FactorHighsSolver::setup() {
 
     kkt_.S.print(logger_, logger_.debug(1));
 
-    // Warn about large memory consumption
     if (kkt_.S.storage() > kLargeStorageGB * 1024 * 1024 * 1024) {
       logger_.printw("Large amount of memory required\n");
     }
 
     logger_.print("\n");
   }
 
-  return kStatusOk;
+  return kOk;
 }
 
 Int FactorHighsSolver::chooseNla() {
-  // Choose whether to use augmented system or normal equations.
-
   Symbolic symb_NE{};
   Symbolic symb_AS{};
   bool failure_NE = false;
@@ -238,7 +226,7 @@ Int FactorHighsSolver::chooseNla() {
       Int status = kkt_.buildNEstructure();
       if (status) {
         failure_NE = true;
-        if (status == kStatusOverflow) {
+        if (status == kErrorOverflow) {
           logger_.printInfo("Integer overflow forming NE matrix\n");
           overflow_NE = true;
         }
@@ -261,7 +249,7 @@ Int FactorHighsSolver::chooseNla() {
       Int AS_status = kkt_.buildASstructure();
       if (!AS_status) AS_status = analyseAS(symb_AS);
       if (AS_status) failure_AS = true;
-      if (AS_status == kStatusOverflow) {
+      if (AS_status == kErrorOverflow) {
         logger_.printInfo("Integer overflow forming AS matrix\n");
         overflow_AS = true;
       }
@@ -301,11 +289,10 @@ Int FactorHighsSolver::chooseNla() {
     run_analyse_AS();
   }
 
-  Int status = kStatusOk;
+  Int status = kOk;
 
   std::stringstream log_stream;
 
-  // Decision may be forced by failures
   if (failure_NE && !failure_AS) {
     options_.nla = kHipoAugmentedString;
     log_stream << textline("Newton system:") << "AS preferred (NE failed)\n";
@@ -314,9 +301,9 @@ Int FactorHighsSolver::chooseNla() {
     log_stream << textline("Newton system:") << "NE preferred (AS failed)\n";
   } else if (failure_AS && failure_NE) {
     if (overflow_AS && overflow_NE)
-      status = kStatusOverflow;
+      status = kErrorOverflow;
     else
-      status = kStatusErrorAnalyse;
+      status = kErrorAnalyse;
 
     logger_.printe("Both NE and AS failed analyse phase\n");
   } else {
@@ -325,7 +312,6 @@ Int FactorHighsSolver::chooseNla() {
     double ops_NE = symb_NE.flops() + symb_NE.spops() * kSpopsWeight;
     double ops_AS = symb_AS.flops() + symb_AS.spops() * kSpopsWeight;
 
-    // Average size of supernodes
     double sn_size_NE = (double)symb_NE.size() / symb_NE.sn();
     double sn_size_AS = (double)symb_AS.size() / symb_AS.sn();
 
@@ -348,7 +334,7 @@ Int FactorHighsSolver::chooseNla() {
 
   logger_.print(log_stream.str().c_str());
 
-  if (status == kStatusOk) {
+  if (status == kOk) {
     if (options_.nla == kHipoAugmentedString) {
       kkt_.S = std::move(symb_AS);
       kkt_.freeNEmemory();
@@ -370,7 +356,6 @@ Int FactorHighsSolver::chooseOrdering(const std::vector<Int>& rows,
   // - If ordering is "amd", "metis", "rcm" run only the ordering requested.
   // - If ordering is "choose", run "amd", "metis", and choose the best.
 
-  // select which fill-reducing orderings should be tried
   std::vector<std::string> orderings_to_try;
   if (options_.ordering != kHighsChooseString)
     orderings_to_try.push_back(options_.ordering);
@@ -387,7 +372,7 @@ Int FactorHighsSolver::chooseOrdering(const std::vector<Int>& rows,
   if (nla == "NE") {
     if (ptr.back() >= kkt_.NE_nz_limit.load(std::memory_order_relaxed)) {
       logger_.printInfo("NE interrupted\n");
-      return kStatusErrorAnalyse;
+      return kErrorAnalyse;
     }
   }
 
@@ -516,7 +501,7 @@ Int FactorHighsSolver::chooseOrdering(const std::vector<Int>& rows,
     ordering = orderings_to_try[chosen];
   }
 
-  return num_success > 0 ? kStatusOk : kStatusErrorAnalyse;
+  return num_success > 0 ? kOk : kErrorAnalyse;
 }
 
 Int FactorHighsSolver::setNla() {
@@ -530,24 +515,24 @@ Int FactorHighsSolver::setNla() {
   if (options_.nla == kHipoAugmentedString) {
     Int status = kkt_.buildASstructure();
     if (!status) status = analyseAS(kkt_.S);
-    if (status == kStatusOverflow) {
+    if (status == kErrorOverflow) {
       logger_.printe("AS requested, integer overflow\n");
-      return kStatusOverflow;
+      return kErrorOverflow;
     } else if (status) {
       logger_.printe("AS requested, failed analyse phase\n");
-      return kStatusErrorAnalyse;
+      return kErrorAnalyse;
     }
     log_stream << textline("Newton system:") << "AS requested\n";
 
   } else if (options_.nla == kHipoNormalEqString) {
     Int status = kkt_.buildNEstructure();
     if (!status) status = analyseNE(kkt_.S);
-    if (status == kStatusOverflow) {
+    if (status == kErrorOverflow) {
       logger_.printe("NE requested, integer overflow\n");
-      return kStatusOverflow;
+      return kErrorOverflow;
     } else if (status) {
       logger_.printe("NE requested, failed analyse phase\n");
-      return kStatusErrorAnalyse;
+      return kErrorAnalyse;
     }
     log_stream << textline("Newton system:") << "NE requested\n";
 
@@ -564,15 +549,14 @@ Int FactorHighsSolver::setNla() {
                << '\n';
   logger_.print(log_stream.str().c_str());
 
-  return kStatusOk;
+  return kOk;
 }
 
 static bool usingAppleBlas() {
   return strstr(HighsExtras::blas::getInfo()->provider, "Apple") != nullptr;
 }
 
 void FactorHighsSolver::setParallel() {
-  // Set parallel options
   bool parallel_tree = false;
   bool parallel_node = false;
 

highs/ipm/hipo/ipm/FactorHighsSolver.h

@@ -15,7 +15,6 @@
 namespace hipo {
 
 class FactorHighsSolver : public LinearSolver {
-  // object to perform factorisation
   FHsolver FH_;
 
   KktMatrix& kkt_;
@@ -44,7 +43,6 @@ class FactorHighsSolver : public LinearSolver {
                     const Regularisation& regul, Info& info, IpmData& record,
                     const Logger& logger);
 
-  // Override functions
   Int factorAS(const std::vector<double>& scaling) override;
   Int factorNE(const std::vector<double>& scaling) override;
   Int solveNE(const std::vector<double>& rhs,

highs/ipm/hipo/ipm/Info.h

@@ -16,7 +16,8 @@ struct Info {
   Int m_original, n_original;
 
   // Status of solver, see IpmStatus.h
-  Status status = kStatusNotRun;
+  Status status = kStatusNotSet;
+  Int error = kOk;
 
   // residuals and objectives of final solution
   double p_res_rel, p_res_abs, d_res_rel, d_res_abs, p_obj, d_obj, pd_gap;