Merge branch 'main' into main

Author: arnavk23

uno/Uno.cpp

@@ -66,7 +66,7 @@ namespace uno {
       model.reset_number_evaluations();
       // pick the ingredients based on the user-defined options
       Uno::pick_ingredients(model, options);
-      Statistics statistics = Uno::create_statistics(model, options);
+      Statistics statistics = Uno::create_statistics(model);
       WarmstartInformation warmstart_information{};
       warmstart_information.whole_problem_changed();
 
@@ -91,7 +91,7 @@ namespace uno {
             while (!termination) {
                ++major_iterations;
                statistics.start_new_line();
-               statistics.set("iter", major_iterations);
+               statistics.set("Major", major_iterations);
                DEBUG << "\n### Outer iteration " << major_iterations << '\n';
 
                // compute an acceptable iterate by solving a subproblem at the current point
@@ -111,7 +111,7 @@ namespace uno {
          }
          catch (std::exception& exception) {
             statistics.start_new_line();
-            statistics.set("status", exception.what());
+            statistics.set("Status", exception.what());
             if (Logger::level == INFO) statistics.print_current_line();
             DEBUG << exception.what() << '\n';
             optimization_status = OptimizationStatus::ALGORITHMIC_ERROR;
@@ -152,33 +152,33 @@ namespace uno {
 
    void Uno::initialize(Statistics& statistics, const Model& model, Iterate& current_iterate, const Options& options) {
       statistics.start_new_line();
-      statistics.set("iter", 0);
-      statistics.set("status", "initial point");
+      statistics.set("Major", 0);
+      statistics.set("Status", "initial point");
 
       model.project_onto_variable_bounds(current_iterate.primals);
-      this->globalization_mechanism->initialize(statistics, model, current_iterate, this->direction, options);
+      this->globalization_mechanism->initialize(statistics, model, current_iterate, this->direction);
       GlobalizationMechanism::set_primal_statistics(statistics, model, current_iterate);
       GlobalizationMechanism::set_dual_residuals_statistics(statistics, current_iterate);
 
-      options.print_used_overwritten();
+      options.print_non_default();
       if (Logger::level == INFO) {
          statistics.print_header();
          statistics.print_current_line();
       }
       current_iterate.status = SolutionStatus::NOT_OPTIMAL;
    }
 
-   Statistics Uno::create_statistics(const Model& model, const Options& options) {
+   Statistics Uno::create_statistics(const Model& model) {
       Statistics statistics{};
-      statistics.add_column("iter", Statistics::int_width, options.get_int("statistics_major_column_order"));
-      statistics.add_column("step norm", Statistics::double_width, options.get_int("statistics_step_norm_column_order"));
-      statistics.add_column("objective", Statistics::double_width, options.get_int("statistics_objective_column_order"));
+      statistics.add_column("Major", Statistics::int_width, 3, Statistics::column_order.at("Major"));
+      statistics.add_column("||Step||", Statistics::double_width, 2, Statistics::column_order.at("||Step||"));
+      statistics.add_column("Objective", Statistics::double_width + 1, 3, Statistics::column_order.at("Objective"));
       if (model.is_constrained()) {
-         statistics.add_column("primal feas", Statistics::double_width + 1, options.get_int("statistics_primal_feasibility_column_order"));
+         statistics.add_column("Infeas", Statistics::double_width, 2, Statistics::column_order.at("Infeas"));
       }
-      statistics.add_column("stationarity", Statistics::double_width + 2, options.get_int("statistics_stationarity_column_order"));
-      statistics.add_column("complementarity", Statistics::double_width + 5, options.get_int("statistics_complementarity_column_order"));
-      statistics.add_column("status", Statistics::string_width, options.get_int("statistics_status_column_order"));
+      statistics.add_column("Statio", Statistics::double_width, 2, Statistics::column_order.at("Statio"));
+      statistics.add_column("Compl", Statistics::double_width, 2, Statistics::column_order.at("Compl"));
+      statistics.add_column("Status", Statistics::string_width, 3, Statistics::column_order.at("Status"));
       return statistics;
    }
 

uno/Uno.hpp

@@ -36,7 +36,7 @@ namespace uno {
 
       void pick_ingredients(const Model& model, const Options& options);
       void initialize(Statistics& statistics, const Model& model, Iterate& current_iterate, const Options& options);
-      [[nodiscard]] static Statistics create_statistics(const Model& model, const Options& options);
+      [[nodiscard]] static Statistics create_statistics(const Model& model);
       [[nodiscard]] static bool termination_criteria(SolutionStatus solution_status, size_t iteration, size_t max_iterations,
          double current_time, double time_limit, bool user_termination, OptimizationStatus& optimization_status);
       [[nodiscard]] Result uno_solve(const Model& model, const Options& options, UserCallbacks& user_callbacks);

uno/ingredients/constraint_relaxation_strategies/ConstraintRelaxationStrategy.hpp

@@ -26,7 +26,7 @@ namespace uno {
       virtual ~ConstraintRelaxationStrategy();
 
       virtual void initialize(Statistics& statistics, const Model& model, Iterate& initial_iterate, Direction& direction,
-         double trust_region_radius, const Options& options) = 0;
+         double trust_region_radius) = 0;
 
       // direction computation
       virtual void compute_feasible_direction(Statistics& statistics, Iterate& current_iterate, Direction& direction,

uno/ingredients/constraint_relaxation_strategies/FeasibilityRestoration.cpp

@@ -43,7 +43,7 @@ namespace uno {
    }
 
    void FeasibilityRestoration::initialize(Statistics& statistics, const Model& model, Iterate& initial_iterate,
-         Direction& direction, double trust_region_radius, const Options& options) {
+         Direction& direction, double trust_region_radius) {
       this->reference_optimality_primals.resize(this->optimality_problem.number_variables);
 
       // memory allocation
@@ -55,12 +55,12 @@ namespace uno {
       );
 
       // statistics
-      this->optimality_inertia_correction_strategy->initialize_statistics(statistics, options);
-      this->optimality_inequality_handling_method->initialize_statistics(statistics, options);
-      this->feasibility_inertia_correction_strategy->initialize_statistics(statistics, options);
-      this->feasibility_inequality_handling_method->initialize_statistics(statistics, options);
-      statistics.add_column("phase", Statistics::int_width - 1, options.get_int("statistics_restoration_phase_column_order"));
-      statistics.set("phase", "OPT");
+      this->optimality_inertia_correction_strategy->initialize_statistics(statistics);
+      this->optimality_inequality_handling_method->initialize_statistics(statistics);
+      this->feasibility_inertia_correction_strategy->initialize_statistics(statistics);
+      this->feasibility_inequality_handling_method->initialize_statistics(statistics);
+      statistics.add_column("Phase", Statistics::int_width - 1, 3, Statistics::column_order.at("Phase"));
+      statistics.set("Phase", "OPT");
 
       // initial iterate
       this->optimality_inequality_handling_method->generate_initial_iterate(initial_iterate);
@@ -71,23 +71,23 @@ namespace uno {
       this->optimality_problem.evaluate_lagrangian_gradient(initial_iterate.residuals.lagrangian_gradient,
          evaluation_space, initial_iterate);
       ConstraintRelaxationStrategy::compute_primal_dual_residuals(this->optimality_problem, initial_iterate);
-      this->optimality_globalization_strategy->initialize(statistics, initial_iterate, options);
-      this->feasibility_globalization_strategy.initialize(statistics, initial_iterate, options);
+      this->optimality_globalization_strategy->initialize(statistics, initial_iterate);
+      this->feasibility_globalization_strategy.initialize(statistics, initial_iterate);
    }
 
    void FeasibilityRestoration::compute_feasible_direction(Statistics& statistics, Iterate& current_iterate, Direction& direction,
          double trust_region_radius, WarmstartInformation& warmstart_information) {
       direction.reset();
       // if we are in the optimality phase, solve the optimality problem
       if (this->current_phase == Phase::OPTIMALITY) {
-         statistics.set("phase", "OPT");
+         statistics.set("Phase", "OPT");
          try {
             DEBUG << "Solving the optimality subproblem\n";
             this->solve_subproblem(statistics, *this->optimality_inequality_handling_method, this->optimality_problem,
                current_iterate, direction, 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"));
+               statistics.set("Status", std::string("infeasible"));
                DEBUG << "/!\\ The subproblem is infeasible\n";
                this->switch_to_feasibility_problem(statistics, current_iterate, trust_region_radius, warmstart_information);
                this->feasibility_inequality_handling_method->set_initial_point(direction.primals);
@@ -104,7 +104,7 @@ namespace uno {
 
       // solve the feasibility problem (minimize the constraint violation)
       DEBUG << "Solving the feasibility subproblem\n";
-      statistics.set("phase", "FEAS");
+      statistics.set("Phase", "FEAS");
       // note: failure of regularization should not happen here, since the feasibility Jacobian has full rank
       this->feasibility_problem.set_proximal_coefficient(this->optimality_inequality_handling_method->proximal_coefficient());
       this->solve_subproblem(statistics, *this->feasibility_inequality_handling_method, this->feasibility_problem,

uno/ingredients/constraint_relaxation_strategies/FeasibilityRestoration.hpp

@@ -25,7 +25,7 @@ namespace uno {
       ~FeasibilityRestoration() override = default;
 
       void initialize(Statistics& statistics, const Model& model, Iterate& initial_iterate, Direction& direction,
-         double trust_region_radius, const Options& options) override;
+         double trust_region_radius) override;
 
       // direction computation
       void compute_feasible_direction(Statistics& statistics, Iterate& current_iterate, Direction& direction,

uno/ingredients/constraint_relaxation_strategies/NoRelaxation.cpp

@@ -23,15 +23,15 @@ namespace uno {
    }
 
    void NoRelaxation::initialize(Statistics& statistics, const Model& model, Iterate& initial_iterate,
-         Direction& direction, double trust_region_radius, const Options& options) {
+         Direction& direction, double trust_region_radius) {
       // memory allocation
       this->inequality_handling_method->initialize(this->problem, initial_iterate, *this->hessian_model,
          *this->inertia_correction_strategy, trust_region_radius);
       direction = Direction(this->problem.number_variables, this->problem.number_constraints);
 
       // statistics
-      this->inertia_correction_strategy->initialize_statistics(statistics, options);
-      this->inequality_handling_method->initialize_statistics(statistics, options);
+      this->inertia_correction_strategy->initialize_statistics(statistics);
+      this->inequality_handling_method->initialize_statistics(statistics);
 
       // initial iterate
       this->inequality_handling_method->generate_initial_iterate(initial_iterate);
@@ -41,7 +41,7 @@ namespace uno {
       const auto& evaluation_space = this->inequality_handling_method->get_evaluation_space();
       this->problem.evaluate_lagrangian_gradient(initial_iterate.residuals.lagrangian_gradient, evaluation_space, initial_iterate);
       this->compute_primal_dual_residuals(this->problem, initial_iterate);
-      this->globalization_strategy.initialize(statistics, initial_iterate, options);
+      this->globalization_strategy.initialize(statistics, initial_iterate);
    }
 
    void NoRelaxation::compute_feasible_direction(Statistics& statistics, Iterate& current_iterate, Direction& direction,

uno/ingredients/constraint_relaxation_strategies/NoRelaxation.hpp

@@ -18,7 +18,7 @@ namespace uno {
       ~NoRelaxation() override = default;
 
       void initialize(Statistics& statistics, const Model& model, Iterate& initial_iterate, Direction& direction,
-         double trust_region_radius, const Options& options) override;
+         double trust_region_radius) override;
 
       // direction computation
       void compute_feasible_direction(Statistics& statistics, Iterate& current_iterate, Direction& direction,

uno/ingredients/globalization_mechanisms/BacktrackingLineSearch.cpp

@@ -25,10 +25,10 @@ namespace uno {
    }
 
    void BacktrackingLineSearch::initialize(Statistics& statistics, const Model& model, Iterate& current_iterate,
-         Direction& direction, const Options& options) {
-      this->constraint_relaxation_strategy->initialize(statistics, model, current_iterate, direction, INF<double>, options);
-      statistics.add_column("LS iter", Statistics::int_width + 2, options.get_int("statistics_minor_column_order"));
-      statistics.add_column("step length", Statistics::double_width + 1, options.get_int("statistics_LS_step_length_column_order"));
+         Direction& direction) {
+      this->constraint_relaxation_strategy->initialize(statistics, model, current_iterate, direction, INF<double>);
+      statistics.add_column("Minor", Statistics::int_width, 3, Statistics::column_order.at("Minor"));
+      statistics.add_column("Steplength", Statistics::double_width + 1, 2, Statistics::column_order.at("Steplength"));
    }
 
    void BacktrackingLineSearch::compute_next_iterate(Statistics& statistics, const Model& model, Iterate& current_iterate,
@@ -58,22 +58,22 @@ namespace uno {
          ++number_iterations;
          DEBUG << "\n\tLine-search iteration " << number_iterations << ", step_length " << step_length << '\n';
          if (1 < number_iterations) { statistics.start_new_line(); }
-         statistics.set("step length", step_length);
+         statistics.set("Steplength", step_length);
 
          bool is_acceptable = false;
          try {
             // take a step as a fraction of the direction
             GlobalizationMechanism::assemble_trial_iterate(model, current_iterate, trial_iterate, direction, step_length,
                // scale or not the constraint dual direction with the LS step length
                this->scale_duals_with_step_length ? step_length : 1.);
-            statistics.set("step norm", step_length * direction.norm);
+            statistics.set("||Step||", step_length * direction.norm);
 
             is_acceptable = this->constraint_relaxation_strategy->is_iterate_acceptable(statistics, model, current_iterate,
                trial_iterate, direction, step_length, warmstart_information, user_callbacks);
             GlobalizationMechanism::set_primal_statistics(statistics, model, trial_iterate);
          }
          catch (const EvaluationError&) {
-            statistics.set("status", "eval. error");
+            statistics.set("Status", "eval. error");
          }
          BacktrackingLineSearch::set_LS_statistics(statistics, number_iterations);
 
@@ -97,7 +97,7 @@ namespace uno {
                   throw std::runtime_error("LS failed");
                }
                // switch to solving the feasibility problem
-               statistics.set("status", "small step length");
+               statistics.set("Status", "small step length");
                this->constraint_relaxation_strategy->switch_to_feasibility_problem(statistics, current_iterate, INF<double>,
                   warmstart_information);
                this->constraint_relaxation_strategy->compute_feasible_direction(statistics, current_iterate, direction,
@@ -116,7 +116,7 @@ namespace uno {
       bool termination = false;
       trial_iterate.status = this->constraint_relaxation_strategy->check_termination(model, trial_iterate);
       if (trial_iterate.status != SolutionStatus::NOT_OPTIMAL) {
-         statistics.set("status", "accepted (small step length)");
+         statistics.set("Status", "accepted (small step length)");
          GlobalizationMechanism::set_dual_residuals_statistics(statistics, trial_iterate);
          termination = true;
       }
@@ -138,6 +138,6 @@ namespace uno {
    }
 
    void BacktrackingLineSearch::set_LS_statistics(Statistics& statistics, size_t number_iterations) {
-      statistics.set("LS iter", number_iterations);
+      statistics.set("Minor", number_iterations);
    }
 } // namespace

uno/ingredients/globalization_mechanisms/BacktrackingLineSearch.hpp

@@ -12,8 +12,7 @@ namespace uno {
       BacktrackingLineSearch(const Model& model, const Options& options);
       ~BacktrackingLineSearch() override = default;
 
-      void initialize(Statistics& statistics, const Model& model, Iterate& current_iterate, Direction& direction,
-         const Options& options) override;
+      void initialize(Statistics& statistics, const Model& model, Iterate& current_iterate, Direction& direction) override;
       void compute_next_iterate(Statistics& statistics, const Model& model, Iterate& current_iterate, Iterate& trial_iterate,
          Direction& direction, WarmstartInformation& warmstart_information, UserCallbacks& user_callbacks) override;
 

uno/ingredients/globalization_mechanisms/GlobalizationMechanism.cpp

@@ -40,16 +40,16 @@ namespace uno {
 
    void GlobalizationMechanism::set_primal_statistics(Statistics& statistics, const Model& model, const Iterate& iterate) {
       if (iterate.is_objective_computed) {
-         statistics.set("objective", iterate.evaluations.objective);
+         statistics.set("Objective", iterate.evaluations.objective);
       }
       if (model.is_constrained()) {
-         statistics.set("primal feas", iterate.progress.infeasibility);
+         statistics.set("Infeas", iterate.progress.infeasibility);
       }
    }
 
    void GlobalizationMechanism::set_dual_residuals_statistics(Statistics& statistics, const Iterate& iterate) {
-      statistics.set("stationarity", iterate.residuals.stationarity);
-      statistics.set("complementarity", iterate.residuals.complementarity);
+      statistics.set("Statio", iterate.residuals.stationarity);
+      statistics.set("Compl", iterate.residuals.complementarity);
    }
 
    size_t GlobalizationMechanism::get_number_subproblems_solved() const {