Remove GlobalizationLayer and SubproblemLayer

uno/Uno.cpp

@@ -5,7 +5,6 @@
 #include "Uno.hpp"
 #include "ingredients/constraint_relaxation_strategies/ConstraintRelaxationStrategy.hpp"
 #include "ingredients/constraint_relaxation_strategies/ConstraintRelaxationStrategyFactory.hpp"
-#include "ingredients/globalization_mechanisms/GlobalizationMechanism.hpp"
 #include "ingredients/globalization_mechanisms/GlobalizationMechanismFactory.hpp"
 #include "ingredients/globalization_strategies/GlobalizationStrategyFactory.hpp"
 #include "ingredients/inequality_handling_methods/InequalityHandlingMethodFactory.hpp"
@@ -26,7 +25,8 @@
 namespace uno {
    Uno::Uno(size_t number_constraints, size_t number_bounds_constraints, const Options& options) :
          constraint_relaxation_strategy(ConstraintRelaxationStrategyFactory::create(number_constraints, number_bounds_constraints, options)),
-         globalization_layer(number_constraints, options),
+         globalization_strategy(GlobalizationStrategyFactory::create(number_constraints, options)),
+         globalization_mechanism(GlobalizationMechanismFactory::create(options)),
          max_iterations(options.get_unsigned_int("max_iterations")),
          time_limit(options.get_double("time_limit")),
          print_solution(options.get_bool("print_solution")) { }
@@ -66,8 +66,8 @@ namespace uno {
 
                // compute an acceptable iterate by solving a subproblem at the current point
                warmstart_information.iterate_changed();
-               this->globalization_layer.mechanism->compute_next_iterate(statistics, *this->constraint_relaxation_strategy,
-                  *this->globalization_layer.strategy, model, current_iterate, trial_iterate, this->direction, warmstart_information,
+               this->globalization_mechanism->compute_next_iterate(statistics, *this->constraint_relaxation_strategy,
+                  *this->globalization_strategy, model, current_iterate, trial_iterate, this->direction, warmstart_information,
                   user_callbacks);
                termination = this->termination_criteria(trial_iterate.status, major_iterations, timer.get_duration(), optimization_status);
                user_callbacks.notify_new_primals(trial_iterate.primals);
@@ -102,7 +102,8 @@ namespace uno {
       statistics.set("iter", 0);
       statistics.set("status", "initial point");
       this->constraint_relaxation_strategy->initialize(statistics, model, current_iterate, this->direction, options);
-      this->globalization_layer.initialize(statistics, current_iterate, options);
+      this->globalization_strategy->initialize(statistics, current_iterate, options);
+      this->globalization_mechanism->initialize(statistics, options);
       options.print_used();
       if (Logger::level == INFO) {
          statistics.print_header();
@@ -172,7 +173,7 @@ namespace uno {
    }
 
    std::string Uno::get_strategy_combination() const {
-      return this->globalization_layer.mechanism->get_name() + " " + this->globalization_layer.strategy->get_name();
+      return this->globalization_mechanism->get_name() + " " + this->globalization_strategy->get_name();
    }
 
    void Uno::print_optimization_summary(const Result& result) const {

uno/Uno.hpp

@@ -4,8 +4,10 @@
 #ifndef UNO_H
 #define UNO_H
 
+#include <memory>
 #include "ingredients/constraint_relaxation_strategies/ConstraintRelaxationStrategy.hpp"
-#include "layers/GlobalizationLayer.hpp"
+#include "ingredients/globalization_mechanisms/GlobalizationMechanism.hpp"
+#include "ingredients/globalization_strategies/GlobalizationStrategy.hpp"
 #include "optimization/Direction.hpp"
 #include "optimization/Result.hpp"
 #include "optimization/IterateStatus.hpp"
@@ -32,7 +34,8 @@ namespace uno {
 
    private:
       std::unique_ptr<ConstraintRelaxationStrategy> constraint_relaxation_strategy;
-      GlobalizationLayer globalization_layer;
+      std::unique_ptr<GlobalizationStrategy> globalization_strategy;
+      std::unique_ptr<GlobalizationMechanism> globalization_mechanism;
       Direction direction{};
       const size_t max_iterations; /*!< Maximum number of iterations */
       const double time_limit; /*!< CPU time limit (can be inf) */

uno/ingredients/constraint_relaxation_strategies/FeasibilityRestoration.cpp

@@ -6,8 +6,11 @@
 #include "ingredients/constraint_relaxation_strategies/l1RelaxedProblem.hpp"
 #include "ingredients/constraint_relaxation_strategies/OptimizationProblem.hpp"
 #include "ingredients/globalization_strategies/GlobalizationStrategy.hpp"
+#include "ingredients/hessian_models/HessianModel.hpp"
+#include "ingredients/hessian_models/HessianModelFactory.hpp"
 #include "ingredients/inequality_handling_methods/InequalityHandlingMethod.hpp"
 #include "ingredients/inequality_handling_methods/InequalityHandlingMethodFactory.hpp"
+#include "ingredients/regularization_strategies/RegularizationStrategyFactory.hpp"
 #include "ingredients/regularization_strategies/UnstableRegularization.hpp"
 #include "linear_algebra/SymmetricIndefiniteLinearSystem.hpp"
 #include "model/Model.hpp"
@@ -23,8 +26,10 @@ namespace uno {
    FeasibilityRestoration::FeasibilityRestoration(size_t number_bound_constraints, const Options& options) :
          ConstraintRelaxationStrategy(options),
          constraint_violation_coefficient(options.get_double("l1_constraint_violation_coefficient")),
-         optimality_subproblem_layer(options),
-         feasibility_subproblem_layer(options),
+         optimality_hessian_model(HessianModelFactory::create(options)),
+         feasibility_hessian_model(HessianModelFactory::create(options)),
+         optimality_regularization_strategy(RegularizationStrategyFactory::create(options)),
+         feasibility_regularization_strategy(RegularizationStrategyFactory::create(options)),
          optimality_inequality_handling_method(InequalityHandlingMethodFactory::create(number_bound_constraints, options)),
          feasibility_inequality_handling_method(InequalityHandlingMethodFactory::create(number_bound_constraints, options)),
          linear_feasibility_tolerance(options.get_double("tolerance")),
@@ -41,17 +46,17 @@ namespace uno {
 
       // memory allocation
       // TODO allocate the feasibility phase only when entering the first time?
-      this->optimality_subproblem_layer.hessian_model->initialize(model);
-      this->feasibility_subproblem_layer.hessian_model->initialize(model);
-      this->optimality_inequality_handling_method->initialize(optimality_problem, *this->optimality_subproblem_layer.hessian_model,
-         *this->optimality_subproblem_layer.regularization_strategy);
-      this->feasibility_inequality_handling_method->initialize(feasibility_problem, *this->feasibility_subproblem_layer.hessian_model,
-         *this->feasibility_subproblem_layer.regularization_strategy);
+      this->optimality_hessian_model->initialize(model);
+      this->feasibility_hessian_model->initialize(model);
+      this->optimality_inequality_handling_method->initialize(optimality_problem, *this->optimality_hessian_model,
+         *this->optimality_regularization_strategy);
+      this->feasibility_inequality_handling_method->initialize(feasibility_problem, *this->feasibility_hessian_model,
+         *this->feasibility_regularization_strategy);
       direction = Direction(feasibility_problem.number_variables, feasibility_problem.number_constraints);
 
       // statistics
-      this->optimality_subproblem_layer.initialize_statistics(statistics, options);
-      this->feasibility_subproblem_layer.initialize_statistics(statistics, options);
+      this->optimality_regularization_strategy->initialize_statistics(statistics, options);
+      this->feasibility_regularization_strategy->initialize_statistics(statistics, options);
       this->optimality_inequality_handling_method->initialize_statistics(statistics, options);
       this->feasibility_inequality_handling_method->initialize_statistics(statistics, options);
       statistics.add_column("phase", Statistics::int_width, options.get_int("statistics_restoration_phase_column_order"));
@@ -78,7 +83,8 @@ namespace uno {
             DEBUG << "Solving the optimality subproblem\n";
             const OptimizationProblem optimality_problem{model};
             this->solve_subproblem(statistics, *this->optimality_inequality_handling_method, optimality_problem, current_iterate,
-               current_iterate.multipliers, direction, this->optimality_subproblem_layer, trust_region_radius, warmstart_information);
+               current_iterate.multipliers, direction, *this->optimality_hessian_model, *this->optimality_regularization_strategy,
+               trust_region_radius, warmstart_information);
             if (direction.status == SubproblemStatus::INFEASIBLE) {
                // switch to the feasibility problem, starting from the current direction
                statistics.set("status", std::string("infeasible subproblem"));
@@ -104,8 +110,8 @@ namespace uno {
       feasibility_problem.set_proximal_center(this->reference_optimality_primals.data());
       feasibility_problem.set_proximal_multiplier(this->feasibility_inequality_handling_method->proximal_coefficient());
       this->solve_subproblem(statistics, *this->feasibility_inequality_handling_method, feasibility_problem, current_iterate,
-         current_iterate.feasibility_multipliers, direction, this->feasibility_subproblem_layer, trust_region_radius,
-         warmstart_information);
+         current_iterate.feasibility_multipliers, direction, *this->feasibility_hessian_model,
+         *this->feasibility_regularization_strategy, trust_region_radius, warmstart_information);
       std::swap(direction.multipliers, direction.feasibility_multipliers);
    }
 
@@ -135,10 +141,11 @@ namespace uno {
 
    void FeasibilityRestoration::solve_subproblem(Statistics& statistics, InequalityHandlingMethod& inequality_handling_method,
          const OptimizationProblem& problem, Iterate& current_iterate, const Multipliers& current_multipliers, Direction& direction,
-         SubproblemLayer& subproblem_layer, double trust_region_radius, WarmstartInformation& warmstart_information) {
+         HessianModel& hessian_model, RegularizationStrategy<double>& regularization_strategy, double trust_region_radius,
+         WarmstartInformation& warmstart_information) {
       direction.set_dimensions(problem.number_variables, problem.number_constraints);
       inequality_handling_method.solve(statistics, problem, current_iterate, current_multipliers, direction,
-         subproblem_layer, trust_region_radius, warmstart_information);
+         hessian_model, regularization_strategy, trust_region_radius, warmstart_information);
       direction.norm = norm_inf(view(direction.primals, 0, problem.get_number_original_variables()));
       DEBUG3 << direction << '\n';
    }
@@ -246,8 +253,7 @@ namespace uno {
    }
 
    size_t FeasibilityRestoration::get_hessian_evaluation_count() const {
-      return this->optimality_subproblem_layer.get_hessian_evaluation_count() +
-         this->feasibility_subproblem_layer.get_hessian_evaluation_count();
+      return this->optimality_hessian_model->evaluation_count + this->feasibility_hessian_model->evaluation_count;
    }
 
    size_t FeasibilityRestoration::get_number_subproblems_solved() const {

uno/ingredients/constraint_relaxation_strategies/FeasibilityRestoration.hpp

@@ -4,9 +4,10 @@
 #ifndef UNO_FEASIBILITYRESTORATION_H
 #define UNO_FEASIBILITYRESTORATION_H
 
+#include <memory>
 #include "ConstraintRelaxationStrategy.hpp"
 #include "ingredients/globalization_strategies/ProgressMeasures.hpp"
-#include "layers/SubproblemLayer.hpp"
+#include "ingredients/regularization_strategies/RegularizationStrategy.hpp"
 #include "linear_algebra/Vector.hpp"
 
 namespace uno {
@@ -46,8 +47,10 @@ namespace uno {
    private:
       Phase current_phase{Phase::OPTIMALITY};
       const double constraint_violation_coefficient;
-      SubproblemLayer optimality_subproblem_layer;
-      SubproblemLayer feasibility_subproblem_layer;
+      std::unique_ptr<HessianModel> optimality_hessian_model;
+      std::unique_ptr<HessianModel> feasibility_hessian_model;
+      std::unique_ptr<RegularizationStrategy<double>> optimality_regularization_strategy;
+      std::unique_ptr<RegularizationStrategy<double>> feasibility_regularization_strategy;
       std::unique_ptr<InequalityHandlingMethod> optimality_inequality_handling_method;
       std::unique_ptr<InequalityHandlingMethod> feasibility_inequality_handling_method;
       const double linear_feasibility_tolerance;
@@ -56,8 +59,8 @@ namespace uno {
       Vector<double> reference_optimality_primals{};
 
       void solve_subproblem(Statistics& statistics, InequalityHandlingMethod& inequality_handling_method, const OptimizationProblem& problem,
-         Iterate& current_iterate, const Multipliers& current_multipliers, Direction& direction, SubproblemLayer& subproblem_layer,
-         double trust_region_radius, WarmstartInformation& warmstart_information);
+         Iterate& current_iterate, const Multipliers& current_multipliers, Direction& direction, HessianModel& hessian_model,
+         RegularizationStrategy<double>& regularization_strategy, double trust_region_radius, WarmstartInformation& warmstart_information);
       void switch_to_optimality_phase(Iterate& current_iterate, GlobalizationStrategy& globalization_strategy, const Model& model,
          Iterate& trial_iterate, WarmstartInformation& warmstart_information);
 

uno/ingredients/constraint_relaxation_strategies/UnconstrainedStrategy.cpp

@@ -4,8 +4,9 @@
 #include "UnconstrainedStrategy.hpp"
 #include "ingredients/constraint_relaxation_strategies/OptimizationProblem.hpp"
 #include "ingredients/globalization_strategies/GlobalizationStrategy.hpp"
+#include "ingredients/hessian_models/HessianModelFactory.hpp"
 #include "ingredients/inequality_handling_methods/InequalityHandlingMethodFactory.hpp"
-#include "layers/SubproblemLayer.hpp"
+#include "ingredients/regularization_strategies/RegularizationStrategyFactory.hpp"
 #include "linear_algebra/SymmetricIndefiniteLinearSystem.hpp"
 #include "optimization/Direction.hpp"
 #include "optimization/Iterate.hpp"
@@ -17,21 +18,21 @@ namespace uno {
    UnconstrainedStrategy::UnconstrainedStrategy(size_t number_bound_constraints, const Options& options) :
          ConstraintRelaxationStrategy(options),
          inequality_handling_method(InequalityHandlingMethodFactory::create(number_bound_constraints, options)),
-         subproblem_layer(options) {
+         hessian_model(HessianModelFactory::create(options)),
+         regularization_strategy(RegularizationStrategyFactory::create(options)) {
    }
 
    void UnconstrainedStrategy::initialize(Statistics& statistics, const Model& model, Iterate& initial_iterate,
          Direction& direction, const Options& options) {
       const OptimizationProblem problem{model};
 
       // memory allocation
-      this->subproblem_layer.hessian_model->initialize(model);
-      this->inequality_handling_method->initialize(problem, *this->subproblem_layer.hessian_model,
-         *this->subproblem_layer.regularization_strategy);
+      this->hessian_model->initialize(model);
+      this->inequality_handling_method->initialize(problem, *this->hessian_model, *this->regularization_strategy);
       direction = Direction(problem.number_variables, problem.number_constraints);
 
       // statistics
-      this->subproblem_layer.initialize_statistics(statistics, options);
+      this->regularization_strategy->initialize_statistics(statistics, options);
       this->inequality_handling_method->initialize_statistics(statistics, options);
 
       // initial iterate
@@ -65,7 +66,7 @@ namespace uno {
          const Multipliers& current_multipliers, Direction& direction, double trust_region_radius, WarmstartInformation& warmstart_information) {
       direction.set_dimensions(problem.number_variables, problem.number_constraints);
       this->inequality_handling_method->solve(statistics, problem, current_iterate, current_multipliers, direction,
-         this->subproblem_layer, trust_region_radius, warmstart_information);
+         *this->hessian_model, *this->regularization_strategy, trust_region_radius, warmstart_information);
       direction.norm = norm_inf(view(direction.primals, 0, problem.get_number_original_variables()));
       DEBUG3 << direction << '\n';
    }
@@ -130,7 +131,7 @@ namespace uno {
    }
 
    size_t UnconstrainedStrategy::get_hessian_evaluation_count() const {
-      return this->subproblem_layer.get_hessian_evaluation_count();
+      return this->hessian_model->evaluation_count;
    }
 
    size_t UnconstrainedStrategy::get_number_subproblems_solved() const {

uno/ingredients/constraint_relaxation_strategies/UnconstrainedStrategy.hpp

@@ -7,8 +7,8 @@
 #include <memory>
 #include "ConstraintRelaxationStrategy.hpp"
 #include "ingredients/globalization_strategies/ProgressMeasures.hpp"
+#include "ingredients/hessian_models/HessianModel.hpp"
 #include "ingredients/inequality_handling_methods/InequalityHandlingMethod.hpp"
-#include "layers/SubproblemLayer.hpp"
 
 namespace uno {
    // forward declarations
@@ -44,7 +44,8 @@ namespace uno {
 
    private:
       std::unique_ptr<InequalityHandlingMethod> inequality_handling_method;
-      SubproblemLayer subproblem_layer;
+      std::unique_ptr<HessianModel> hessian_model;
+      std::unique_ptr<RegularizationStrategy<double>> regularization_strategy;
 
       void solve_subproblem(Statistics& statistics, const OptimizationProblem& problem, Iterate& current_iterate,
          const Multipliers& current_multipliers, Direction& direction, double trust_region_radius,
@@ -56,4 +57,4 @@ namespace uno {
    };
 } // namespace
 
-#endif //UNO_UNCONSTRAINEDSTRATEGY_H
+#endif //UNO_UNCONSTRAINEDSTRATEGY_H