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_