From 68fe95634bcf89720f4be940b0c40337a7366f86 Mon Sep 17 00:00:00 2001 From: Charlie Vanaret Date: Thu, 12 Jun 2025 19:39:28 +0200 Subject: [PATCH 1/2] Removed GlobalizationLayer and SubproblemLayer --- uno/Uno.cpp | 13 +++--- uno/Uno.hpp | 7 +++- .../FeasibilityRestoration.cpp | 40 ++++++++++-------- .../FeasibilityRestoration.hpp | 13 +++--- .../UnconstrainedStrategy.cpp | 17 ++++---- .../UnconstrainedStrategy.hpp | 7 ++-- .../l1Relaxation.cpp | 42 +++++++++++-------- .../l1Relaxation.hpp | 13 +++--- .../InequalityHandlingMethod.hpp | 4 +- .../InequalityConstrainedMethod.cpp | 7 ++-- .../InequalityConstrainedMethod.hpp | 5 ++- .../PrimalDualInteriorPointMethod.cpp | 18 ++++---- .../PrimalDualInteriorPointMethod.hpp | 7 ++-- .../subproblem_solvers/BQPD/BQPDSolver.cpp | 8 ++-- .../subproblem_solvers/BQPD/BQPDSolver.hpp | 3 +- .../subproblem_solvers/HiGHS/HiGHSSolver.cpp | 9 ++-- .../subproblem_solvers/HiGHS/HiGHSSolver.hpp | 3 +- .../subproblem_solvers/LPSolver.hpp | 4 +- .../subproblem_solvers/QPSolver.hpp | 5 ++- uno/layers/GlobalizationLayer.hpp | 36 ---------------- uno/layers/SubproblemLayer.hpp | 39 ----------------- 21 files changed, 128 insertions(+), 172 deletions(-) delete mode 100644 uno/layers/GlobalizationLayer.hpp delete mode 100644 uno/layers/SubproblemLayer.hpp diff --git a/uno/Uno.cpp b/uno/Uno.cpp index 439108a4e..cc2345037 100644 --- a/uno/Uno.cpp +++ b/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 { diff --git a/uno/Uno.hpp b/uno/Uno.hpp index 05df17ef6..f4336dfad 100644 --- a/uno/Uno.hpp +++ b/uno/Uno.hpp @@ -4,8 +4,10 @@ #ifndef UNO_H #define UNO_H +#include #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 constraint_relaxation_strategy; - GlobalizationLayer globalization_layer; + std::unique_ptr globalization_strategy; + std::unique_ptr globalization_mechanism; Direction direction{}; const size_t max_iterations; /*!< Maximum number of iterations */ const double time_limit; /*!< CPU time limit (can be inf) */ diff --git a/uno/ingredients/constraint_relaxation_strategies/FeasibilityRestoration.cpp b/uno/ingredients/constraint_relaxation_strategies/FeasibilityRestoration.cpp index de585b25d..879f62167 100644 --- a/uno/ingredients/constraint_relaxation_strategies/FeasibilityRestoration.cpp +++ b/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& 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 { diff --git a/uno/ingredients/constraint_relaxation_strategies/FeasibilityRestoration.hpp b/uno/ingredients/constraint_relaxation_strategies/FeasibilityRestoration.hpp index 602552a91..da73e60f7 100644 --- a/uno/ingredients/constraint_relaxation_strategies/FeasibilityRestoration.hpp +++ b/uno/ingredients/constraint_relaxation_strategies/FeasibilityRestoration.hpp @@ -4,9 +4,10 @@ #ifndef UNO_FEASIBILITYRESTORATION_H #define UNO_FEASIBILITYRESTORATION_H +#include #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 optimality_hessian_model; + std::unique_ptr feasibility_hessian_model; + std::unique_ptr> optimality_regularization_strategy; + std::unique_ptr> feasibility_regularization_strategy; std::unique_ptr optimality_inequality_handling_method; std::unique_ptr feasibility_inequality_handling_method; const double linear_feasibility_tolerance; @@ -56,8 +59,8 @@ namespace uno { Vector 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& 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); diff --git a/uno/ingredients/constraint_relaxation_strategies/UnconstrainedStrategy.cpp b/uno/ingredients/constraint_relaxation_strategies/UnconstrainedStrategy.cpp index 68f72a804..0cfe3fece 100644 --- a/uno/ingredients/constraint_relaxation_strategies/UnconstrainedStrategy.cpp +++ b/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,7 +18,8 @@ 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, @@ -25,13 +27,12 @@ namespace uno { 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 { diff --git a/uno/ingredients/constraint_relaxation_strategies/UnconstrainedStrategy.hpp b/uno/ingredients/constraint_relaxation_strategies/UnconstrainedStrategy.hpp index df6d389c2..64b01fc0f 100644 --- a/uno/ingredients/constraint_relaxation_strategies/UnconstrainedStrategy.hpp +++ b/uno/ingredients/constraint_relaxation_strategies/UnconstrainedStrategy.hpp @@ -7,8 +7,8 @@ #include #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 inequality_handling_method; - SubproblemLayer subproblem_layer; + std::unique_ptr hessian_model; + std::unique_ptr> 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 \ No newline at end of file diff --git a/uno/ingredients/constraint_relaxation_strategies/l1Relaxation.cpp b/uno/ingredients/constraint_relaxation_strategies/l1Relaxation.cpp index dfc6785b8..6226b7b53 100644 --- a/uno/ingredients/constraint_relaxation_strategies/l1Relaxation.cpp +++ b/uno/ingredients/constraint_relaxation_strategies/l1Relaxation.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 "model/Model.hpp" #include "optimization/Direction.hpp" #include "optimization/Iterate.hpp" @@ -28,8 +31,10 @@ namespace uno { ConstraintRelaxationStrategy(options), penalty_parameter(options.get_double("l1_relaxation_initial_parameter")), constraint_violation_coefficient(options.get_double("l1_constraint_violation_coefficient")), - l1_relaxed_subproblem_layer(options), - feasibility_subproblem_layer(options), + l1_relaxed_hessian_model(HessianModelFactory::create(options)), + feasibility_hessian_model(HessianModelFactory::create(options)), + l1_relaxed_regularization_strategy(RegularizationStrategyFactory::create(options)), + feasibility_regularization_strategy(RegularizationStrategyFactory::create(options)), inequality_handling_method(InequalityHandlingMethodFactory::create(number_bound_constraints, options)), feasibility_inequality_handling_method(InequalityHandlingMethodFactory::create(number_bound_constraints, options)), tolerance(options.get_double("tolerance")), @@ -49,20 +54,20 @@ namespace uno { const l1RelaxedProblem feasibility_problem{model, 0., this->constraint_violation_coefficient}; // memory allocation - this->l1_relaxed_subproblem_layer.hessian_model->initialize(model); - this->feasibility_subproblem_layer.hessian_model->initialize(model); - this->inequality_handling_method->initialize(l1_relaxed_problem, *this->l1_relaxed_subproblem_layer.hessian_model, - *this->l1_relaxed_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->l1_relaxed_hessian_model->initialize(model); + this->feasibility_hessian_model->initialize(model); + this->inequality_handling_method->initialize(l1_relaxed_problem, *this->l1_relaxed_hessian_model, + *this->l1_relaxed_regularization_strategy); + this->feasibility_inequality_handling_method->initialize(feasibility_problem, *this->feasibility_hessian_model, + *this->feasibility_regularization_strategy); this->trial_multipliers.constraints.resize(l1_relaxed_problem.number_constraints); this->trial_multipliers.lower_bounds.resize(l1_relaxed_problem.number_variables); this->trial_multipliers.upper_bounds.resize(l1_relaxed_problem.number_variables); direction = Direction(l1_relaxed_problem.number_variables, l1_relaxed_problem.number_constraints); // statistics - this->l1_relaxed_subproblem_layer.initialize_statistics(statistics, options); - this->feasibility_subproblem_layer.initialize_statistics(statistics, options); + this->l1_relaxed_regularization_strategy->initialize_statistics(statistics, options); + this->feasibility_regularization_strategy->initialize_statistics(statistics, options); this->inequality_handling_method->initialize_statistics(statistics, options); this->feasibility_inequality_handling_method->initialize_statistics(statistics, options); statistics.add_column("penalty", Statistics::double_width - 5, options.get_int("statistics_penalty_parameter_column_order")); @@ -118,8 +123,8 @@ namespace uno { this->feasibility_inequality_handling_method->initialize_feasibility_problem(feasibility_problem, current_iterate); Direction feasibility_direction(direction.number_variables, direction.number_constraints); this->solve_subproblem(statistics, *this->feasibility_inequality_handling_method, feasibility_problem, current_iterate, - current_iterate.feasibility_multipliers, feasibility_direction, this->feasibility_subproblem_layer, - trust_region_radius, warmstart_information); + current_iterate.feasibility_multipliers, feasibility_direction, *this->feasibility_hessian_model, + *this->feasibility_regularization_strategy, trust_region_radius, warmstart_information); std::swap(feasibility_direction.multipliers, feasibility_direction.feasibility_multipliers); const double residual_lowest_violation = model.constraint_violation(current_iterate.evaluations.constraints + current_iterate.evaluations.constraint_jacobian * feasibility_direction.primals, Norm::L1); @@ -150,13 +155,14 @@ namespace uno { void l1Relaxation::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& regularization_strategy, double trust_region_radius, + WarmstartInformation& warmstart_information) { DEBUG << "Solving the subproblem with penalty parameter " << problem.get_objective_multiplier() << "\n\n"; // solve the subproblem 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); + inequality_handling_method.solve(statistics, problem, current_iterate, current_multipliers, direction, 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'; assert(direction.status == SubproblemStatus::OPTIMAL && "The subproblem was not solved to optimality"); @@ -166,7 +172,8 @@ namespace uno { double current_penalty_parameter, double trust_region_radius, WarmstartInformation& warmstart_information) { const l1RelaxedProblem l1_relaxed_problem{model, current_penalty_parameter, this->constraint_violation_coefficient}; this->solve_subproblem(statistics, *this->inequality_handling_method, l1_relaxed_problem, current_iterate, - current_iterate.multipliers, direction, this->l1_relaxed_subproblem_layer, trust_region_radius, warmstart_information); + current_iterate.multipliers, direction, *this->l1_relaxed_hessian_model, *this->l1_relaxed_regularization_strategy, + trust_region_radius, warmstart_information); if (direction.status == SubproblemStatus::UNBOUNDED_PROBLEM) { throw std::runtime_error("l1Relaxation::solve_l1_relaxed_problem: the subproblem is unbounded, this should not happen. " "If the subproblem has curvature, use regularization. If not, use a trust-region method.\n"); @@ -330,8 +337,7 @@ namespace uno { } size_t l1Relaxation::get_hessian_evaluation_count() const { - return this->l1_relaxed_subproblem_layer.get_hessian_evaluation_count() + - this->feasibility_subproblem_layer.get_hessian_evaluation_count(); + return this->l1_relaxed_hessian_model->evaluation_count + this->feasibility_hessian_model->evaluation_count; } size_t l1Relaxation::get_number_subproblems_solved() const { diff --git a/uno/ingredients/constraint_relaxation_strategies/l1Relaxation.hpp b/uno/ingredients/constraint_relaxation_strategies/l1Relaxation.hpp index 8df85a597..b51a779ab 100644 --- a/uno/ingredients/constraint_relaxation_strategies/l1Relaxation.hpp +++ b/uno/ingredients/constraint_relaxation_strategies/l1Relaxation.hpp @@ -4,9 +4,10 @@ #ifndef UNO_L1RELAXATION_H #define UNO_L1RELAXATION_H +#include #include "ConstraintRelaxationStrategy.hpp" #include "ingredients/globalization_strategies/ProgressMeasures.hpp" -#include "layers/SubproblemLayer.hpp" +#include "ingredients/regularization_strategies/RegularizationStrategy.hpp" #include "optimization/Multipliers.hpp" namespace uno { @@ -49,8 +50,10 @@ namespace uno { protected: double penalty_parameter; const double constraint_violation_coefficient; - SubproblemLayer l1_relaxed_subproblem_layer; - SubproblemLayer feasibility_subproblem_layer; + std::unique_ptr l1_relaxed_hessian_model; + std::unique_ptr feasibility_hessian_model; + std::unique_ptr> l1_relaxed_regularization_strategy; + std::unique_ptr> feasibility_regularization_strategy; std::unique_ptr inequality_handling_method; std::unique_ptr feasibility_inequality_handling_method; const double tolerance; @@ -64,8 +67,8 @@ namespace uno { void solve_l1_relaxed_problem(Statistics& statistics, const Model& model, Iterate& current_iterate, Direction& direction, double current_penalty_parameter, double trust_region_radius, WarmstartInformation& warmstart_information); 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& regularization_strategy, double trust_region_radius, WarmstartInformation& warmstart_information); // functions that decrease the penalty parameter to enforce particular conditions void decrease_parameter_aggressively(const Model& model, Iterate& current_iterate, const Direction& direction); diff --git a/uno/ingredients/inequality_handling_methods/InequalityHandlingMethod.hpp b/uno/ingredients/inequality_handling_methods/InequalityHandlingMethod.hpp index 17218fa20..094713cf9 100644 --- a/uno/ingredients/inequality_handling_methods/InequalityHandlingMethod.hpp +++ b/uno/ingredients/inequality_handling_methods/InequalityHandlingMethod.hpp @@ -19,7 +19,6 @@ namespace uno { template class RegularizationStrategy; class Statistics; - class SubproblemLayer; template class SymmetricMatrix; template @@ -37,7 +36,8 @@ namespace uno { virtual void initialize_statistics(Statistics& statistics, const Options& options) = 0; virtual void generate_initial_iterate(const OptimizationProblem& problem, Iterate& initial_iterate) = 0; virtual void solve(Statistics& statistics, const OptimizationProblem& problem, Iterate& current_iterate, const Multipliers& current_multipliers, - Direction& direction, SubproblemLayer& subproblem_layer, double trust_region_radius, WarmstartInformation& warmstart_information) = 0; + Direction& direction, HessianModel& hessian_model, RegularizationStrategy& regularization_strategy, + double trust_region_radius, WarmstartInformation& warmstart_information) = 0; virtual void initialize_feasibility_problem(const l1RelaxedProblem& problem, Iterate& current_iterate) = 0; virtual void exit_feasibility_problem(const OptimizationProblem& problem, Iterate& trial_iterate) = 0; diff --git a/uno/ingredients/inequality_handling_methods/inequality_constrained_methods/InequalityConstrainedMethod.cpp b/uno/ingredients/inequality_handling_methods/inequality_constrained_methods/InequalityConstrainedMethod.cpp index a0a61cf20..38f6b8958 100644 --- a/uno/ingredients/inequality_handling_methods/inequality_constrained_methods/InequalityConstrainedMethod.cpp +++ b/uno/ingredients/inequality_handling_methods/inequality_constrained_methods/InequalityConstrainedMethod.cpp @@ -48,10 +48,11 @@ namespace uno { */ } - void InequalityConstrainedMethod::solve(Statistics& statistics, const OptimizationProblem& problem, Iterate& current_iterate, const Multipliers& current_multipliers, - Direction& direction, SubproblemLayer& subproblem_layer, double trust_region_radius, WarmstartInformation& warmstart_information) { + void InequalityConstrainedMethod::solve(Statistics& statistics, const OptimizationProblem& problem, Iterate& current_iterate, + const Multipliers& current_multipliers, Direction& direction, HessianModel& hessian_model, RegularizationStrategy& regularization_strategy, + double trust_region_radius, WarmstartInformation& warmstart_information) { this->solver->solve(statistics, problem, current_iterate, current_multipliers, this->initial_point, direction, - subproblem_layer, trust_region_radius, warmstart_information); + hessian_model, regularization_strategy, trust_region_radius, warmstart_information); InequalityConstrainedMethod::compute_dual_displacements(current_multipliers, direction.multipliers); this->number_subproblems_solved++; // reset the initial point diff --git a/uno/ingredients/inequality_handling_methods/inequality_constrained_methods/InequalityConstrainedMethod.hpp b/uno/ingredients/inequality_handling_methods/inequality_constrained_methods/InequalityConstrainedMethod.hpp index 244611887..e806aae5a 100644 --- a/uno/ingredients/inequality_handling_methods/inequality_constrained_methods/InequalityConstrainedMethod.hpp +++ b/uno/ingredients/inequality_handling_methods/inequality_constrained_methods/InequalityConstrainedMethod.hpp @@ -20,8 +20,9 @@ namespace uno { void initialize_statistics(Statistics& statistics, const Options& options) override; void generate_initial_iterate(const OptimizationProblem& problem, Iterate& initial_iterate) override; void solve(Statistics& statistics, const OptimizationProblem& problem, Iterate& current_iterate, - const Multipliers& current_multipliers, Direction& direction, SubproblemLayer& subproblem_layer, - double trust_region_radius, WarmstartInformation& warmstart_information) override; + const Multipliers& current_multipliers, Direction& direction, HessianModel& hessian_model, + RegularizationStrategy& regularization_strategy, double trust_region_radius, + WarmstartInformation& warmstart_information) override; void initialize_feasibility_problem(const l1RelaxedProblem& problem, Iterate& current_iterate) override; void exit_feasibility_problem(const OptimizationProblem& problem, Iterate& trial_iterate) override; diff --git a/uno/ingredients/inequality_handling_methods/interior_point_methods/PrimalDualInteriorPointMethod.cpp b/uno/ingredients/inequality_handling_methods/interior_point_methods/PrimalDualInteriorPointMethod.cpp index 42a83a94a..4d5fef8c8 100644 --- a/uno/ingredients/inequality_handling_methods/interior_point_methods/PrimalDualInteriorPointMethod.cpp +++ b/uno/ingredients/inequality_handling_methods/interior_point_methods/PrimalDualInteriorPointMethod.cpp @@ -6,9 +6,9 @@ #include "PrimalDualInteriorPointProblem.hpp" #include "ingredients/constraint_relaxation_strategies/l1RelaxedProblem.hpp" #include "ingredients/regularization_strategies/Inertia.hpp" +#include "ingredients/regularization_strategies/RegularizationStrategy.hpp" #include "ingredients/subproblem_solvers/DirectSymmetricIndefiniteLinearSolver.hpp" #include "ingredients/subproblem_solvers/SymmetricIndefiniteLinearSolverFactory.hpp" -#include "layers/SubproblemLayer.hpp" #include "optimization/Direction.hpp" #include "optimization/Iterate.hpp" #include "optimization/WarmstartInformation.hpp" @@ -133,7 +133,7 @@ namespace uno { } void PrimalDualInteriorPointMethod::evaluate_functions(Statistics& statistics, const PrimalDualInteriorPointProblem& barrier_problem, - Iterate& current_iterate, const Multipliers& current_multipliers, SubproblemLayer& subproblem_layer, const WarmstartInformation& warmstart_information) { + Iterate& current_iterate, const Multipliers& current_multipliers, HessianModel& hessian_model, const WarmstartInformation& warmstart_information) { // barrier objective gradient if (warmstart_information.objective_changed) { barrier_problem.evaluate_objective_gradient(current_iterate, this->objective_gradient); @@ -147,13 +147,13 @@ namespace uno { // barrier Lagrangian Hessian if (warmstart_information.objective_changed || warmstart_information.constraints_changed) { - barrier_problem.evaluate_lagrangian_hessian(statistics, *subproblem_layer.hessian_model, current_iterate.primals, current_multipliers, this->hessian); + barrier_problem.evaluate_lagrangian_hessian(statistics, hessian_model, current_iterate.primals, current_multipliers, this->hessian); } } void PrimalDualInteriorPointMethod::solve(Statistics& statistics, const OptimizationProblem& problem, Iterate& current_iterate, - const Multipliers& current_multipliers, Direction& direction, SubproblemLayer& subproblem_layer, double trust_region_radius, - WarmstartInformation& warmstart_information) { + const Multipliers& current_multipliers, Direction& direction, HessianModel& hessian_model, + RegularizationStrategy& regularization_strategy, double trust_region_radius, WarmstartInformation& warmstart_information) { if (problem.has_inequality_constraints()) { throw std::runtime_error("The problem has inequality constraints. Create an instance of HomogeneousEqualityConstrainedModel"); } @@ -175,10 +175,10 @@ namespace uno { const PrimalDualInteriorPointProblem barrier_problem(problem, this->barrier_parameter()); // evaluate the functions at the current iterate - this->evaluate_functions(statistics, barrier_problem, current_iterate, current_multipliers, subproblem_layer, warmstart_information); + this->evaluate_functions(statistics, barrier_problem, current_iterate, current_multipliers, hessian_model, warmstart_information); // compute the primal-dual solution - this->assemble_augmented_system(statistics, problem, current_multipliers, subproblem_layer); + this->assemble_augmented_system(statistics, problem, current_multipliers, regularization_strategy); this->augmented_system.solve(*this->linear_solver); assert(direction.status == SubproblemStatus::OPTIMAL && "The primal-dual perturbed subproblem was not solved to optimality"); this->number_subproblems_solved++; @@ -192,14 +192,14 @@ namespace uno { } void PrimalDualInteriorPointMethod::assemble_augmented_system(Statistics& statistics, const OptimizationProblem& problem, - const Multipliers& current_multipliers, SubproblemLayer& subproblem_layer) { + const Multipliers& current_multipliers, RegularizationStrategy& regularization_strategy) { // assemble and factorize the augmented matrix this->augmented_system.assemble_matrix(this->hessian, this->constraint_jacobian, problem.number_variables, problem.number_constraints); // regularize the augmented matrix const double dual_regularization_parameter = std::pow(this->barrier_parameter(), this->parameters.regularization_exponent); const Inertia expected_inertia{problem.number_variables, problem.number_constraints, 0}; - subproblem_layer.regularization_strategy->regularize_augmented_matrix(statistics, this->augmented_system.matrix, + regularization_strategy.regularize_augmented_matrix(statistics, this->augmented_system.matrix, dual_regularization_parameter, expected_inertia, *this->linear_solver); // assemble the RHS diff --git a/uno/ingredients/inequality_handling_methods/interior_point_methods/PrimalDualInteriorPointMethod.hpp b/uno/ingredients/inequality_handling_methods/interior_point_methods/PrimalDualInteriorPointMethod.hpp index 3d8ce8498..e1fabea1a 100644 --- a/uno/ingredients/inequality_handling_methods/interior_point_methods/PrimalDualInteriorPointMethod.hpp +++ b/uno/ingredients/inequality_handling_methods/interior_point_methods/PrimalDualInteriorPointMethod.hpp @@ -40,7 +40,8 @@ namespace uno { [[nodiscard]] double proximal_coefficient() const override; void solve(Statistics& statistics, const OptimizationProblem& problem, Iterate& current_iterate, const Multipliers& current_multipliers, - Direction& direction, SubproblemLayer& subproblem_layer, double trust_region_radius, WarmstartInformation& warmstart_information) override; + Direction& direction, HessianModel& hessian_model, RegularizationStrategy& regularization_strategy, + double trust_region_radius, WarmstartInformation& warmstart_information) override; [[nodiscard]] double hessian_quadratic_product(const Vector& vector) const override; void set_auxiliary_measure(const Model& model, Iterate& iterate) override; @@ -74,7 +75,7 @@ namespace uno { [[nodiscard]] double barrier_parameter() const; [[nodiscard]] double push_variable_to_interior(double variable_value, double lower_bound, double upper_bound) const; void evaluate_functions(Statistics& statistics, const PrimalDualInteriorPointProblem& barrier_problem, Iterate& current_iterate, - const Multipliers& current_multipliers, SubproblemLayer& subproblem_layer, const WarmstartInformation& warmstart_information); + const Multipliers& current_multipliers, HessianModel& hessian_model, const WarmstartInformation& warmstart_information); void update_barrier_parameter(const OptimizationProblem& problem, const Iterate& current_iterate, const Multipliers& current_multipliers, const DualResiduals& residuals); [[nodiscard]] bool is_small_step(const OptimizationProblem& problem, const Vector& current_primals, const Vector& direction_primals) const; @@ -86,7 +87,7 @@ namespace uno { [[nodiscard]] static double dual_fraction_to_boundary(const OptimizationProblem& problem, const Multipliers& current_multipliers, Multipliers& direction_multipliers, double tau); void assemble_augmented_system(Statistics& statistics, const OptimizationProblem& problem, const Multipliers& current_multipliers, - SubproblemLayer& subproblem_layer); + RegularizationStrategy& regularization_strategy); void assemble_augmented_rhs(const Multipliers& current_multipliers, size_t number_variables, size_t number_constraints); void assemble_primal_dual_direction(const OptimizationProblem& problem, const Vector& current_primals, const Multipliers& current_multipliers, Vector& direction_primals, Multipliers& direction_multipliers); diff --git a/uno/ingredients/subproblem_solvers/BQPD/BQPDSolver.cpp b/uno/ingredients/subproblem_solvers/BQPD/BQPDSolver.cpp index dc74d78ba..0c1e026e8 100644 --- a/uno/ingredients/subproblem_solvers/BQPD/BQPDSolver.cpp +++ b/uno/ingredients/subproblem_solvers/BQPD/BQPDSolver.cpp @@ -7,7 +7,6 @@ #include "ingredients/hessian_models/HessianModel.hpp" #include "ingredients/regularization_strategies/RegularizationStrategy.hpp" #include "ingredients/subproblem_solvers/MA57/MA57Solver.hpp" -#include "layers/SubproblemLayer.hpp" #include "linear_algebra/SymmetricMatrix.hpp" #include "linear_algebra/Vector.hpp" #include "optimization/Direction.hpp" @@ -90,14 +89,15 @@ namespace uno { void BQPDSolver::solve(Statistics& statistics, const OptimizationProblem& problem, Iterate& current_iterate, const Multipliers& current_multipliers, const Vector& initial_point, Direction& direction, - SubproblemLayer& subproblem_layer, double trust_region_radius, const WarmstartInformation& warmstart_information) { + HessianModel& hessian_model, RegularizationStrategy& regularization_strategy, double trust_region_radius, + const WarmstartInformation& warmstart_information) { this->set_up_subproblem(problem, current_iterate, trust_region_radius, warmstart_information); if (warmstart_information.objective_changed || warmstart_information.constraints_changed) { // evaluate the Lagrangian Hessian of the problem at the current primal-dual point - problem.evaluate_lagrangian_hessian(statistics, *subproblem_layer.hessian_model, current_iterate.primals, current_multipliers, this->hessian); + problem.evaluate_lagrangian_hessian(statistics, hessian_model, current_iterate.primals, current_multipliers, this->hessian); // regularize the Hessian const Inertia expected_inertia{problem.get_number_original_variables(), 0, problem.number_variables - problem.get_number_original_variables()}; - subproblem_layer.regularization_strategy->regularize_hessian(statistics, this->hessian, expected_inertia); + regularization_strategy.regularize_hessian(statistics, this->hessian, expected_inertia); this->save_hessian_in_local_format(); } if (this->print_subproblem) { diff --git a/uno/ingredients/subproblem_solvers/BQPD/BQPDSolver.hpp b/uno/ingredients/subproblem_solvers/BQPD/BQPDSolver.hpp index 94aa6628d..406d7f2e7 100644 --- a/uno/ingredients/subproblem_solvers/BQPD/BQPDSolver.hpp +++ b/uno/ingredients/subproblem_solvers/BQPD/BQPDSolver.hpp @@ -53,7 +53,8 @@ namespace uno { void solve(Statistics& statistics, const OptimizationProblem& problem, Iterate& current_iterate, const Multipliers& current_multipliers, const Vector& initial_point, Direction& direction, - SubproblemLayer& subproblem_layer, double trust_region_radius, const WarmstartInformation& warmstart_information) override; + HessianModel& hessian_model, RegularizationStrategy& regularization_strategy, double trust_region_radius, + const WarmstartInformation& warmstart_information) override; [[nodiscard]] double hessian_quadratic_product(const Vector& vector) const override; diff --git a/uno/ingredients/subproblem_solvers/HiGHS/HiGHSSolver.cpp b/uno/ingredients/subproblem_solvers/HiGHS/HiGHSSolver.cpp index 7a647b36f..75e7ae67f 100644 --- a/uno/ingredients/subproblem_solvers/HiGHS/HiGHSSolver.cpp +++ b/uno/ingredients/subproblem_solvers/HiGHS/HiGHSSolver.cpp @@ -1,7 +1,7 @@ #include #include "HiGHSSolver.hpp" #include "ingredients/constraint_relaxation_strategies/OptimizationProblem.hpp" -#include "layers/SubproblemLayer.hpp" +#include "ingredients/regularization_strategies/RegularizationStrategy.hpp" #include "linear_algebra/SparseVector.hpp" #include "linear_algebra/Vector.hpp" #include "optimization/Direction.hpp" @@ -42,10 +42,11 @@ namespace uno { void HiGHSSolver::solve(Statistics& /*statistics*/, const OptimizationProblem& problem, Iterate& current_iterate, const Multipliers& /*current_multipliers*/, const Vector& /*initial_point*/, Direction& direction, - SubproblemLayer& subproblem_layer, double trust_region_radius, const WarmstartInformation& warmstart_information) { + HessianModel& hessian_model, RegularizationStrategy& regularization_strategy, double trust_region_radius, + const WarmstartInformation& warmstart_information) { // check if HiGHS can solve the subproblem - const size_t number_regularized_hessian_nonzeros = problem.number_hessian_nonzeros(*subproblem_layer.hessian_model) + - (subproblem_layer.regularization_strategy->performs_primal_regularization() ? problem.number_variables : 0); + const size_t number_regularized_hessian_nonzeros = problem.number_hessian_nonzeros(hessian_model) + + (regularization_strategy.performs_primal_regularization() ? problem.number_variables : 0); if (0 < number_regularized_hessian_nonzeros) { throw std::runtime_error("The subproblem has curvature. For the moment, HiGHS can only solve LPs"); } diff --git a/uno/ingredients/subproblem_solvers/HiGHS/HiGHSSolver.hpp b/uno/ingredients/subproblem_solvers/HiGHS/HiGHSSolver.hpp index 9b2bf4d9b..01f19fab9 100644 --- a/uno/ingredients/subproblem_solvers/HiGHS/HiGHSSolver.hpp +++ b/uno/ingredients/subproblem_solvers/HiGHS/HiGHSSolver.hpp @@ -19,7 +19,8 @@ namespace uno { void solve(Statistics& statistics, const OptimizationProblem& problem, Iterate& current_iterate, const Multipliers& current_multipliers, const Vector& initial_point, Direction& direction, - SubproblemLayer& subproblem_layer, double trust_region_radius, const WarmstartInformation& warmstart_information) override; + HessianModel& hessian_model, RegularizationStrategy& regularization_strategy, double trust_region_radius, + const WarmstartInformation& warmstart_information) override; [[nodiscard]] double hessian_quadratic_product(const Vector& vector) const override; diff --git a/uno/ingredients/subproblem_solvers/LPSolver.hpp b/uno/ingredients/subproblem_solvers/LPSolver.hpp index 9442b00fe..6d420ec90 100644 --- a/uno/ingredients/subproblem_solvers/LPSolver.hpp +++ b/uno/ingredients/subproblem_solvers/LPSolver.hpp @@ -14,7 +14,6 @@ namespace uno { template class RegularizationStrategy; class Statistics; - class SubproblemLayer; template class Vector; struct WarmstartInformation; @@ -33,7 +32,8 @@ namespace uno { virtual void solve(Statistics& statistics, const OptimizationProblem& problem, Iterate& current_iterate, const Multipliers& current_multipliers, const Vector& initial_point, Direction& direction, - SubproblemLayer& subproblem_layer, double trust_region_radius, const WarmstartInformation& warmstart_information) = 0; + HessianModel& hessian_model, RegularizationStrategy& regularization_strategy, double trust_region_radius, + const WarmstartInformation& warmstart_information) = 0; [[nodiscard]] virtual double hessian_quadratic_product(const Vector& vector) const = 0; }; diff --git a/uno/ingredients/subproblem_solvers/QPSolver.hpp b/uno/ingredients/subproblem_solvers/QPSolver.hpp index 6d25f7c60..a4e232581 100644 --- a/uno/ingredients/subproblem_solvers/QPSolver.hpp +++ b/uno/ingredients/subproblem_solvers/QPSolver.hpp @@ -16,8 +16,9 @@ namespace uno { RegularizationStrategy& regularization_strategy) override = 0; void solve(Statistics& statistics, const OptimizationProblem& problem, Iterate& current_iterate, const Multipliers& current_multipliers, - const Vector& initial_point, Direction& direction, SubproblemLayer& subproblem_layer, - double trust_region_radius, const WarmstartInformation& warmstart_information) override = 0; + const Vector& initial_point, Direction& direction, HessianModel& hessian_model, + RegularizationStrategy& regularization_strategy, double trust_region_radius, + const WarmstartInformation& warmstart_information) override = 0; }; } // namespace diff --git a/uno/layers/GlobalizationLayer.hpp b/uno/layers/GlobalizationLayer.hpp deleted file mode 100644 index 6b89e8cff..000000000 --- a/uno/layers/GlobalizationLayer.hpp +++ /dev/null @@ -1,36 +0,0 @@ -// Copyright (c) 2025 Charlie Vanaret -// Licensed under the MIT license. See LICENSE file in the project directory for details. - -#ifndef UNO_GLOBALIZATIONLAYER_H -#define UNO_GLOBALIZATIONLAYER_H - -#include -#include "ingredients/globalization_mechanisms/GlobalizationMechanism.hpp" -#include "ingredients/globalization_mechanisms/GlobalizationMechanismFactory.hpp" -#include "ingredients/globalization_strategies/GlobalizationStrategy.hpp" -#include "ingredients/globalization_strategies/GlobalizationStrategyFactory.hpp" - -namespace uno { - // forward declarations - class Iterate; - class Options; - class Statistics; - - class GlobalizationLayer { - public: - std::unique_ptr strategy; - std::unique_ptr mechanism; - - GlobalizationLayer(size_t number_constraints, const Options& options): - strategy(GlobalizationStrategyFactory::create(number_constraints, options)), - mechanism(GlobalizationMechanismFactory::create(options)) { - } - - void initialize(Statistics& statistics, const Iterate& initial_iterate, const Options& options) const { - this->strategy->initialize(statistics, initial_iterate, options); - this->mechanism->initialize(statistics, options); - } - }; -} // namespace - -#endif //UNO_GLOBALIZATIONLAYER_H \ No newline at end of file diff --git a/uno/layers/SubproblemLayer.hpp b/uno/layers/SubproblemLayer.hpp deleted file mode 100644 index b66a658bf..000000000 --- a/uno/layers/SubproblemLayer.hpp +++ /dev/null @@ -1,39 +0,0 @@ -// Copyright (c) 2025 Charlie Vanaret -// Licensed under the MIT license. See LICENSE file in the project directory for details. - -#ifndef UNO_SUBPROBLEMLAYER_H -#define UNO_SUBPROBLEMLAYER_H - -#include - -#include "ingredients/hessian_models/HessianModel.hpp" -#include "ingredients/hessian_models/HessianModelFactory.hpp" -#include "ingredients/regularization_strategies/RegularizationStrategy.hpp" -#include "ingredients/regularization_strategies/RegularizationStrategyFactory.hpp" - -namespace uno { - // forward declarations - class Options; - class Statistics; - - class SubproblemLayer { - public: - std::unique_ptr hessian_model; - std::unique_ptr> regularization_strategy; - - explicit SubproblemLayer(const Options& options): - hessian_model(HessianModelFactory::create(options)), - regularization_strategy(RegularizationStrategyFactory::create(options)) { - } - - void initialize_statistics(Statistics& statistics, const Options& options) const { - this->regularization_strategy->initialize_statistics(statistics, options); - } - - [[nodiscard]] size_t get_hessian_evaluation_count() const { - return this->hessian_model->evaluation_count; - } - }; -} // namespace - -#endif //UNO_SUBPROBLEMLAYER_H \ No newline at end of file From b5fcf82879ef40e7904cbcf5bfbf8a35301a9e15 Mon Sep 17 00:00:00 2001 From: Charlie Vanaret Date: Thu, 12 Jun 2025 19:44:28 +0200 Subject: [PATCH 2/2] Removed unused includes --- uno/ingredients/subproblem_solvers/QPSolverFactory.cpp | 1 - uno/linear_algebra/COOSparseStorage.hpp | 1 - uno/linear_algebra/SymmetricIndefiniteLinearSystem.hpp | 2 +- 3 files changed, 1 insertion(+), 3 deletions(-) diff --git a/uno/ingredients/subproblem_solvers/QPSolverFactory.cpp b/uno/ingredients/subproblem_solvers/QPSolverFactory.cpp index e21189b08..79111480f 100644 --- a/uno/ingredients/subproblem_solvers/QPSolverFactory.cpp +++ b/uno/ingredients/subproblem_solvers/QPSolverFactory.cpp @@ -2,7 +2,6 @@ // Licensed under the MIT license. See LICENSE file in the project directory for details. #include -#include #include "QPSolverFactory.hpp" #include "QPSolver.hpp" #include "linear_algebra/Vector.hpp" diff --git a/uno/linear_algebra/COOSparseStorage.hpp b/uno/linear_algebra/COOSparseStorage.hpp index 427d5d865..f6490eb50 100644 --- a/uno/linear_algebra/COOSparseStorage.hpp +++ b/uno/linear_algebra/COOSparseStorage.hpp @@ -5,7 +5,6 @@ #define UNO_COOSPARSESTORAGE_H #include -#include #include #include "SparseStorage.hpp" #include "symbolic/Range.hpp" diff --git a/uno/linear_algebra/SymmetricIndefiniteLinearSystem.hpp b/uno/linear_algebra/SymmetricIndefiniteLinearSystem.hpp index 7213e6a84..8aa216e1b 100644 --- a/uno/linear_algebra/SymmetricIndefiniteLinearSystem.hpp +++ b/uno/linear_algebra/SymmetricIndefiniteLinearSystem.hpp @@ -57,4 +57,4 @@ namespace uno { } } // namespace -#endif // UNO_SYMMETRICINDEFINITELINEARSYSTEM_H +#endif // UNO_SYMMETRICINDEFINITELINEARSYSTEM_H \ No newline at end of file