poly-one.hpp

// BSD 3-Clause License
//
// Copyright (C) 2021-2025, University of Edinburgh, University of Trento,
//                          Heriot-Watt University
// Copyright note valid unless otherwise stated in individual files.
// All rights reserved.
 
#ifndef CROCODDYL_CORE_CONTROLS_POLY_ONE_HPP_
#define CROCODDYL_CORE_CONTROLS_POLY_ONE_HPP_
 
#include "crocoddyl/core/control-base.hpp"
#include "crocoddyl/core/fwd.hpp"
 
namespace crocoddyl {
 
template <typename _Scalar>
class ControlParametrizationModelPolyOneTpl
    : public ControlParametrizationModelAbstractTpl<_Scalar> {
 public:
  EIGEN_MAKE_ALIGNED_OPERATOR_NEW
  CROCODDYL_DERIVED_CAST(ControlParametrizationModelBase,
                         ControlParametrizationModelPolyOneTpl)
 
  typedef _Scalar Scalar;
  typedef MathBaseTpl<Scalar> MathBase;
  typedef ControlParametrizationDataAbstractTpl<Scalar>
      ControlParametrizationDataAbstract;
  typedef ControlParametrizationModelAbstractTpl<Scalar> Base;
  typedef ControlParametrizationDataPolyOneTpl<Scalar> Data;
  typedef typename MathBase::VectorXs VectorXs;
  typedef typename MathBase::MatrixXs MatrixXs;
 
  explicit ControlParametrizationModelPolyOneTpl(const std::size_t nw);
  virtual ~ControlParametrizationModelPolyOneTpl() = default;
 
  virtual void calc(
      const std::shared_ptr<ControlParametrizationDataAbstract>& data,
      const Scalar t, const Eigen::Ref<const VectorXs>& u) const override;
 
  virtual void calcDiff(
      const std::shared_ptr<ControlParametrizationDataAbstract>& data,
      const Scalar t, const Eigen::Ref<const VectorXs>& u) const override;
 
  virtual std::shared_ptr<ControlParametrizationDataAbstract> createData()
      override;
 
  virtual void params(
      const std::shared_ptr<ControlParametrizationDataAbstract>& data,
      const Scalar t, const Eigen::Ref<const VectorXs>& w) const override;
 
  virtual void convertBounds(const Eigen::Ref<const VectorXs>& w_lb,
                             const Eigen::Ref<const VectorXs>& w_ub,
                             Eigen::Ref<VectorXs> u_lb,
                             Eigen::Ref<VectorXs> u_ub) const override;
 
  virtual void multiplyByJacobian(
      const std::shared_ptr<ControlParametrizationDataAbstract>& data,
      const Eigen::Ref<const MatrixXs>& A, Eigen::Ref<MatrixXs> out,
      const AssignmentOp = setto) const override;
 
  virtual void multiplyJacobianTransposeBy(
      const std::shared_ptr<ControlParametrizationDataAbstract>& data,
      const Eigen::Ref<const MatrixXs>& A, Eigen::Ref<MatrixXs> out,
      const AssignmentOp = setto) const override;
 
  template <typename NewScalar>
  ControlParametrizationModelPolyOneTpl<NewScalar> cast() const;
 
  virtual void print(std::ostream& os) const override;
 
 protected:
  using Base::nu_;
  using Base::nw_;
};
 
template <typename _Scalar>
struct ControlParametrizationDataPolyOneTpl
    : public ControlParametrizationDataAbstractTpl<_Scalar> {
  EIGEN_MAKE_ALIGNED_OPERATOR_NEW
 
  typedef _Scalar Scalar;
  typedef MathBaseTpl<Scalar> MathBase;
  typedef ControlParametrizationDataAbstractTpl<Scalar> Base;
  typedef typename MathBase::Vector2s Vector2s;
 
  template <template <typename Scalar> class Model>
  explicit ControlParametrizationDataPolyOneTpl(Model<Scalar>* const model)
      : Base(model) {
    c.setZero();
  }
  virtual ~ControlParametrizationDataPolyOneTpl() = default;
 
  Vector2s c;  
 
  using Base::dw_du;
  using Base::u;
  using Base::w;
};
 
}  // namespace crocoddyl
 
/* --- Details -------------------------------------------------------------- */
/* --- Details -------------------------------------------------------------- */
/* --- Details -------------------------------------------------------------- */
#include "crocoddyl/core/controls/poly-one.hxx"
 
CROCODDYL_DECLARE_EXTERN_TEMPLATE_CLASS(
    crocoddyl::ControlParametrizationModelPolyOneTpl)
CROCODDYL_DECLARE_EXTERN_TEMPLATE_STRUCT(
    crocoddyl::ControlParametrizationDataPolyOneTpl)
 
#endif  // CROCODDYL_CORE_CONTROLS_POLY_ONE_HPP_