Problem.hxx

Go to the documentation of this file.

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\
 * Copyright (c) 2025, Davide Stocco and Enrico Bertolazzi.                                      *
 *                                                                                               *
 * The Pipal project is distributed under the MIT License.                                       *
 *                                                                                               *
 * Davide Stocco                                                               Enrico Bertolazzi *
 * University of Trento                                                     University of Trento *
 * e-mail: davide.stocco@unitn.it                             e-mail: enrico.bertolazzi@unitn.it *
\* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
#pragma once
 
#ifndef INCLUDE_PIPAL_PROBLEM_HXX
#define INCLUDE_PIPAL_PROBLEM_HXX
 
namespace Pipal {

  template <typename Real>
  class Problem
  {
    static_assert(std::is_floating_point_v<Real>,
      "Pipal::Problem<Real>: Real must be a floating-point type.");
 
    std::string m_name{"(Unnamed Pipal Problem)"}; 
 
  public:
    using UniquePtr = std::unique_ptr<Problem>;

    Problem() = default;

    Problem(std::string t_name) : m_name(std::move(t_name)) {};

    Problem(Problem const &) = delete;

    Problem & operator=(Problem const &) = delete;

    Problem(Problem &&) = delete;

    Problem & operator=(Problem &&) = delete;

    virtual ~Problem() = default;

    std::string const & name() const {return this->m_name;}

    void name(std::string const & t_name) {this->m_name = t_name;}

    virtual bool objective(Vector<Real> const & x, Real & out) const = 0;

    virtual bool objective_gradient(Vector<Real> const & x, Vector<Real> & out) const = 0;

    virtual bool constraints(Vector<Real> const & x, Vector<Real> & out) const = 0;

    virtual bool constraints_jacobian(Vector<Real> const & x, SparseMatrix<Real> & out) const = 0;

    virtual bool lagrangian_hessian(Vector<Real> const & x, Vector<Real> const & l, SparseMatrix<Real> & out) const = 0;

    virtual bool primal_lower_bounds(Vector<Real> & out) const = 0;

    virtual bool primal_upper_bounds(Vector<Real> & out) const = 0;

    virtual bool constraints_lower_bounds(Vector<Real> & out) const = 0;

    virtual bool constraints_upper_bounds(Vector<Real> & out) const = 0;
 
  }; // class Problem

  template <typename Real>
  class ProblemWrapper : public Problem<Real>
  {
  public:
    using ObjectiveFunc           = std::function<bool(Vector<Real> const &, Real &)>;
    using ConstraintsFunc         = std::function<bool(Vector<Real> const &, Vector<Real> &)>;
    using ObjectiveGradientFunc   = std::function<bool(Vector<Real> const &, Vector<Real> &)>;
    using ConstraintsJacobianFunc = std::function<bool(Vector<Real> const &, SparseMatrix<Real> &)>;
    using LagrangianHessianFunc   = std::function<bool(Vector<Real> const &, Vector<Real> const &, SparseMatrix<Real> &)>;
    using BoundsFunc              = std::function<bool(Vector<Real> &)>;
 
  private:
    // Problem functions
    ObjectiveFunc           m_objective{nullptr};            
    ObjectiveGradientFunc   m_objective_gradient{nullptr};   
    ConstraintsFunc         m_constraints{nullptr};          
    ConstraintsJacobianFunc m_constraints_jacobian{nullptr}; 
    LagrangianHessianFunc   m_lagrangian_hessian{nullptr};   
 
    // Bounds functions
    BoundsFunc m_primal_lower_bounds{nullptr};      
    BoundsFunc m_primal_upper_bounds{nullptr};      
    BoundsFunc m_constraints_lower_bounds{nullptr}; 
    BoundsFunc m_constraints_upper_bounds{nullptr}; 
 
  public:
    ProblemWrapper(
      std::string             const & t_name,
      ObjectiveFunc           const & t_objective,
      ObjectiveGradientFunc   const & t_objective_gradient,
      ConstraintsFunc         const & t_constraints,
      ConstraintsJacobianFunc const & t_constraints_jacobian,
      LagrangianHessianFunc   const & t_lagrangian_hessian,
      BoundsFunc              const & t_primal_lower_bounds,
      BoundsFunc              const & t_primal_upper_bounds,
      BoundsFunc              const & t_constraints_lower_bounds,
      BoundsFunc              const & t_constraints_upper_bounds
  )
    : Problem<Real>(t_name)
    , m_objective(t_objective)
    , m_objective_gradient(t_objective_gradient)
    , m_constraints(t_constraints)
    , m_constraints_jacobian(t_constraints_jacobian)
    , m_lagrangian_hessian(t_lagrangian_hessian)
    , m_primal_lower_bounds(t_primal_lower_bounds)
    , m_primal_upper_bounds(t_primal_upper_bounds)
    , m_constraints_lower_bounds(t_constraints_lower_bounds)
    , m_constraints_upper_bounds(t_constraints_upper_bounds)
    {}

    ~ProblemWrapper() override {};

    ObjectiveFunc & objective() {return this->m_objective;}

    void objective(ObjectiveFunc const & objective)
    {
      this->m_objective = objective;
    }

    ObjectiveGradientFunc & objective_gradient() {return this->m_objective_gradient;}

    void objective_gradient(ObjectiveGradientFunc const & objective_gradient)
    {
      this->m_objective_gradient = objective_gradient;
    }

    ConstraintsFunc & constraints() {return this->m_constraints;}

    void constraints(ConstraintsFunc const & constraints)
    {
      this->m_constraints = constraints;
    }

    ConstraintsJacobianFunc & constraints_jacobian() {return this->m_constraints_jacobian;}

    void constraints_jacobian(ConstraintsJacobianFunc const & constraints_jacobian)
    {
      this->m_constraints_jacobian = constraints_jacobian;
    }

    BoundsFunc & primal_lower_bounds() {return this->m_primal_lower_bounds;}

    void primal_lower_bounds(BoundsFunc const & primal_lower_bounds)
    {
      this->m_primal_lower_bounds = primal_lower_bounds;
    }

    BoundsFunc & primal_upper_bounds() {return this->m_primal_upper_bounds;}

    void primal_upper_bounds(BoundsFunc const & primal_upper_bounds)
    {
      this->m_primal_upper_bounds = primal_upper_bounds;
    }

    BoundsFunc & constraints_lower_bounds() {return this->m_constraints_lower_bounds;}

    void constraints_lower_bounds(BoundsFunc const & constraints_lower_bounds)
    {
      this->m_constraints_lower_bounds = constraints_lower_bounds;
    }

    BoundsFunc & constraints_upper_bounds() {return this->m_constraints_upper_bounds;}

    void constraints_upper_bounds(BoundsFunc const & constraints_upper_bounds)
    {
      this->m_constraints_upper_bounds = constraints_upper_bounds;
    }

    LagrangianHessianFunc & lagrangian_hessian() {return this->m_lagrangian_hessian;}

    void lagrangian_hessian(LagrangianHessianFunc const & lagrangian_hessian)
    {
      this->m_lagrangian_hessian = lagrangian_hessian;
    }

    bool objective(Vector<Real> const & x, Real & out) const override
    {
      return this->m_objective(x, out);
    }

    bool objective_gradient(Vector<Real> const & x, Vector<Real> & out) const override
    {
      return this->m_objective_gradient(x, out);
    }

    bool constraints(Vector<Real> const & x, Vector<Real> & out) const override
    {
      return this->m_constraints(x, out);
    }

    bool constraints_jacobian(Vector<Real> const & x, SparseMatrix<Real> & out) const override
    {
      return this->m_constraints_jacobian(x, out);
    }

    bool lagrangian_hessian(Vector<Real> const & x, Vector<Real> const & l, SparseMatrix<Real> & out)
      const override
    {
      return this->m_lagrangian_hessian(x, l, out);
    }

    bool primal_lower_bounds(Vector<Real> & out) const override
    {
      return this->m_primal_lower_bounds(out);
    }

    bool primal_upper_bounds(Vector<Real> & out) const override
    {
      return this->m_primal_upper_bounds(out);
    }

    bool constraints_lower_bounds(Vector<Real> & out) const override
    {
      return this->m_constraints_lower_bounds(out);
    }

    bool constraints_upper_bounds(Vector<Real> & out) const override
    {
      return this->m_constraints_upper_bounds(out);
    }
 
  }; // class ProblemWrapper
 
} // namespace Pipal
 
#endif // INCLUDE_PIPAL_PROBLEM_HXX