function-base.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "proxsuite-nlp/fwd.hpp"
 
namespace proxsuite {
namespace nlp {
template <typename _Scalar> struct BaseFunctionTpl : math_types<_Scalar> {
protected:
  int nx_;
  int ndx_;
  int nr_;
 
public:
  using Scalar = _Scalar;
  PROXSUITE_NLP_DYNAMIC_TYPEDEFS(Scalar);
 
  BaseFunctionTpl(const int nx, const int ndx, const int nr)
      : nx_(nx), ndx_(ndx), nr_(nr) {}
 
  BaseFunctionTpl(const ManifoldAbstractTpl<Scalar> &manifold, const int nr)
      : BaseFunctionTpl(manifold.nx(), manifold.ndx(), nr) {}
 
  virtual VectorXs operator()(const ConstVectorRef &x) const = 0;
 
  virtual ~BaseFunctionTpl() = default;
 
  int nx() const { return nx_; }
  int ndx() const { return ndx_; }
  int nr() const { return nr_; }
};
 
template <typename _Scalar>
struct C1FunctionTpl : public BaseFunctionTpl<_Scalar> {
public:
  using Scalar = _Scalar;
  using Base = BaseFunctionTpl<_Scalar>;
  PROXSUITE_NLP_DYNAMIC_TYPEDEFS(Scalar);
 
  // We can't use using Base::Base because of MSVC explicit template
  // instantiation
  C1FunctionTpl(const int nx, const int ndx, const int nr)
      : Base(nx, ndx, nr) {}
  C1FunctionTpl(const ManifoldAbstractTpl<Scalar> &manifold, const int nr)
      : C1FunctionTpl(manifold.nx(), manifold.ndx(), nr) {}
 
  virtual void computeJacobian(const ConstVectorRef &x,
                               MatrixRef Jout) const = 0;
 
  MatrixXs computeJacobian(const ConstVectorRef &x) const {
    MatrixXs Jout(this->nr(), this->ndx());
    computeJacobian(x, Jout);
    return Jout;
  }
};
 
template <typename _Scalar>
struct C2FunctionTpl : public C1FunctionTpl<_Scalar> {
public:
  using Scalar = _Scalar;
  using Base = C1FunctionTpl<_Scalar>;
  PROXSUITE_NLP_DYNAMIC_TYPEDEFS(Scalar);
 
  // We can't use using Base::Base because of MSVC explicit template
  // instantiation
  C2FunctionTpl(const int nx, const int ndx, const int nr)
      : Base(nx, ndx, nr) {}
  C2FunctionTpl(const ManifoldAbstractTpl<Scalar> &manifold, const int nr)
      : C2FunctionTpl(manifold.nx(), manifold.ndx(), nr) {}
 
  virtual void vectorHessianProduct(const ConstVectorRef &,
                                    const ConstVectorRef &,
                                    MatrixRef Hout) const {
    Hout.setZero();
  }
};
 
} // namespace nlp
} // namespace proxsuite
 
#ifdef PROXSUITE_NLP_ENABLE_TEMPLATE_INSTANTIATION
#include "proxsuite-nlp/function-base.txx"
#endif