Small refactoring

CMakeLists.txt

@@ -58,6 +58,7 @@ file(GLOB UNO_SOURCE_FILES
    uno/optimization/*.cpp
    uno/options/*.cpp
    uno/preprocessing/*.cpp
+   uno/reformulation/*.cpp
    uno/tools/*.cpp
 )
 

bindings/AMPL/AMPLModel.cpp

@@ -134,7 +134,7 @@ namespace uno {
    }
    */
 
-   void AMPLModel::evaluate_constraints(const Vector<double>& x, std::vector<double>& constraints) const {
+   void AMPLModel::evaluate_constraints(const Vector<double>& x, Vector<double>& constraints) const {
       fint error_flag = 0;
       (*(this->asl)->p.Conval)(this->asl, const_cast<double*>(x.data()), constraints.data(), &error_flag);
       if (0 < error_flag) {

bindings/AMPL/AMPLModel.hpp

@@ -13,8 +13,8 @@
 
 // include AMPL Solver Library (ASL)
 extern "C" {
-#include "asl_pfgh.h"
-#include "getstub.h"
+   #include "asl_pfgh.h"
+   #include "getstub.h"
 }
 
 namespace uno {
@@ -33,7 +33,7 @@ namespace uno {
 
       [[nodiscard]] double evaluate_objective(const Vector<double>& x) const override;
       void evaluate_objective_gradient(const Vector<double>& x, SparseVector<double>& gradient) const override;
-      void evaluate_constraints(const Vector<double>& x, std::vector<double>& constraints) const override;
+      void evaluate_constraints(const Vector<double>& x, Vector<double>& constraints) const override;
       void evaluate_constraint_gradient(const Vector<double>& x, size_t constraint_index, SparseVector<double>& gradient) const override;
       void evaluate_constraint_jacobian(const Vector<double>& x, RectangularMatrix<double>& constraint_jacobian) const override;
       void evaluate_lagrangian_hessian(const Vector<double>& x, double objective_multiplier, const Vector<double>& multipliers,

uno/ingredients/constraint_relaxation_strategies/ConstraintRelaxationStrategy.cpp

@@ -2,16 +2,15 @@
 // Licensed under the MIT license. See LICENSE file in the project directory for details.
 
 #include "ConstraintRelaxationStrategy.hpp"
-#include "OptimizationProblem.hpp"
 #include "ingredients/globalization_strategies/GlobalizationStrategy.hpp"
 #include "ingredients/globalization_strategies/GlobalizationStrategyFactory.hpp"
 #include "optimization/Direction.hpp"
 #include "ingredients/inequality_handling_methods/InequalityHandlingMethod.hpp"
 #include "ingredients/inequality_handling_methods/InequalityHandlingMethodFactory.hpp"
-#include "linear_algebra/SymmetricMatrix.hpp"
 #include "model/Model.hpp"
 #include "optimization/Iterate.hpp"
 #include "optimization/Multipliers.hpp"
+#include "optimization/OptimizationProblem.hpp"
 #include "symbolic/VectorView.hpp"
 #include "symbolic/Expression.hpp"
 #include "options/Options.hpp"

uno/ingredients/constraint_relaxation_strategies/FeasibilityRestoration.hpp

@@ -7,8 +7,8 @@
 #include <memory>
 #include "ConstraintRelaxationStrategy.hpp"
 #include "ingredients/globalization_strategies/ProgressMeasures.hpp"
-#include "OptimalityProblem.hpp"
 #include "l1RelaxedProblem.hpp"
+#include "OptimalityProblem.hpp"
 
 namespace uno {
    enum class Phase {FEASIBILITY_RESTORATION = 1, OPTIMALITY = 2};

uno/ingredients/constraint_relaxation_strategies/OptimalityProblem.cpp

@@ -16,7 +16,7 @@ namespace uno {
       objective_gradient = iterate.evaluations.objective_gradient;
    }
 
-   void OptimalityProblem::evaluate_constraints(Iterate& iterate, std::vector<double>& constraints) const {
+   void OptimalityProblem::evaluate_constraints(Iterate& iterate, Vector<double>& constraints) const {
       iterate.evaluate_constraints(this->model);
       constraints = iterate.evaluations.constraints;
    }
@@ -59,7 +59,7 @@ namespace uno {
       }
    }
 
-   double OptimalityProblem::complementarity_error(const Vector<double>& primals, const std::vector<double>& constraints,
+   double OptimalityProblem::complementarity_error(const Vector<double>& primals, const Vector<double>& constraints,
          const Multipliers& multipliers, double shift_value, Norm residual_norm) const {
       // bound constraints
       const Range variables_range = Range(this->model.number_variables);

uno/ingredients/constraint_relaxation_strategies/OptimalityProblem.hpp

@@ -4,7 +4,7 @@
 #ifndef UNO_OPTIMALITYPROBLEM_H
 #define UNO_OPTIMALITYPROBLEM_H
 
-#include "OptimizationProblem.hpp"
+#include "optimization/OptimizationProblem.hpp"
 
 namespace uno {
    class OptimalityProblem: public OptimizationProblem {
@@ -13,7 +13,7 @@ namespace uno {
 
       [[nodiscard]] double get_objective_multiplier() const override { return 1.; }
       void evaluate_objective_gradient(Iterate& iterate, SparseVector<double>& objective_gradient) const override;
-      void evaluate_constraints(Iterate& iterate, std::vector<double>& constraints) const override;
+      void evaluate_constraints(Iterate& iterate, Vector<double>& constraints) const override;
       void evaluate_constraint_jacobian(Iterate& iterate, RectangularMatrix<double>& constraint_jacobian) const override;
       void evaluate_lagrangian_hessian(const Vector<double>& x, const Vector<double>& multipliers, SymmetricMatrix<size_t, double>& hessian) const override;
 
@@ -32,8 +32,8 @@ namespace uno {
       [[nodiscard]] size_t number_hessian_nonzeros() const override { return this->model.number_hessian_nonzeros(); }
 
       void evaluate_lagrangian_gradient(LagrangianGradient<double>& lagrangian_gradient, Iterate& iterate, const Multipliers& multipliers) const override;
-      [[nodiscard]] double complementarity_error(const Vector<double>& primals, const std::vector<double>& constraints,
-            const Multipliers& multipliers, double shift_value, Norm residual_norm) const override;
+      [[nodiscard]] double complementarity_error(const Vector<double>& primals, const Vector<double>& constraints, const Multipliers& multipliers,
+            double shift_value, Norm residual_norm) const override;
    };
 } // namespace
 

uno/ingredients/constraint_relaxation_strategies/l1RelaxedProblem.cpp

@@ -69,7 +69,7 @@ namespace uno {
       }
    }
 
-   void l1RelaxedProblem::evaluate_constraints(Iterate& iterate, std::vector<double>& constraints) const {
+   void l1RelaxedProblem::evaluate_constraints(Iterate& iterate, Vector<double>& constraints) const {
       iterate.evaluate_constraints(this->model);
       constraints = iterate.evaluations.constraints;
       // add the contribution of the elastics
@@ -161,8 +161,8 @@ namespace uno {
    }
 
    // complementary slackness error: expression for violated constraints depends on the definition of the relaxed problem
-   double l1RelaxedProblem::complementarity_error(const Vector<double>& primals, const std::vector<double>& constraints,
-         const Multipliers& multipliers, double shift_value, Norm residual_norm) const {
+   double l1RelaxedProblem::complementarity_error(const Vector<double>& primals, const Vector<double>& constraints, const Multipliers& multipliers,
+         double shift_value, Norm residual_norm) const {
       // bound constraints
       const Range variables_range = Range(this->number_variables);
       const VectorExpression bounds_complementarity{variables_range, [&](size_t variable_index) {

uno/ingredients/constraint_relaxation_strategies/l1RelaxedProblem.hpp

@@ -4,7 +4,7 @@
 #ifndef UNO_L1RELAXEDPROBLEM_H
 #define UNO_L1RELAXEDPROBLEM_H
 
-#include "OptimizationProblem.hpp"
+#include "optimization/OptimizationProblem.hpp"
 #include "ElasticVariables.hpp"
 #include "symbolic/Concatenation.hpp"
 
@@ -16,7 +16,7 @@ namespace uno {
 
       [[nodiscard]] double get_objective_multiplier() const override;
       void evaluate_objective_gradient(Iterate& iterate, SparseVector<double>& objective_gradient) const override;
-      void evaluate_constraints(Iterate& iterate, std::vector<double>& constraints) const override;
+      void evaluate_constraints(Iterate& iterate, Vector<double>& constraints) const override;
       void evaluate_constraint_jacobian(Iterate& iterate, RectangularMatrix<double>& constraint_jacobian) const override;
       void evaluate_lagrangian_hessian(const Vector<double>& x, const Vector<double>& multipliers, SymmetricMatrix<size_t, double>& hessian) const override;
 
@@ -35,8 +35,8 @@ namespace uno {
       [[nodiscard]] size_t number_hessian_nonzeros() const override;
 
       void evaluate_lagrangian_gradient(LagrangianGradient<double>& lagrangian_gradient, Iterate& iterate, const Multipliers& multipliers) const override;
-      [[nodiscard]] double complementarity_error(const Vector<double>& primals, const std::vector<double>& constraints,
-            const Multipliers& multipliers, double shift_value, Norm residual_norm) const override;
+      [[nodiscard]] double complementarity_error(const Vector<double>& primals, const Vector<double>& constraints, const Multipliers& multipliers,
+            double shift_value, Norm residual_norm) const override;
 
       // parameterization
       void set_objective_multiplier(double new_objective_multiplier);

uno/ingredients/hessian_models/ConvexifiedHessian.cpp

@@ -2,9 +2,9 @@
 // Licensed under the MIT license. See LICENSE file in the project directory for details.
 
 #include "ConvexifiedHessian.hpp"
-#include "ingredients/constraint_relaxation_strategies/OptimizationProblem.hpp"
+#include "optimization/OptimizationProblem.hpp"
 #include "ingredients/hessian_models/UnstableRegularization.hpp"
-#include "ingredients/constraint_relaxation_strategies/OptimizationProblem.hpp"
+#include "optimization/OptimizationProblem.hpp"
 #include "ingredients/subproblem_solvers/DirectSymmetricIndefiniteLinearSolver.hpp"
 #include "ingredients/subproblem_solvers/SymmetricIndefiniteLinearSolverFactory.hpp"
 #include "linear_algebra/SymmetricMatrix.hpp"

uno/ingredients/hessian_models/ExactHessian.cpp

@@ -2,7 +2,7 @@
 // Licensed under the MIT license. See LICENSE file in the project directory for details.
 
 #include "ExactHessian.hpp"
-#include "ingredients/constraint_relaxation_strategies/OptimizationProblem.hpp"
+#include "optimization/OptimizationProblem.hpp"
 #include "linear_algebra/SymmetricMatrix.hpp"
 #include "options/Options.hpp"
 

uno/ingredients/hessian_models/ZeroHessian.cpp

@@ -2,7 +2,7 @@
 // Licensed under the MIT license. See LICENSE file in the project directory for details.
 
 #include "ZeroHessian.hpp"
-#include "ingredients/constraint_relaxation_strategies/OptimizationProblem.hpp"
+#include "optimization/OptimizationProblem.hpp"
 #include "linear_algebra/SymmetricMatrix.hpp"
 #include "options/Options.hpp"
 

uno/ingredients/inequality_handling_methods/inequality_constrained_methods/LPMethod.cpp

@@ -2,7 +2,7 @@
 // Licensed under the MIT license. See LICENSE file in the project directory for details.
 
 #include "LPMethod.hpp"
-#include "ingredients/constraint_relaxation_strategies/OptimizationProblem.hpp"
+#include "optimization/OptimizationProblem.hpp"
 #include "ingredients/subproblem_solvers/LPSolver.hpp"
 #include "ingredients/subproblem_solvers/LPSolverFactory.hpp"
 #include "ingredients/subproblems/LagrangeNewtonSubproblem.hpp"

uno/ingredients/inequality_handling_methods/inequality_constrained_methods/QPMethod.cpp

@@ -2,7 +2,7 @@
 // Licensed under the MIT license. See LICENSE file in the project directory for details.
 
 #include "QPMethod.hpp"
-#include "ingredients/constraint_relaxation_strategies/OptimizationProblem.hpp"
+#include "optimization/OptimizationProblem.hpp"
 #include "ingredients/subproblem_solvers/DirectSymmetricIndefiniteLinearSolver.hpp"
 #include "ingredients/subproblem_solvers/QPSolver.hpp"
 #include "ingredients/subproblem_solvers/QPSolverFactory.hpp"

uno/ingredients/inequality_handling_methods/interior_point_methods/BarrierParameterUpdateStrategy.cpp

@@ -5,7 +5,7 @@
 #include <cmath>
 #include "BarrierParameterUpdateStrategy.hpp"
 #include "optimization/Iterate.hpp"
-#include "ingredients/constraint_relaxation_strategies/OptimizationProblem.hpp"
+#include "optimization/OptimizationProblem.hpp"
 #include "symbolic/VectorExpression.hpp"
 #include "tools/Logger.hpp"
 #include "options/Options.hpp"

uno/ingredients/inequality_handling_methods/interior_point_methods/PrimalDualInteriorPointMethod.hpp

@@ -50,7 +50,7 @@ namespace uno {
 
    protected:
       SparseVector<double> objective_gradient; /*!< Sparse Jacobian of the objective */
-      std::vector<double> constraints; /*!< Constraint values (size \f$m)\f$ */
+      Vector<double> constraints; /*!< Constraint values (size \f$m)\f$ */
       RectangularMatrix<double> constraint_jacobian; /*!< Sparse Jacobian of the constraints */
       SymmetricMatrix<size_t, double> hessian;
 

uno/ingredients/inequality_handling_methods/interior_point_methods/PrimalDualInteriorPointProblem.cpp

@@ -40,7 +40,7 @@ namespace uno {
       }
    }
 
-   void PrimalDualInteriorPointProblem::evaluate_constraints(Iterate& iterate, std::vector<double>& constraints) const {
+   void PrimalDualInteriorPointProblem::evaluate_constraints(Iterate& iterate, Vector<double>& constraints) const {
       problem.evaluate_constraints(iterate, constraints);
    }
 
@@ -152,7 +152,7 @@ namespace uno {
       }
    }
 
-   double PrimalDualInteriorPointProblem::complementarity_error(const Vector<double>& primals, const std::vector<double>& constraints,
+   double PrimalDualInteriorPointProblem::complementarity_error(const Vector<double>& primals, const Vector<double>& constraints,
          const Multipliers& multipliers, double shift_value, Norm residual_norm) const {
       return this->problem.complementarity_error(primals, constraints, multipliers, shift_value, residual_norm);
    }

uno/ingredients/inequality_handling_methods/interior_point_methods/PrimalDualInteriorPointProblem.hpp

@@ -4,7 +4,7 @@
 #ifndef UNO_PRIMALDUALINTERIORPOINTPROBLEM_H
 #define UNO_PRIMALDUALINTERIORPOINTPROBLEM_H
 
-#include "ingredients/constraint_relaxation_strategies/OptimizationProblem.hpp"
+#include "optimization/OptimizationProblem.hpp"
 
 namespace uno {
    class PrimalDualInteriorPointProblem : public OptimizationProblem {
@@ -14,7 +14,7 @@ namespace uno {
       // function evaluations
       [[nodiscard]] double get_objective_multiplier() const override;
       void evaluate_objective_gradient(Iterate& iterate, SparseVector<double>& objective_gradient) const override;
-      void evaluate_constraints(Iterate& iterate, std::vector<double>& constraints) const override;
+      void evaluate_constraints(Iterate& iterate, Vector<double>& constraints) const override;
       void evaluate_constraint_jacobian(Iterate& iterate, RectangularMatrix<double>& constraint_jacobian) const override;
       void evaluate_lagrangian_hessian(const Vector<double>& x, const Vector<double>& multipliers,
             SymmetricMatrix<size_t, double>& hessian) const override;
@@ -34,8 +34,8 @@ namespace uno {
 
       void evaluate_lagrangian_gradient(LagrangianGradient<double>& lagrangian_gradient, Iterate& iterate,
             const Multipliers& multipliers) const override;
-      [[nodiscard]] double complementarity_error(const Vector<double>& primals, const std::vector<double>& constraints,
-            const Multipliers& multipliers, double shift_value, Norm residual_norm) const override;
+      [[nodiscard]] double complementarity_error(const Vector<double>& primals, const Vector<double>& constraints, const Multipliers& multipliers,
+         double shift_value, Norm residual_norm) const override;
 
    protected:
       const OptimizationProblem& problem;

uno/ingredients/subproblem_solvers/BQPD/BQPDSolver.cpp

@@ -3,7 +3,7 @@
 
 #include <cassert>
 #include "BQPDSolver.hpp"
-#include "ingredients/constraint_relaxation_strategies/OptimizationProblem.hpp"
+#include "optimization/OptimizationProblem.hpp"
 #include "ingredients/hessian_models/HessianModel.hpp"
 #include "ingredients/subproblems/LagrangeNewtonSubproblem.hpp"
 #include "linear_algebra/SymmetricMatrix.hpp"

uno/ingredients/subproblem_solvers/BQPD/BQPDSolver.hpp

@@ -61,7 +61,7 @@ namespace uno {
 
    private:
       std::vector<double> lower_bounds{}, upper_bounds{}; // lower and upper bounds of variables and constraints
-      std::vector<double> constraints;
+      Vector<double> constraints;
       SparseVector<double> linear_objective;
       RectangularMatrix<double> constraint_jacobian;
       std::vector<double> bqpd_jacobian{};

uno/ingredients/subproblem_solvers/HiGHS/HiGHSSolver.hpp

@@ -5,6 +5,7 @@
 #include "Highs.h"
 #include "linear_algebra/RectangularMatrix.hpp"
 #include "linear_algebra/SparseVector.hpp"
+#include "linear_algebra/Vector.hpp"
 
 namespace uno {
    // forward declaration
@@ -22,7 +23,7 @@ namespace uno {
       HighsModel model;
       Highs highs_solver;
 
-      std::vector<double> constraints;
+      Vector<double> constraints;
       SparseVector<double> linear_objective;
       RectangularMatrix<double> constraint_jacobian;
 

uno/ingredients/subproblems/LagrangeNewtonSubproblem.cpp

@@ -2,7 +2,7 @@
 // Licensed under the MIT license. See LICENSE file in the project directory for details.
 
 #include "LagrangeNewtonSubproblem.hpp"
-#include "ingredients/constraint_relaxation_strategies/OptimizationProblem.hpp"
+#include "optimization/OptimizationProblem.hpp"
 #include "ingredients/hessian_models/HessianModel.hpp"
 #include "optimization/Iterate.hpp"
 
@@ -17,7 +17,7 @@ namespace uno {
       this->problem.evaluate_objective_gradient(this->current_iterate, linear_objective);
    }
 
-   void LagrangeNewtonSubproblem::evaluate_constraints(std::vector<double>& constraints) {
+   void LagrangeNewtonSubproblem::evaluate_constraints(Vector<double>& constraints) {
       this->problem.evaluate_constraints(this->current_iterate, constraints);
    }
 

uno/ingredients/subproblems/LagrangeNewtonSubproblem.hpp

@@ -6,7 +6,7 @@
 
 #include <cstddef>
 #include <vector>
-#include "ingredients/constraint_relaxation_strategies/OptimizationProblem.hpp"
+#include "optimization/OptimizationProblem.hpp"
 #include "optimization/Iterate.hpp"
 
 namespace uno {
@@ -33,14 +33,14 @@ namespace uno {
             HessianModel& hessian_model, double trust_region_radius);
 
       void evaluate_objective_gradient(SparseVector<double>& linear_objective);
-      void evaluate_constraints(std::vector<double>& constraints);
+      void evaluate_constraints(Vector<double>& constraints);
       void evaluate_constraint_jacobian(RectangularMatrix<double>& jacobian);
       void evaluate_hessian(Statistics& statistics, SymmetricMatrix<size_t, double>& hessian);
 
       template <typename Array>
       void set_variable_bounds(Array& lower_bounds, Array& upper_bounds);
       template <typename Array>
-      void set_constraint_bounds(const std::vector<double>& constraints, Array& lower_bounds, Array& upper_bounds);
+      void set_constraint_bounds(const Vector<double>& constraints, Array& lower_bounds, Array& upper_bounds);
 
    protected:
       const OptimizationProblem& problem;
@@ -67,7 +67,7 @@ namespace uno {
    }
 
    template <typename Array>
-   void LagrangeNewtonSubproblem::set_constraint_bounds(const std::vector<double>& constraints, Array& lower_bounds, Array& upper_bounds) {
+   void LagrangeNewtonSubproblem::set_constraint_bounds(const Vector<double>& constraints, Array& lower_bounds, Array& upper_bounds) {
       for (size_t constraint_index: Range(this->problem.number_constraints)) {
          lower_bounds[constraint_index] = problem.constraint_lower_bound(constraint_index) - constraints[constraint_index];
          upper_bounds[constraint_index] = problem.constraint_upper_bound(constraint_index) - constraints[constraint_index];

uno/model/BoundRelaxedModel.hpp

@@ -19,7 +19,7 @@ namespace uno {
       void evaluate_objective_gradient(const Vector<double>& x, SparseVector<double>& gradient) const override {
          this->model->evaluate_objective_gradient(x, gradient);
       }
-      void evaluate_constraints(const Vector<double>& x, std::vector<double>& constraints) const override {
+      void evaluate_constraints(const Vector<double>& x, Vector<double>& constraints) const override {
          this->model->evaluate_constraints(x, constraints);
       }
       void evaluate_constraint_gradient(const Vector<double>& x, size_t constraint_index, SparseVector<double>& gradient) const override {

uno/model/FixedBoundsConstraintsModel.cpp

@@ -37,7 +37,7 @@ namespace uno {
       this->model->evaluate_objective_gradient(x, gradient);
    }
 
-   void FixedBoundsConstraintsModel::evaluate_constraints(const Vector<double>& x, std::vector<double>& constraints) const {
+   void FixedBoundsConstraintsModel::evaluate_constraints(const Vector<double>& x, Vector<double>& constraints) const {
       this->model->evaluate_constraints(x, constraints);
       // add the fixed variables
       size_t current_constraint = this->model->number_constraints;

uno/model/FixedBoundsConstraintsModel.hpp

@@ -24,7 +24,7 @@ namespace uno {
 
       [[nodiscard]] double evaluate_objective(const Vector<double>& x) const override;
       void evaluate_objective_gradient(const Vector<double>& x, SparseVector<double>& gradient) const override;
-      void evaluate_constraints(const Vector<double>& x, std::vector<double>& constraints) const override;
+      void evaluate_constraints(const Vector<double>& x, Vector<double>& constraints) const override;
       void evaluate_constraint_gradient(const Vector<double>& x, size_t constraint_index, SparseVector<double>& gradient) const override;
       void evaluate_constraint_jacobian(const Vector<double>& x, RectangularMatrix<double>& constraint_jacobian) const override;
       void evaluate_lagrangian_hessian(const Vector<double>& x, double objective_multiplier, const Vector<double>& multipliers,