function-abstract.hpp

Go to the documentation of this file.

#pragma once
 
#include "aligator/context.hpp"
#include <ostream>
 
namespace aligator {

template <typename _Scalar> struct StageFunctionTpl {
public:
  using Scalar = _Scalar;
  ALIGATOR_DYNAMIC_TYPEDEFS(Scalar);
  using Data = StageFunctionDataTpl<Scalar>;

  const int ndx1;
  const int nu;
  const int nr;
 
  StageFunctionTpl(const int ndx, const int nu, const int nr);

  virtual void evaluate(const ConstVectorRef &x, const ConstVectorRef &u,
                        Data &data) const = 0;

  virtual void computeJacobians(const ConstVectorRef &x,
                                const ConstVectorRef &u, Data &data) const = 0;

  virtual void computeVectorHessianProducts(const ConstVectorRef &x,
                                            const ConstVectorRef &u,
                                            const ConstVectorRef &lbda,
                                            Data &data) const;
 
  virtual ~StageFunctionTpl() = default;

  virtual shared_ptr<Data> createData() const;
};

template <typename _Scalar> struct StageFunctionDataTpl {
  using Scalar = _Scalar;
  ALIGATOR_DYNAMIC_TYPEDEFS(Scalar);
 
  const int ndx1;
  const int nu;
  const int nr;
  const int nvar = ndx1 + nu;

  VectorXs value_;
  VectorRef valref_;
  MatrixXs jac_buffer_;
  MatrixXs vhp_buffer_;
  MatrixRef Jx_;
  MatrixRef Ju_;
 
  ConstMatrixRef Jx() const { return Jx_; }
  ConstMatrixRef Ju() const { return Ju_; }
  MatrixRef Jx() { return Jx_; }
  MatrixRef Ju() { return Ju_; }
 
  /* Vector-Hessian product buffers */
 
  MatrixRef Hxx_;
  MatrixRef Hxu_;
  MatrixRef Huu_;

  StageFunctionDataTpl(const int ndx, const int nu, const int nr);
  explicit StageFunctionDataTpl(const StageFunctionTpl<Scalar> &model);
  virtual ~StageFunctionDataTpl() = default;
};
 
template <typename T>
std::ostream &operator<<(std::ostream &oss,
                         const StageFunctionDataTpl<T> &self);
 
extern template struct StageFunctionTpl<context::Scalar>;
extern template struct StageFunctionDataTpl<context::Scalar>;
extern template std::ostream &
operator<<(std::ostream &oss,
           const StageFunctionDataTpl<context::Scalar> &self);
 
} // namespace aligator