Merge branch 'latest' into presolve-logging

Author: jajhall

highs/ipm/IpxWrapper.cpp

@@ -468,106 +468,15 @@ HighsStatus solveHipo(const HighsOptions& options, HighsTimer& timer,
   // ipx_lps.control_ elapsed time
   hipo.setIpxTimerOffset(timer.read());
 
-  hipo::Options hipo_options{};
-
-  hipo_options.display = true;
-  if (!options.output_flag | !options.log_to_console)
-    hipo_options.display = false;
-
-  hipo_options.log_options = &options.log_options;
-
-  // Debug option is already considered through log_options.log_dev_level in
-  // hipo::LogHighs::debug
-
-  hipo_options.timeless_log = options.timeless_log;
-  hipo_options.feasibility_tol = std::min(options.primal_feasibility_tolerance,
-                                          options.dual_feasibility_tolerance);
-  hipo_options.optimality_tol = options.ipm_optimality_tolerance;
-  hipo_options.crossover_tol = options.start_crossover_tolerance;
-
   if (options.kkt_tolerance != kDefaultKktTolerance) {
-    hipo_options.feasibility_tol = options.kkt_tolerance;
-    hipo_options.optimality_tol = 1e-1 * options.kkt_tolerance;
-    hipo_options.crossover_tol = 1e-1 * options.kkt_tolerance;
     highsLogUser(options.log_options, HighsLogType::kInfo,
                  "IpxWrapper: feasibility_tol = %g; optimality_tol = %g; "
                  "crossover_tol = %g\n",
-                 hipo_options.feasibility_tol, hipo_options.optimality_tol,
-                 hipo_options.crossover_tol);
-  }
-
-  // hipo uses same timer as highs, so it is fine to pass the same time limit
-  hipo_options.time_limit = options.time_limit;
-
-  hipo_options.max_iter =
-      options.ipm_iteration_limit - highs_info.ipm_iteration_count;
-
-  if (options.run_crossover == kHighsOnString)
-    hipo_options.crossover = hipo::kOptionCrossoverOn;
-  else if (options.run_crossover == kHighsOffString)
-    hipo_options.crossover = hipo::kOptionCrossoverOff;
-  else {
-    assert(options.run_crossover == kHighsChooseString);
-    hipo_options.crossover = hipo::kOptionCrossoverChoose;
-  }
-
-  // Potentially control if ipx is used for refinement and if it is displayed
-  // hipo_options.refine_with_ipx = true;
-  hipo_options.display_ipx = true;
-
-  // if option parallel is on, it can be refined by option hipo_parallel_type
-  if (options.parallel == kHighsOnString) {
-    if (options.hipo_parallel_type == kHipoTreeString)
-      hipo_options.parallel = hipo::kOptionParallelTreeOnly;
-    else if (options.hipo_parallel_type == kHipoNodeString)
-      hipo_options.parallel = hipo::kOptionParallelNodeOnly;
-    else if (options.hipo_parallel_type == kHipoBothString)
-      hipo_options.parallel = hipo::kOptionParallelOn;
-    else {
-      highsLogUser(options.log_options, HighsLogType::kError,
-                   "Unknown value of option %s\n", kHipoParallelString.c_str());
-      model_status = HighsModelStatus::kSolveError;
-      return HighsStatus::kError;
-    }
+                 options.kkt_tolerance, 1e-1 * options.kkt_tolerance,
+                 1e-1 * options.kkt_tolerance);
   }
-  // otherwise, option hipo_parallel_type is ignored
-  else if (options.parallel == kHighsOffString)
-    hipo_options.parallel = hipo::kOptionParallelOff;
-  else {
-    assert(options.parallel == kHighsChooseString);
-    hipo_options.parallel = hipo::kOptionParallelChoose;
-  }
-
-  // Parse hipo_system option
-  if (options.hipo_system == kHipoAugmentedString) {
-    hipo_options.nla = hipo::kOptionNlaAugmented;
-  } else if (options.hipo_system == kHipoNormalEqString) {
-    hipo_options.nla = hipo::kOptionNlaNormEq;
-  } else if (options.hipo_system == kHighsChooseString) {
-    hipo_options.nla = hipo::kOptionNlaChoose;
-  } else {
-    highsLogUser(options.log_options, HighsLogType::kError,
-                 "Unknown value of option %s\n", kHipoSystemString.c_str());
-    model_status = HighsModelStatus::kSolveError;
-    return HighsStatus::kError;
-  }
-
-  // Reordering heuristic
-  if (options.hipo_ordering != kHipoMetisString &&
-      options.hipo_ordering != kHipoAmdString &&
-      options.hipo_ordering != kHipoRcmString &&
-      options.hipo_ordering != kHighsChooseString) {
-    highsLogUser(options.log_options, HighsLogType::kError,
-                 "Unknown value of option %s\n", kHipoOrderingString.c_str());
-    model_status = HighsModelStatus::kSolveError;
-    return HighsStatus::kError;
-  }
-  hipo_options.ordering = options.hipo_ordering;
-
-  // block size option
-  hipo_options.block_size = options.hipo_block_size;
 
-  hipo.setOptions(hipo_options);
+  hipo.setOptions(options);
   hipo.setTimer(timer);
   hipo.setCallback(callback);
 

highs/ipm/hipo/ipm/FactorHiGHSSolver.cpp

@@ -452,10 +452,10 @@ Int FactorHiGHSSolver::chooseNla() {
 
   // Decision may be forced by failures
   if (failure_NE && !failure_AS) {
-    options_.nla = kOptionNlaAugmented;
+    options_.nla = kHipoAugmentedString;
     log_stream << textline("Newton system:") << "AS preferred (NE failed)\n";
   } else if (failure_AS && !failure_NE) {
-    options_.nla = kOptionNlaNormEq;
+    options_.nla = kHipoNormalEqString;
     log_stream << textline("Newton system:") << "NE preferred (AS failed)\n";
   } else if (failure_AS && failure_NE) {
     if (overflow_AS && overflow_NE)
@@ -483,18 +483,18 @@ Int FactorHiGHSSolver::chooseNla() {
 
     if (NE_much_more_expensive ||
         (sn_AS_larger_than_NE && AS_not_too_expensive)) {
-      options_.nla = kOptionNlaAugmented;
+      options_.nla = kHipoAugmentedString;
       log_stream << textline("Newton system:") << "AS preferred\n";
     } else {
-      options_.nla = kOptionNlaNormEq;
+      options_.nla = kHipoNormalEqString;
       log_stream << textline("Newton system:") << "NE preferred\n";
     }
   }
 
   log_.print(log_stream);
 
   if (status == kStatusOk) {
-    if (options_.nla == kOptionNlaAugmented) {
+    if (options_.nla == kHipoAugmentedString) {
       S_ = std::move(symb_AS);
       freeNEmemory();
     } else {
@@ -604,44 +604,38 @@ Int FactorHiGHSSolver::chooseOrdering(const std::vector<Int>& rows,
 Int FactorHiGHSSolver::setNla() {
   std::stringstream log_stream;
 
-  hipo::OptionNla nla = options_.nla;
-  if (nla == kOptionNlaNormEq && model_.nonSeparableQp()) {
+  if (options_.nla == kHipoNormalEqString && model_.nonSeparableQp()) {
     log_.printw("Normal equations not available for non-separable QP\n");
-    nla = kOptionNlaChoose;
+    options_.nla = kHighsChooseString;
   }
 
-  switch (nla) {
-    case kOptionNlaAugmented: {
-      Int status = analyseAS(S_);
-      if (status == kStatusOverflow) {
-        log_.printe("AS requested, integer overflow\n");
-        return kStatusOverflow;
-      } else if (status) {
-        log_.printe("AS requested, failed analyse phase\n");
-        return kStatusErrorAnalyse;
-      }
-      log_stream << textline("Newton system:") << "AS requested\n";
-      break;
+  if (options_.nla == kHipoAugmentedString) {
+    Int status = analyseAS(S_);
+    if (status == kStatusOverflow) {
+      log_.printe("AS requested, integer overflow\n");
+      return kStatusOverflow;
+    } else if (status) {
+      log_.printe("AS requested, failed analyse phase\n");
+      return kStatusErrorAnalyse;
     }
-
-    case kOptionNlaNormEq: {
-      Int status = analyseNE(S_);
-      if (status == kStatusOverflow) {
-        log_.printe("NE requested, integer overflow\n");
-        return kStatusOverflow;
-      } else if (status) {
-        log_.printe("NE requested, failed analyse phase\n");
-        return kStatusErrorAnalyse;
-      }
-      log_stream << textline("Newton system:") << "NE requested\n";
-      break;
+    log_stream << textline("Newton system:") << "AS requested\n";
+
+  } else if (options_.nla == kHipoNormalEqString) {
+    Int status = analyseNE(S_);
+    if (status == kStatusOverflow) {
+      log_.printe("NE requested, integer overflow\n");
+      return kStatusOverflow;
+    } else if (status) {
+      log_.printe("NE requested, failed analyse phase\n");
+      return kStatusErrorAnalyse;
     }
+    log_stream << textline("Newton system:") << "NE requested\n";
 
-    case kOptionNlaChoose: {
-      if (Int status = chooseNla()) return status;
-      break;
-    }
-  }
+  } else if (options_.nla == kHighsChooseString) {
+    if (Int status = chooseNla()) return status;
+
+  } else
+    assert(1 == 0);
 
   log_.print(log_stream);
 
@@ -656,81 +650,74 @@ void FactorHiGHSSolver::setParallel() {
   std::stringstream log_stream;
   log_stream << textline("Parallelism:");
 
-  switch (options_.parallel) {
-    case kOptionParallelOff:
-      log_stream << "None requested\n";
-      break;
-    case kOptionParallelOn:
+  if (options_.parallel == kHighsOffString) {
+    log_stream << "None requested\n";
+  } else if (options_.parallel == kHighsOnString) {
+    if (options_.parallel_type == kHipoBothString) {
       parallel_tree = true;
       parallel_node = true;
       log_stream << "Full requested\n";
-      break;
-    case kOptionParallelChoose: {
-#ifdef HIPO_USES_APPLE_BLAS
-      // Blas on Apple do not work well with parallel_node, but parallel_tree
-      // seems to always be beneficial.
-      parallel_node = false;
+    } else if (options_.parallel_type == kHipoTreeString) {
       parallel_tree = true;
-#else
-      // Otherwise, parallel_node is active because it is triggered only if the
-      // frontal matrix is large enough anyway.
+      log_stream << "Tree requested\n";
+    } else if (options_.parallel_type == kHipoNodeString) {
       parallel_node = true;
+      log_stream << "Node requested\n";
+    } else
+      assert(1 == 0);
 
-      // parallel_tree instead is chosen with a heuristic
-
-      double tree_speedup = S_.flops() / S_.critops();
-      double sn_size = (double)S_.size() / S_.sn();
-
-      bool enough_sn = S_.sn() > kMinNumberSn;
-      bool enough_flops = S_.flops() > kLargeFlopsThresh;
-      bool speedup_is_large = tree_speedup > kLargeSpeedupThresh;
-      bool sn_are_large = sn_size > kLargeSnThresh;
-      bool sn_are_not_small = sn_size > kSmallSnThresh;
-
-      // parallel_tree is active if the supernodes are large, or if there is a
-      // large expected speedup and the supernodes are not too small, provided
-      // that the number of flops and supernodes is not too small.
-      if (enough_sn && enough_flops &&
-          (sn_are_large || (speedup_is_large && sn_are_not_small))) {
-        parallel_tree = true;
-      }
+  } else if (options_.parallel == kHighsChooseString) {
+#ifdef HIPO_USES_APPLE_BLAS
+    // Blas on Apple do not work well with parallel_node, but parallel_tree
+    // seems to always be beneficial.
+    parallel_node = false;
+    parallel_tree = true;
+#else
+    // Otherwise, parallel_node is active because it is triggered only if the
+    // frontal matrix is large enough anyway.
+    parallel_node = true;
+
+    // parallel_tree instead is chosen with a heuristic
+
+    double tree_speedup = S_.flops() / S_.critops();
+    double sn_size = (double)S_.size() / S_.sn();
+
+    bool enough_sn = S_.sn() > kMinNumberSn;
+    bool enough_flops = S_.flops() > kLargeFlopsThresh;
+    bool speedup_is_large = tree_speedup > kLargeSpeedupThresh;
+    bool sn_are_large = sn_size > kLargeSnThresh;
+    bool sn_are_not_small = sn_size > kSmallSnThresh;
+
+    // parallel_tree is active if the supernodes are large, or if there is a
+    // large expected speedup and the supernodes are not too small, provided
+    // that the number of flops and supernodes is not too small.
+    if (enough_sn && enough_flops &&
+        (sn_are_large || (speedup_is_large && sn_are_not_small))) {
+      parallel_tree = true;
+    }
 #endif
 
-      // If serial memory is too large, switch off tree parallelism to avoid
-      // running out of memory
-      double num_GB = S_.storage() / 1024 / 1024 / 1024;
-      if (num_GB > kLargeStorageGB) {
-        parallel_tree = false;
-      }
+    // If serial memory is too large, switch off tree parallelism to avoid
+    // running out of memory
+    double num_GB = S_.storage() / 1024 / 1024 / 1024;
+    if (num_GB > kLargeStorageGB) {
+      parallel_tree = false;
+    }
 
-      // switch off tree parallelism if depth of recursion is too large
-      if (S_.depth() > kMaxTreeDepth) parallel_tree = false;
-
-      if (parallel_tree && parallel_node) {
-        options_.parallel = kOptionParallelOn;
-        log_stream << "Full preferred\n";
-      } else if (parallel_tree && !parallel_node) {
-        options_.parallel = kOptionParallelTreeOnly;
-        log_stream << "Tree preferred\n";
-      } else if (!parallel_tree && parallel_node) {
-        options_.parallel = kOptionParallelNodeOnly;
-        log_stream << "Node preferred\n";
-      } else {
-        options_.parallel = kOptionParallelOff;
-        log_stream << "None preferred\n";
-      }
+    // switch off tree parallelism if depth of recursion is too large
+    if (S_.depth() > kMaxTreeDepth) parallel_tree = false;
 
-      break;
-    }
-    case kOptionParallelTreeOnly:
-      parallel_tree = true;
-      log_stream << "Tree requested\n";
-      break;
-    case kOptionParallelNodeOnly:
-      parallel_node = true;
-      log_stream << "Node requested\n";
-      break;
-  }
+    if (parallel_tree && parallel_node)
+      log_stream << "Full preferred\n";
+    else if (parallel_tree && !parallel_node)
+      log_stream << "Tree preferred\n";
+    else if (!parallel_tree && parallel_node)
+      log_stream << "Node preferred\n";
+    else
+      log_stream << "None preferred\n";
+
+  } else
+    assert(1 == 0);
 
   log_.print(log_stream);
   S_.setParallel(parallel_tree, parallel_node);

highs/ipm/hipo/ipm/Info.h

@@ -33,12 +33,6 @@ struct Info {
   // Number of correctors used
   Int correctors;
 
-  // Nla option used
-  OptionNla option_nla;
-
-  // Parallel option used
-  OptionParallel option_par;
-
   // Total times to form matrix, factorise and solve linear systems
   double analyse_NE_time{};
   double analyse_AS_time{};