Simplify options

Author: filikat

highs/ipm/IpxWrapper.cpp

@@ -502,14 +502,7 @@ HighsStatus solveLpHipo(const HighsOptions& options, HighsTimer& timer,
   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;
-  }
+  hipo_options.crossover = options.run_crossover;
 
   // Potentially control if ipx is used for refinement and if it is displayed
   // hipo_options.refine_with_ipx = true;
@@ -538,19 +531,16 @@ HighsStatus solveLpHipo(const HighsOptions& options, HighsTimer& timer,
     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 {
+  // Linear system
+  if (options.hipo_system != kHipoAugmentedString &&
+      options.hipo_system != kHipoNormalEqString &&
+      options.hipo_system != kHighsChooseString) {
     highsLogUser(options.log_options, HighsLogType::kError,
                  "Unknown value of option %s\n", kHipoSystemString.c_str());
     model_status = HighsModelStatus::kSolveError;
     return HighsStatus::kError;
   }
+  hipo_options.nla = options.hipo_system;
 
   // Reordering heuristic
   if (options.hipo_ordering != kHipoMetisString &&
@@ -564,16 +554,15 @@ HighsStatus solveLpHipo(const HighsOptions& options, HighsTimer& timer,
   }
   hipo_options.ordering = options.hipo_ordering;
 
-  if (options.hipo_scaling == kHipoCRscaling) {
-    hipo_options.scaling = hipo::kOptionCRscaling;
-  } else if (options.hipo_scaling == kHipoNormScaling) {
-    hipo_options.scaling = hipo::kOptionNormScaling;
-  } else {
+  // Scaling strategy
+  if (options.hipo_scaling != kHipoCRscaling &&
+      options.hipo_scaling != kHipoNormScaling) {
     highsLogUser(options.log_options, HighsLogType::kError,
                  "Unknown value of option %s\n", kHipoScalingString.c_str());
     model_status = HighsModelStatus::kSolveError;
     return HighsStatus::kError;
   }
+  hipo_options.scaling = options.hipo_scaling;
 
   // block size option
   hipo_options.block_size = options.hipo_block_size;

highs/ipm/hipo/ipm/FactorHiGHSSolver.cpp

@@ -391,7 +391,7 @@ Int FactorHiGHSSolver::setup() {
 Int FactorHiGHSSolver::chooseNla() {
   // Choose whether to use augmented system or normal equations.
 
-  assert(options_.nla == kOptionNlaChoose);
+  assert(options_.nla == kHighsChooseString);
 
   Symbolic symb_NE{};
   Symbolic symb_AS{};
@@ -436,10 +436,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)
@@ -467,18 +467,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 {
@@ -588,33 +588,30 @@ Int FactorHiGHSSolver::chooseOrdering(const std::vector<Int>& rows,
 Int FactorHiGHSSolver::setNla() {
   std::stringstream log_stream;
 
-  switch (options_.nla) {
-    case kOptionNlaAugmented: {
-      if (analyseAS(S_)) {
-        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 (Int status = chooseNla()) return status;
   }
 
   log_.print(log_stream);

highs/ipm/hipo/ipm/Info.h

@@ -34,7 +34,7 @@ struct Info {
   Int correctors;
 
   // Nla option used
-  OptionNla option_nla;
+  std::string option_nla;
 
   // Parallel option used
   OptionParallel option_par;

highs/ipm/hipo/ipm/Iterate.cpp

@@ -300,7 +300,7 @@ void Iterate::extract(std::vector<double>& x_user, std::vector<double>& xl_user,
   zu_user = std::vector<double>(zu.begin(), zu.begin() + model.n_orig());
 
   // force unused entries to have correct value
-  for (int i = 0; i < model.n_orig(); ++i) {
+  for (Int i = 0; i < model.n_orig(); ++i) {
     if (!model.hasLb(i)) {
       xl_user[i] = kHighsInf;
       zl_user[i] = 0.0;
@@ -625,12 +625,12 @@ void Iterate::finalResiduals(Info& info) const {
   }
 }
 
-void Iterate::setReg(LinearSolver& LS, OptionNla opt) {
+void Iterate::setReg(LinearSolver& LS, const std::string& nla) {
   // extract regularisation
   LS.getReg(total_reg);
 
   // easy access to primal/dual regularisation
-  if (opt == kOptionNlaNormEq) {
+  if (nla == kHipoNormalEqString) {
     Rp = nullptr;
     Rd = total_reg.data();
   } else {

highs/ipm/hipo/ipm/Iterate.h

@@ -196,7 +196,7 @@ struct Iterate {
   // ===================================================================================
   void residuals6x6(const NewtonDir& d);
 
-  void setReg(LinearSolver& LS, OptionNla opt);
+  void setReg(LinearSolver& LS, const std::string& nla);
 };
 
 }  // namespace hipo

highs/ipm/hipo/ipm/Model.cpp

@@ -9,7 +9,8 @@ namespace hipo {
 Int Model::init(const Int num_var, const Int num_con, const double* obj,
                 const double* rhs, const double* lower, const double* upper,
                 const Int* A_ptr, const Int* A_rows, const double* A_vals,
-                const char* constraints, double offset, OptionScaling opt) {
+                const char* constraints, double offset,
+                const std::string& scaling) {
   // copy the input into the model
 
   if (checkData(num_var, num_con, obj, rhs, lower, upper, A_ptr, A_rows, A_vals,
@@ -45,7 +46,7 @@ Int Model::init(const Int num_var, const Int num_con, const double* obj,
   constraints_ = std::vector<char>(constraints, constraints + m_);
 
   preprocess();
-  scale(opt);
+  scale(scaling);
   reformulate();
   denseColumns();
   computeNorms();
@@ -317,7 +318,7 @@ void Model::print(const LogHighs& log) const {
   }
   if (std::isinf(bmin)) bmin = 0.0;
 
-  // compute max and min inerval for bounds
+  // compute max and min interval for bounds
   double boundmin = kHighsInf;
   double boundmax = 0.0;
   for (Int i = 0; i < n_; ++i) {
@@ -409,7 +410,7 @@ static double roundToPowerOf2(double d) {
   return std::ldexp(1.0, exp);
 }
 
-void Model::scale(OptionScaling opt) {
+void Model::scale(const std::string& scaling) {
   // Compute scaling:
   // A -> R * A * C
   // b -> R * b
@@ -422,9 +423,9 @@ void Model::scale(OptionScaling opt) {
   colscale_.resize(n_, 1.0);
   rowscale_.resize(m_, 1.0);
 
-  if (opt == kOptionCRscaling) {
+  if (scaling == kHipoCRscaling) {
     CRscaling();
-  } else if (opt == kOptionNormScaling) {
+  } else if (scaling == kHipoNormScaling) {
     const Int num_passes = 2;
     for (Int pass = 0; pass < num_passes; ++pass) {
       onePassNormScaling();

highs/ipm/hipo/ipm/Model.h

@@ -81,7 +81,7 @@ class Model {
                 const char* constraints) const;
   void computeNorms();
 
-  void scale(OptionScaling opt);
+  void scale(const std::string& scaling);
   void applyScaling();
   void CRscaling();
   void onePassNormScaling();
@@ -92,7 +92,7 @@ class Model {
   Int init(const Int num_var, const Int num_con, const double* obj,
            const double* rhs, const double* lower, const double* upper,
            const Int* A_ptr, const Int* A_rows, const double* A_vals,
-           const char* constraints, double offset, OptionScaling opt);
+           const char* constraints, double offset, const std::string& scaling);
 
   // Print information of model
   void print(const LogHighs& log) const;

highs/ipm/hipo/ipm/Options.h

@@ -3,27 +3,10 @@
 
 #include "Parameters.h"
 #include "io/HighsIO.h"
+#include "lp_data/HighsOptions.h"
 
 namespace hipo {
 
-enum OptionNla {
-  kOptionNlaMin = 0,
-  kOptionNlaAugmented = kOptionNlaMin,
-  kOptionNlaNormEq,
-  kOptionNlaChoose,
-  kOptionNlaMax = kOptionNlaChoose,
-  kOptionNlaDefault = kOptionNlaChoose
-};
-
-enum OptionCrossover {
-  kOptionCrossoverMin = 0,
-  kOptionCrossoverOff = kOptionCrossoverMin,
-  kOptionCrossoverOn,
-  kOptionCrossoverChoose,
-  kOptionCrossoverMax = kOptionCrossoverChoose,
-  kOptionCrossoverDefault = kOptionCrossoverOff
-};
-
 enum OptionParallel {
   kOptionParallelMin = 0,
   kOptionParallelOff = kOptionParallelMin,  // tree off     node off
@@ -35,21 +18,13 @@ enum OptionParallel {
   kOptionParallelDefault = kOptionParallelChoose
 };
 
-enum OptionScaling {
-  kOptionScalingMin = 0,
-  kOptionCRscaling = kOptionScalingMin,
-  kOptionNormScaling,
-  kOptionScalingMax = kOptionNormScaling,
-  kOptionScalingDefault = kOptionCRscaling
-};
-
 struct Options {
   // Solver options
-  OptionNla nla = kOptionNlaDefault;
-  OptionCrossover crossover = kOptionCrossoverDefault;
-  OptionParallel parallel = kOptionParallelDefault;
+  std::string nla = kHighsChooseString;
+  std::string crossover = kHighsOffString;
   std::string ordering = kHighsChooseString;
-  OptionScaling scaling = kOptionScalingDefault;
+  std::string scaling = kHipoCRscaling;
+  OptionParallel parallel = kOptionParallelDefault;
 
   // Ipm parameters
   Int max_iter = kMaxIterDefault;