Minor refactoring

Author: cvanaret

uno/ingredients/constraint_relaxation_strategies/ConstraintRelaxationStrategy.cpp

@@ -45,7 +45,7 @@ namespace uno {
 
    bool ConstraintRelaxationStrategy::is_iterate_acceptable(Statistics& statistics, GlobalizationStrategy& globalization_strategy,
          const Subproblem& subproblem, const SolverWorkspace& solver_workspace, Iterate& current_iterate, Iterate& trial_iterate,
-         const Direction& direction, double step_length, EvaluationCache& evaluation_cache) const {
+         const Direction& direction, double step_length, Evaluations& current_evaluations, Evaluations& trial_evaluations) const {
       subproblem.problem.postprocess_iterate(trial_iterate);
       const double objective_multiplier = subproblem.problem.get_objective_multiplier();
 
@@ -57,25 +57,25 @@ namespace uno {
          subproblem.problem.set_auxiliary_measure(current_iterate);
          //this->subproblem_definition_changed = false;
       //}
-      this->evaluate_progress_measures(subproblem.problem, trial_iterate, evaluation_cache.trial_evaluations);
+      this->evaluate_progress_measures(subproblem.problem, trial_iterate, trial_evaluations);
 
       bool accept_iterate = false;
       if (direction.norm == 0.) {
          DEBUG << "Zero step acceptable\n";
-         evaluation_cache.trial_evaluations.objective = subproblem.problem.model.evaluate_objective(trial_iterate.primals);
+         trial_evaluations.objective = subproblem.problem.model.evaluate_objective(trial_iterate.primals);
          accept_iterate = true;
          statistics.set("Status", "0 primal step");
       }
       else {
          // determine acceptance wrt the globalization strategy
          const ProgressMeasures predicted_reductions = subproblem.compute_predicted_reductions(direction, step_length,
-            this->progress_norm, evaluation_cache.current_evaluations, solver_workspace);
+            this->progress_norm, current_evaluations, solver_workspace);
          accept_iterate = globalization_strategy.is_iterate_acceptable(statistics, current_iterate.progress, trial_iterate.progress,
             predicted_reductions, objective_multiplier);
          // check that the derivatives exist at the accepted trial iterate (an exception is thrown upon evaluation failure)
          if (accept_iterate) {
-            evaluation_cache.trial_evaluations.evaluate_objective_gradient(subproblem.problem.model, trial_iterate.primals);
-            evaluation_cache.trial_evaluations.evaluate_jacobian(subproblem.problem.model, trial_iterate.primals);
+            trial_evaluations.evaluate_objective_gradient(subproblem.problem.model, trial_iterate.primals);
+            trial_evaluations.evaluate_jacobian(subproblem.problem.model, trial_iterate.primals);
          }
       }
       return accept_iterate;

uno/ingredients/constraint_relaxation_strategies/ConstraintRelaxationStrategy.hpp

@@ -43,11 +43,14 @@ namespace uno {
 
       // second-order corrections
       [[nodiscard]] virtual bool has_second_order_corrections() const = 0;
+      virtual void compute_second_order_correction(Iterate& current_iterate, Direction& direction,
+         const Vector<double>& constraints) = 0;
 
       // trial iterate acceptance
       [[nodiscard]] virtual bool is_iterate_acceptable(Statistics& statistics, const Model& model, Iterate& current_iterate,
          Iterate& trial_iterate, const Direction& direction, double step_length, bool uses_trust_region,
-         EvaluationCache& evaluation_cache, WarmstartInformation& warmstart_information, UserCallbacks& user_callbacks) = 0;
+         Evaluations& current_evaluations, Evaluations& trial_evaluations, WarmstartInformation& warmstart_information,
+         UserCallbacks& user_callbacks) = 0;
 
       [[nodiscard]] virtual std::string get_name() const = 0;
       [[nodiscard]] size_t get_number_subproblems_solved() const;
@@ -68,7 +71,7 @@ namespace uno {
       void evaluate_progress_measures(const OptimizationProblem& problem, Iterate& iterate, Evaluations& evaluations) const;
       bool is_iterate_acceptable(Statistics& statistics, GlobalizationStrategy& globalization_strategy, const Subproblem& subproblem,
          const SolverWorkspace& solver_workspace, Iterate& current_iterate, Iterate& trial_iterate, const Direction& direction,
-         double step_length, EvaluationCache& evaluation_cache) const;
+         double step_length, Evaluations& current_evaluations, Evaluations& trial_evaluations) const;
       void compute_residuals(const OptimizationProblem& problem, Iterate& iterate, Evaluations& evaluations) const;
       [[nodiscard]] double compute_stationarity_scaling(const Model& model, const Multipliers& multipliers) const;
       [[nodiscard]] double compute_complementarity_scaling(const Model& model, const Multipliers& multipliers) const;

uno/ingredients/constraint_relaxation_strategies/FeasibilityRestoration.cpp

@@ -173,6 +173,20 @@ namespace uno {
       }
    }
 
+   void FeasibilityRestoration::compute_second_order_correction(Iterate& current_iterate, Direction& direction,
+         const Vector<double>& constraints) {
+      if (this->current_phase == Phase::OPTIMALITY) {
+         const Subproblem subproblem(*this->reformulated_problem, current_iterate, *this->hessian_model, *this->inertia_correction_strategy);
+         return this->subproblem_solver->compute_second_order_correction(subproblem, direction, constraints);
+      }
+      else {
+         const Subproblem feasibility_subproblem(*this->reformulated_feasibility_problem, current_iterate, *this->feasibility_hessian_model,
+            *this->feasibility_inertia_correction_strategy);
+         return this->feasibility_subproblem_solver->compute_second_order_correction(feasibility_subproblem, direction,
+            constraints);
+      }
+   }
+
    void FeasibilityRestoration::solve_subproblem(Statistics& statistics, const Subproblem& subproblem,
          SubproblemSolver& subproblem_solver, const OptimizationProblem& problem, GlobalizationStrategy& globalization_strategy,
          Iterate& current_iterate, Direction& direction, double trust_region_radius, Evaluations& current_evaluations,
@@ -226,34 +240,36 @@ namespace uno {
 
    bool FeasibilityRestoration::is_iterate_acceptable(Statistics& statistics, const Model& model,
          Iterate& current_iterate, Iterate& trial_iterate, const Direction& direction, double step_length,
-         bool uses_trust_region, EvaluationCache& evaluation_cache, WarmstartInformation& warmstart_information,
-         UserCallbacks& user_callbacks) {
+         bool uses_trust_region, Evaluations& current_evaluations, Evaluations& trial_evaluations,
+         WarmstartInformation& warmstart_information, UserCallbacks& user_callbacks) {
       bool accept_iterate = false;
       // determine acceptability, depending on the current phase
       if (this->current_phase == Phase::OPTIMALITY) {
          const Subproblem subproblem(*this->reformulated_problem, current_iterate, *this->hessian_model,
             *this->inertia_correction_strategy);
          accept_iterate = ConstraintRelaxationStrategy::is_iterate_acceptable(statistics, *this->globalization_strategy,
             subproblem, this->subproblem_solver->get_workspace(), current_iterate, trial_iterate, direction, step_length,
-            evaluation_cache);
+            current_evaluations, trial_evaluations);
          if (uses_trust_region || accept_iterate) {
-            this->hessian_model->notify_trial_iterate(statistics, current_iterate, trial_iterate, evaluation_cache);
+            this->hessian_model->notify_trial_iterate(statistics, current_iterate, trial_iterate, current_evaluations,
+               trial_evaluations);
          }
       }
       else {
          const Subproblem feasibility_subproblem(*this->reformulated_feasibility_problem, current_iterate, *this->feasibility_hessian_model,
             *this->feasibility_inertia_correction_strategy);
          accept_iterate = ConstraintRelaxationStrategy::is_iterate_acceptable(statistics, this->feasibility_globalization_strategy,
             feasibility_subproblem, this->feasibility_subproblem_solver->get_workspace(), current_iterate, trial_iterate,
-            direction, step_length, evaluation_cache);
+            direction, step_length, current_evaluations, trial_evaluations);
          if (uses_trust_region || accept_iterate) {
-            this->feasibility_hessian_model->notify_trial_iterate(statistics, current_iterate, trial_iterate, evaluation_cache);
+            this->feasibility_hessian_model->notify_trial_iterate(statistics, current_iterate, trial_iterate, current_evaluations,
+               trial_evaluations);
          }
       }
 
       // possibly go from restoration phase to optimality phase
       if (this->current_phase == Phase::FEASIBILITY_RESTORATION && this->can_switch_to_optimality_phase(model, trial_iterate,
-            direction, step_length, evaluation_cache.current_evaluations)) {
+            direction, step_length, current_evaluations)) {
          this->switch_back_to_optimality_phase(current_iterate, trial_iterate);
          // set a cold start in the subproblem solver
          warmstart_information.whole_problem_changed();
@@ -264,19 +280,17 @@ namespace uno {
 
       // check termination
       if (this->current_phase == Phase::OPTIMALITY) {
-         this->compute_residuals(this->original_problem, trial_iterate, evaluation_cache.trial_evaluations);
-         trial_iterate.status = this->check_termination(this->original_problem, trial_iterate,
-            evaluation_cache.trial_evaluations);
+         this->compute_residuals(this->original_problem, trial_iterate, trial_evaluations);
+         trial_iterate.status = this->check_termination(this->original_problem, trial_iterate, trial_evaluations);
          if (accept_iterate) {
             user_callbacks.notify_acceptable_iterate(trial_iterate.primals, trial_iterate.multipliers,
                this->original_problem.get_objective_multiplier(), trial_iterate.progress.infeasibility,
                trial_iterate.residuals.stationarity, trial_iterate.residuals.complementarity);
          }
       }
       else {
-         this->compute_residuals(this->feasibility_problem, trial_iterate, evaluation_cache.trial_evaluations);
-         trial_iterate.status = this->check_termination(this->feasibility_problem, trial_iterate,
-            evaluation_cache.trial_evaluations);
+         this->compute_residuals(this->feasibility_problem, trial_iterate, trial_evaluations);
+         trial_iterate.status = this->check_termination(this->feasibility_problem, trial_iterate, trial_evaluations);
          if (accept_iterate) {
             user_callbacks.notify_acceptable_iterate(trial_iterate.primals, trial_iterate.multipliers,
                this->feasibility_problem.get_objective_multiplier(), trial_iterate.progress.infeasibility,

uno/ingredients/constraint_relaxation_strategies/FeasibilityRestoration.hpp

@@ -38,11 +38,14 @@ namespace uno {
 
       // second-order corrections
       [[nodiscard]] bool has_second_order_corrections() const override;
+      void compute_second_order_correction(Iterate& current_iterate, Direction& direction,
+         const Vector<double>& constraints) override;
 
       // trial iterate acceptance
       [[nodiscard]] bool is_iterate_acceptable(Statistics& statistics, const Model& model, Iterate& current_iterate,
          Iterate& trial_iterate, const Direction& direction, double step_length, bool uses_trust_region,
-         EvaluationCache& evaluation_cache, WarmstartInformation& warmstart_information, UserCallbacks& user_callbacks) override;
+         Evaluations& current_evaluations, Evaluations& trial_evaluations, WarmstartInformation& warmstart_information,
+         UserCallbacks& user_callbacks) override;
 
       [[nodiscard]] std::string get_name() const override;
 

uno/ingredients/constraint_relaxation_strategies/NoRelaxation.cpp

@@ -95,23 +95,31 @@ namespace uno {
       return this->subproblem_solver->has_second_order_corrections();
    }
 
+   void NoRelaxation::compute_second_order_correction(Iterate& current_iterate, Direction& direction,
+         const Vector<double>& constraints) {
+      const Subproblem subproblem(*this->reformulated_problem, current_iterate, *this->hessian_model, *this->inertia_correction_strategy);
+      this->subproblem_solver->compute_second_order_correction(subproblem, direction, constraints);
+   }
+
    bool NoRelaxation::is_iterate_acceptable(Statistics& statistics, const Model& /*model*/, Iterate& current_iterate,
          Iterate& trial_iterate, const Direction& direction, double step_length, bool uses_trust_region,
-         EvaluationCache& evaluation_cache, WarmstartInformation& warmstart_information, UserCallbacks& user_callbacks) {
+         Evaluations& current_evaluations, Evaluations& trial_evaluations, WarmstartInformation& warmstart_information,
+         UserCallbacks& user_callbacks) {
       const Subproblem subproblem(*this->reformulated_problem, current_iterate, *this->hessian_model,
          *this->inertia_correction_strategy);
       const bool accept_iterate = ConstraintRelaxationStrategy::is_iterate_acceptable(statistics, this->globalization_strategy,
          subproblem, this->subproblem_solver->get_workspace(), current_iterate, trial_iterate, direction, step_length,
-         evaluation_cache);
-      this->compute_residuals(this->original_problem, trial_iterate, evaluation_cache.trial_evaluations);
-      trial_iterate.status = this->check_termination(this->original_problem, trial_iterate, evaluation_cache.trial_evaluations);
+         current_evaluations, trial_evaluations);
+      this->compute_residuals(this->original_problem, trial_iterate, trial_evaluations);
+      trial_iterate.status = this->check_termination(this->original_problem, trial_iterate, trial_evaluations);
       if (accept_iterate) {
          user_callbacks.notify_acceptable_iterate(trial_iterate.primals, trial_iterate.multipliers,
             this->original_problem.get_objective_multiplier(), trial_iterate.progress.infeasibility,
             trial_iterate.residuals.stationarity, trial_iterate.residuals.complementarity);
       }
       if (uses_trust_region || accept_iterate) {
-         this->hessian_model->notify_trial_iterate(statistics, current_iterate, trial_iterate, evaluation_cache);
+         this->hessian_model->notify_trial_iterate(statistics, current_iterate, trial_iterate, current_evaluations,
+            trial_evaluations);
       }
       warmstart_information.no_changes();
       return accept_iterate;

uno/ingredients/constraint_relaxation_strategies/NoRelaxation.hpp

@@ -34,11 +34,14 @@ namespace uno {
 
       // second-order corrections
       [[nodiscard]] bool has_second_order_corrections() const override;
+      void compute_second_order_correction(Iterate& current_iterate, Direction& direction,
+         const Vector<double>& constraints) override;
 
       // trial iterate acceptance
       [[nodiscard]] bool is_iterate_acceptable(Statistics& statistics, const Model& model, Iterate& current_iterate,
          Iterate& trial_iterate, const Direction& direction, double step_length, bool uses_trust_region,
-         EvaluationCache& evaluation_cache, WarmstartInformation& warmstart_information, UserCallbacks& user_callbacks) override;
+         Evaluations& current_evaluations, Evaluations& trial_evaluations, WarmstartInformation& warmstart_information,
+         UserCallbacks& user_callbacks) override;
 
       [[nodiscard]] std::string get_name() const override;
 

uno/ingredients/globalization_mechanisms/BacktrackingLineSearch.cpp

@@ -11,6 +11,7 @@
 #include "optimization/Iterate.hpp"
 #include "ingredients/subproblem_solvers/SubproblemStatus.hpp"
 #include "optimization/EvaluationCache.hpp"
+#include "symbolic/Sum.hpp"
 #include "tools/Logger.hpp"
 #include "options/Options.hpp"
 #include "tools/Statistics.hpp"
@@ -87,11 +88,10 @@ namespace uno {
    // go a fraction along the direction by finding an acceptable step length
    // returns true upon success, false upon failure
    bool BacktrackingLineSearch::backtrack_along_direction(Statistics& statistics, const Model& model, Iterate& current_iterate,
-         Iterate& trial_iterate, const Direction& direction, EvaluationCache& evaluation_cache, WarmstartInformation& warmstart_information,
+         Iterate& trial_iterate, Direction& direction, EvaluationCache& evaluation_cache, WarmstartInformation& warmstart_information,
          UserCallbacks& user_callbacks) const {
       double step_length = 1.;
       bool termination = false;
-      bool in_soc = false;
       size_t number_iterations = 0;
       while (!termination) {
          ++number_iterations;
@@ -112,7 +112,8 @@ namespace uno {
             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, false, evaluation_cache, warmstart_information, user_callbacks);
+               trial_iterate, direction, step_length, false, evaluation_cache.current_evaluations, evaluation_cache.trial_evaluations,
+               warmstart_information, user_callbacks);
             BacktrackingLineSearch::set_primal_statistics(statistics, model, trial_iterate, evaluation_cache.trial_evaluations);
          }
          catch (const EvaluationError&) {
@@ -126,10 +127,23 @@ namespace uno {
             if (Logger::level == INFO) statistics.print_current_line();
          }
          // from here on, the trial iterate was rejected
-         else if (number_iterations == 1) {
+         else if (number_iterations == 1 && this->constraint_relaxation_strategy->has_second_order_corrections() &&
+               trial_iterate.progress.infeasibility > current_iterate.progress.infeasibility) {
             // enter second-order corrections
-            in_soc = true;
-            WARNING << "Entering second-order corrections\n";
+            INFO << "Entering second-order corrections\n";
+            double theta_soc_old = current_iterate.progress.infeasibility;
+            Vector<double> c_k_soc(evaluation_cache.trial_evaluations.constraints);
+            c_k_soc += direction.primal_dual_step_length * evaluation_cache.current_evaluations.constraints;
+            /*
+            this->constraint_relaxation_strategy->compute_second_order_correction(current_iterate, direction, c_k_soc);
+            //Iterate iterate_k_soc();
+            Vector<double> x_k_soc = current_iterate.primals + direction.primal_dual_step_length * direction.primals;
+
+            Evaluations soc_evaluations(evaluation_cache.current_evaluations);
+            is_acceptable = this->constraint_relaxation_strategy->is_iterate_acceptable(statistics, model, current_iterate,
+               trial_iterate, direction, step_length, false, evaluation_cache.current_evaluations, evaluation_cache.trial_evaluations,
+               warmstart_information, user_callbacks);
+            */
          }
          else if (step_length >= this->minimum_step_length) {
             step_length = this->decrease_step_length(step_length);

uno/ingredients/globalization_mechanisms/BacktrackingLineSearch.hpp

@@ -25,7 +25,7 @@ namespace uno {
       const bool scale_duals_with_step_length;
 
       [[nodiscard]] bool backtrack_along_direction(Statistics& statistics, const Model& model, Iterate& current_iterate,
-         Iterate& trial_iterate, const Direction& direction, EvaluationCache& evaluation_cache, WarmstartInformation& warmstart_information,
+         Iterate& trial_iterate, Direction& direction, EvaluationCache& evaluation_cache, WarmstartInformation& warmstart_information,
          UserCallbacks& user_callbacks) const;
       [[nodiscard]] double decrease_step_length(double step_length) const;
       static void check_unboundedness(const Direction& direction);

uno/ingredients/globalization_mechanisms/TrustRegionStrategy.cpp

@@ -145,7 +145,8 @@ namespace uno {
          Iterate& trial_iterate, const Direction& direction, EvaluationCache& evaluation_cache,
          WarmstartInformation& warmstart_information, UserCallbacks& user_callbacks) {
       bool accept_iterate = this->constraint_relaxation_strategy->is_iterate_acceptable(statistics, model, current_iterate,
-         trial_iterate, direction, 1., true, evaluation_cache, warmstart_information, user_callbacks);
+         trial_iterate, direction, 1., true, evaluation_cache.current_evaluations, evaluation_cache.trial_evaluations,
+         warmstart_information, user_callbacks);
       GlobalizationMechanism::set_primal_statistics(statistics, model, trial_iterate, evaluation_cache.trial_evaluations);
       if (accept_iterate) {
          // possibly increase the radius if trust region is active