constraint-base.hpp

// BSD 3-Clause License
//
// Copyright (C) 2020-2025, University of Edinburgh, Heriot-Watt University
// Copyright note valid unless otherwise stated in individual files.
// All rights reserved.
 
#ifndef CROCODDYL_CORE_CONSTRAINT_BASE_HPP_
#define CROCODDYL_CORE_CONSTRAINT_BASE_HPP_
 
#include "crocoddyl/core/fwd.hpp"
//
#include "crocoddyl/core/data-collector-base.hpp"
#include "crocoddyl/core/residual-base.hpp"
#include "crocoddyl/core/state-base.hpp"
 
namespace crocoddyl {
 
enum ConstraintType { Inequality = 0, Equality, Both };
 
class ConstraintModelBase {
 public:
  virtual ~ConstraintModelBase() = default;
 
  CROCODDYL_BASE_CAST(ConstraintModelBase, ConstraintModelAbstractTpl)
};
 
template <typename _Scalar>
class ConstraintModelAbstractTpl : public ConstraintModelBase {
 public:
  EIGEN_MAKE_ALIGNED_OPERATOR_NEW
 
  typedef _Scalar Scalar;
  typedef MathBaseTpl<Scalar> MathBase;
  typedef ConstraintDataAbstractTpl<Scalar> ConstraintDataAbstract;
  typedef StateAbstractTpl<Scalar> StateAbstract;
  typedef ResidualModelAbstractTpl<Scalar> ResidualModelAbstract;
  typedef DataCollectorAbstractTpl<Scalar> DataCollectorAbstract;
  typedef typename MathBase::VectorXs VectorXs;
 
  ConstraintModelAbstractTpl(std::shared_ptr<StateAbstract> state,
                             std::shared_ptr<ResidualModelAbstract> residual,
                             const std::size_t ng, const std::size_t nh);
 
  ConstraintModelAbstractTpl(std::shared_ptr<StateAbstract> state,
                             const std::size_t nu, const std::size_t ng,
                             const std::size_t nh, const bool T_const = true);
 
  ConstraintModelAbstractTpl(std::shared_ptr<StateAbstract> state,
                             const std::size_t ng, const std::size_t nh,
                             const bool T_const = true);
  virtual ~ConstraintModelAbstractTpl() = default;
 
  virtual void calc(const std::shared_ptr<ConstraintDataAbstract>& data,
                    const Eigen::Ref<const VectorXs>& x,
                    const Eigen::Ref<const VectorXs>& u) = 0;
 
  virtual void calc(const std::shared_ptr<ConstraintDataAbstract>& data,
                    const Eigen::Ref<const VectorXs>& x);
 
  virtual void calcDiff(const std::shared_ptr<ConstraintDataAbstract>& data,
                        const Eigen::Ref<const VectorXs>& x,
                        const Eigen::Ref<const VectorXs>& u) = 0;
 
  virtual void calcDiff(const std::shared_ptr<ConstraintDataAbstract>& data,
                        const Eigen::Ref<const VectorXs>& x);
 
  virtual std::shared_ptr<ConstraintDataAbstract> createData(
      DataCollectorAbstract* const data);
 
  void update_bounds(const VectorXs& lower, const VectorXs& upper);
 
  void remove_bounds();
 
  const std::shared_ptr<StateAbstract>& get_state() const;
 
  const std::shared_ptr<ResidualModelAbstract>& get_residual() const;
 
  ConstraintType get_type() const;
 
  const VectorXs& get_lb() const;
 
  const VectorXs& get_ub() const;
 
  std::size_t get_nu() const;
 
  std::size_t get_ng() const;
 
  std::size_t get_nh() const;
 
  bool get_T_constraint() const;
 
  template <class Scalar>
  friend std::ostream& operator<<(std::ostream& os,
                                  const CostModelAbstractTpl<Scalar>& model);
 
  virtual void print(std::ostream& os) const;
 
 private:
  std::size_t ng_internal_;  
  std::size_t nh_internal_;  
 
 protected:
  std::shared_ptr<StateAbstract> state_;             
  std::shared_ptr<ResidualModelAbstract> residual_;  
  ConstraintType
      type_;           
  VectorXs lb_;        
  VectorXs ub_;        
  std::size_t nu_;     
  std::size_t ng_;     
  std::size_t nh_;     
  bool T_constraint_;  
  VectorXs unone_;     
  ConstraintModelAbstractTpl()
      : state_(nullptr), residual_(nullptr), nu_(0), ng_(0), nh_(0) {}
};
 
template <typename _Scalar>
struct ConstraintDataAbstractTpl {
  EIGEN_MAKE_ALIGNED_OPERATOR_NEW
 
  typedef _Scalar Scalar;
  typedef MathBaseTpl<Scalar> MathBase;
  typedef ResidualDataAbstractTpl<Scalar> ResidualDataAbstract;
  typedef DataCollectorAbstractTpl<Scalar> DataCollectorAbstract;
  typedef typename MathBase::VectorXs VectorXs;
  typedef typename MathBase::MatrixXs MatrixXs;
 
  template <template <typename Scalar> class Model>
  ConstraintDataAbstractTpl(Model<Scalar>* const model,
                            DataCollectorAbstract* const data)
      : shared(data),
        residual(model->get_residual()->createData(data)),
        g(model->get_ng()),
        Gx(model->get_ng(), model->get_state()->get_ndx()),
        Gu(model->get_ng(), model->get_nu()),
        h(model->get_nh()),
        Hx(model->get_nh(), model->get_state()->get_ndx()),
        Hu(model->get_nh(), model->get_nu()) {
    if (model->get_ng() == 0 && model->get_nh() == 0) {
      throw_pretty("Invalid argument: " << "ng and nh cannot be equals to 0");
    }
    g.setZero();
    Gx.setZero();
    Gu.setZero();
    h.setZero();
    Hx.setZero();
    Hu.setZero();
  }
  virtual ~ConstraintDataAbstractTpl() = default;
 
  DataCollectorAbstract* shared;                   
  std::shared_ptr<ResidualDataAbstract> residual;  
  VectorXs g;   
  MatrixXs Gx;  
  MatrixXs Gu;  
  VectorXs h;   
  MatrixXs Hx;  
  MatrixXs Hu;  
};
 
}  // namespace crocoddyl
 
/* --- Details -------------------------------------------------------------- */
/* --- Details -------------------------------------------------------------- */
/* --- Details -------------------------------------------------------------- */
#include "crocoddyl/core/constraint-base.hxx"
 
CROCODDYL_DECLARE_EXTERN_TEMPLATE_CLASS(crocoddyl::ConstraintModelAbstractTpl)
CROCODDYL_DECLARE_EXTERN_TEMPLATE_STRUCT(crocoddyl::ConstraintDataAbstractTpl)
 
#endif  // CROCODDYL_CORE_CONSTRAINT_BASE_HPP_