tangent-bundle.hpp

#pragma once
 
#include "proxsuite-nlp/manifold-base.hpp"
 
namespace proxsuite {
namespace nlp {

template <class Base>
struct TangentBundleTpl : public ManifoldAbstractTpl<typename Base::Scalar> {
protected:
  Base base_;
 
public:
  using Self = TangentBundleTpl<Base>;
  using Scalar = typename Base::Scalar;
  static constexpr int Options = Base::Options;
  PROXSUITE_NLP_DYNAMIC_TYPEDEFS(Scalar);

  TangentBundleTpl(Base base) : base_(base) {};
  template <typename... BaseCtorArgs>
  TangentBundleTpl(BaseCtorArgs... args) : base_(Base(args...)) {}

 
  inline int nx() const { return base_.nx() + base_.ndx(); }
  inline int ndx() const { return 2 * base_.ndx(); }
 
  VectorXs neutral() const;
  VectorXs rand() const;
  bool isNormalized(const ConstVectorRef &x) const {
    auto p = getBasePoint(x);
    return base_.isNormalized(p);
  }
 
  const Base &getBaseSpace() const { return base_; }

 
  void integrate_impl(const ConstVectorRef &x, const ConstVectorRef &dx,
                      VectorRef out) const;
 
  void difference_impl(const ConstVectorRef &x0, const ConstVectorRef &x1,
                       VectorRef out) const;
 
  void Jintegrate_impl(const ConstVectorRef &x, const ConstVectorRef &v,
                       MatrixRef Jout, int arg) const;
 
  void JintegrateTransport(const ConstVectorRef &x, const ConstVectorRef &v,
                           MatrixRef Jout, int arg) const;
 
  void Jdifference_impl(const ConstVectorRef &x0, const ConstVectorRef &x1,
                        MatrixRef Jout, int arg) const;
 
  void interpolate_impl(const ConstVectorRef &x0, const ConstVectorRef &x1,
                        const Scalar &u, VectorRef out) const;

  template <typename Point>
  typename Point::ConstSegmentReturnType getBasePoint(const Point &x) const {
    return x.head(base_.nx());
  }
 
  template <typename Point>
  typename Point::SegmentReturnType getBasePointWrite(const Point &x) const {
    return PROXSUITE_NLP_EIGEN_CONST_CAST(Point, x).head(base_.nx());
  }
 
  template <typename Tangent>
  typename Tangent::ConstSegmentReturnType
  getBaseTangent(const Tangent &v) const {
    return v.head(base_.ndx());
  }
 
  template <typename Tangent>
  typename Tangent::SegmentReturnType
  getTangentHeadWrite(const Tangent &v) const {
    return PROXSUITE_NLP_EIGEN_CONST_CAST(Tangent, v).head(base_.ndx());
  }
 
  template <typename Jac>
  Eigen::Block<Jac, Eigen::Dynamic, Eigen::Dynamic>
  getBaseJacobian(const Jac &J) const {
    return PROXSUITE_NLP_EIGEN_CONST_CAST(Jac, J).topLeftCorner(base_.ndx(),
                                                                base_.ndx());
  }
};
 
} // namespace nlp
} // namespace proxsuite
 
#include "proxsuite-nlp/modelling/spaces/tangent-bundle.hxx"