Function.h

Go to the documentation of this file.

 
#pragma once
 
#include <tvm/internal/FirstOrderProvider.h>
#include <tvm/utils/internal/map.h>
 
#include <Eigen/Core>
 
#include <map>
 
namespace tvm
{
 
namespace function
{
 
namespace abstract
{
 
class TVM_DLLAPI Function : public tvm::internal::FirstOrderProvider
{
public:
  SET_OUTPUTS(Function, Velocity, NormalAcceleration, JDot)
 
  
  virtual const Eigen::VectorXd & velocity() const;
  virtual const Eigen::VectorXd & normalAcceleration() const;
  virtual MatrixConstRef JDot(const Variable & x) const;
 
protected:
  struct slice_jdot
  {
    using Type = MatrixRef;
    using ConstType = MatrixConstRef;
    static Type get(Eigen::MatrixXd & M, const Range & r) { return M.middleCols(r.start, r.dim); }
    static ConstType get(const Eigen::MatrixXd & M, const Range & r) { return M.middleCols(r.start, r.dim); }
  };
  Function(int m = 0);
 
  Function(Space image);
 
  void resizeCache() override;
  void resizeVelocityCache();
  void resizeNormalAccelerationCache();
  void resizeJDotCache();
 
  void addVariable_(VariablePtr v) override;
  void removeVariable_(VariablePtr v) override;
 
  // cache
  Eigen::VectorXd velocity_;
  Eigen::VectorXd normalAcceleration_;
  utils::internal::MapWithVariableAsKey<Eigen::MatrixXd, slice_jdot> JDot_;
 
private:
  // we retain the variables' derivatives shared_ptr to ensure the reference is never lost
  std::vector<VariablePtr> variablesDot_;
};
 
inline const Eigen::VectorXd & Function::velocity() const { return velocity_; }
 
inline const Eigen::VectorXd & Function::normalAcceleration() const { return normalAcceleration_; }
 
inline MatrixConstRef Function::JDot(const Variable & x) const
{ return JDot_.at(&x, tvm::utils::internal::with_sub{}); }
 
} // namespace abstract
 
} // namespace function
 
} // namespace tvm