tvm Namespace Reference

Namespaces
	constant
	constraint
	diagnostic
	event
	exception
	function
	geometry
	graph
	hint
	internal
	requirements
	robot
	scheme
	solver
	task_dynamics
	utils

Classes
class	Clock
class	ControlProblem
class	LinearConstraintWithRequirements
class	LinearizedControlProblem
class	Range
class	Robot
class	Space
class	Task
class	TaskWithRequirements
class	Variable
class	VariableVector

Typedefs
using	TaskWithRequirementsPtr = std::shared_ptr< TaskWithRequirements >
using	MatrixConstRef = Eigen::Ref< const Eigen::MatrixXd >
using	MatrixRef = Eigen::Ref< Eigen::MatrixXd >
using	VectorConstRef = Eigen::Ref< const Eigen::VectorXd >
using	VectorRef = Eigen::Ref< Eigen::VectorXd >
using	MatrixPtr = std::shared_ptr< Eigen::MatrixXd >
using	VectorPtr = std::shared_ptr< Eigen::VectorXd >
using	ConstraintPtr = std::shared_ptr< constraint::abstract::Constraint >
using	FunctionPtr = std::shared_ptr< function::abstract::Function >
using	LinearFunctionPtr = std::shared_ptr< function::abstract::LinearFunction >
using	LinearConstraintPtr = std::shared_ptr< constraint::abstract::LinearConstraint >
using	ClockPtr = std::shared_ptr< Clock >
using	RangePtr = std::shared_ptr< Range >
using	RobotPtr = std::shared_ptr< Robot >
using	SolvingRequirementsPtr = std::shared_ptr< requirements::SolvingRequirementsWithCallbacks >
using	TaskDynamicsPtr = std::shared_ptr< task_dynamics::abstract::TaskDynamicsImpl >
using	VariablePtr = std::shared_ptr< Variable >

Functions
template<typename Derived >
tvm::utils::LinearExpr< Derived >	operator* (const Eigen::MatrixBase< Derived > &matrix, const tvm::VariablePtr &v)
tvm::utils::LinearExpr< tvm::utils::internal::MinusIdentityType >	operator- (const tvm::VariablePtr &v)
tvm::utils::LinearExpr< tvm::utils::internal::MultIdentityType >	operator* (double s, const tvm::VariablePtr &v)
auto	operator+ (const tvm::VariablePtr &u, const tvm::VariablePtr &v)
template<typename AddType , typename tvm::internal::enable_for_templated_t< AddType, Eigen::MatrixBase, tvm::utils::LinearExpr, tvm::utils::AffineExpr > = 0>
auto	operator+ (const AddType &a, const tvm::VariablePtr &v)
template<typename AddType , typename tvm::internal::enable_for_templated_t< AddType, Eigen::MatrixBase, tvm::utils::LinearExpr, tvm::utils::AffineExpr > = 0>
auto	operator+ (const tvm::VariablePtr &v, const AddType &a)
auto	operator- (const tvm::VariablePtr &u, const tvm::VariablePtr &v)
template<typename SubType , typename tvm::internal::enable_for_templated_t< SubType, Eigen::MatrixBase, tvm::utils::LinearExpr, tvm::utils::AffineExpr > = 0>
auto	operator- (const SubType &a, const tvm::VariablePtr &v)
template<typename SubType , typename tvm::internal::enable_for_templated_t< SubType, Eigen::MatrixBase, tvm::utils::LinearExpr, tvm::utils::AffineExpr > = 0>
auto	operator- (const tvm::VariablePtr &v, const SubType &a)
VariablePtr TVM_DLLAPI	dot (VariablePtr var, int ndiff=1, bool autoName=false)
bool	operator== (const Variable &u, const Variable &v)
bool	operator!= (const Variable &u, const Variable &v)
VariableVector TVM_DLLAPI	dot (const VariableVector &vars, int ndiff=1)

Detailed Description

Copyright 2017-2020 CNRS-AIST JRL and CNRS-UM LIRMM

Copyright 2022 CNRS-AIST JRL and CNRS-UM LIRMM

Copyright 2017-2022 CNRS-AIST JRL and CNRS-UM LIRMM

Typedef Documentation

ClockPtr

using tvm::ClockPtr = typedef std::shared_ptr<Clock>

ConstraintPtr

using tvm::ConstraintPtr = typedef std::shared_ptr<constraint::abstract::Constraint>

FunctionPtr

using tvm::FunctionPtr = typedef std::shared_ptr<function::abstract::Function>

LinearConstraintPtr

using tvm::LinearConstraintPtr = typedef std::shared_ptr<constraint::abstract::LinearConstraint>

LinearFunctionPtr

using tvm::LinearFunctionPtr = typedef std::shared_ptr<function::abstract::LinearFunction>

MatrixConstRef

using tvm::MatrixConstRef = typedef Eigen::Ref<const Eigen::MatrixXd>

MatrixPtr

using tvm::MatrixPtr = typedef std::shared_ptr<Eigen::MatrixXd>

MatrixRef

using tvm::MatrixRef = typedef Eigen::Ref<Eigen::MatrixXd>

RangePtr

using tvm::RangePtr = typedef std::shared_ptr<Range>

RobotPtr

using tvm::RobotPtr = typedef std::shared_ptr<Robot>

SolvingRequirementsPtr

using tvm::SolvingRequirementsPtr = typedef std::shared_ptr<requirements::SolvingRequirementsWithCallbacks>

TaskDynamicsPtr

using tvm::TaskDynamicsPtr = typedef std::shared_ptr<task_dynamics::abstract::TaskDynamicsImpl>

TaskWithRequirementsPtr

using tvm::TaskWithRequirementsPtr = typedef std::shared_ptr<TaskWithRequirements>

VariablePtr

using tvm::VariablePtr = typedef std::shared_ptr<Variable>

VectorConstRef

using tvm::VectorConstRef = typedef Eigen::Ref<const Eigen::VectorXd>

VectorPtr

using tvm::VectorPtr = typedef std::shared_ptr<Eigen::VectorXd>

VectorRef

using tvm::VectorRef = typedef Eigen::Ref<Eigen::VectorXd>

Function Documentation

dot() [1/2]

VariableVector TVM_DLLAPI tvm::dot	(	const VariableVector &	vars,
		int	ndiff = 1
	)

Get the vector of ndiff-th time derivatives of the variables of the input vector.

Parameters

var	the variable to be derived
ndiff	the order of the derivation

Warning

This recreates a vector from scratch each time

dot() [2/2]

VariablePtr TVM_DLLAPI tvm::dot	(	VariablePtr	var,
		int	ndiff = 1,
		bool	autoName = false
	)

Get the ndiff-th time derivative of a variable

Parameters

var	the variable to be derived
ndiff	the order of the derivation
autoName	base the name on that of the supervariable of the primitive (if the variable was not already created with another name before).

operator!=()

bool tvm::operator!= ( const Variable &  u, const Variable &  v  )

inline

operator*() [1/2]

template<typename Derived >

tvm::utils::LinearExpr<Derived> tvm::operator* ( const Eigen::MatrixBase< Derived > &  matrix, const tvm::VariablePtr &  v  )

inline

Lin = M * x

operator*() [2/2]

tvm::utils::LinearExpr<tvm::utils::internal::MultIdentityType> tvm::operator* ( double  s, const tvm::VariablePtr &  v  )

inline

Lin = scalar * var

operator+() [1/3]

template<typename AddType , typename tvm::internal::enable_for_templated_t< AddType, Eigen::MatrixBase, tvm::utils::LinearExpr, tvm::utils::AffineExpr > = 0>

auto tvm::operator+ ( const AddType &  a, const tvm::VariablePtr &  v  )

inline

Aff = a + var

operator+() [2/3]

auto tvm::operator+ ( const tvm::VariablePtr &  u, const tvm::VariablePtr &  v  )

inline

Aff = var + var

operator+() [3/3]

template<typename AddType , typename tvm::internal::enable_for_templated_t< AddType, Eigen::MatrixBase, tvm::utils::LinearExpr, tvm::utils::AffineExpr > = 0>

auto tvm::operator+ ( const tvm::VariablePtr &  v, const AddType &  a  )

inline

Aff = var + a

operator-() [1/4]

template<typename SubType , typename tvm::internal::enable_for_templated_t< SubType, Eigen::MatrixBase, tvm::utils::LinearExpr, tvm::utils::AffineExpr > = 0>

auto tvm::operator- ( const SubType &  a, const tvm::VariablePtr &  v  )

inline

Aff = vec - var

operator-() [2/4]

auto tvm::operator- ( const tvm::VariablePtr &  u, const tvm::VariablePtr &  v  )

inline

Aff = var - var

operator-() [3/4]

tvm::utils::LinearExpr<tvm::utils::internal::MinusIdentityType> tvm::operator- ( const tvm::VariablePtr &  v )

inline

Lin = -var

operator-() [4/4]

template<typename SubType , typename tvm::internal::enable_for_templated_t< SubType, Eigen::MatrixBase, tvm::utils::LinearExpr, tvm::utils::AffineExpr > = 0>

auto tvm::operator- ( const tvm::VariablePtr &  v, const SubType &  a  )

inline

Aff = var - vec

operator==()

bool tvm::operator== ( const Variable &  u, const Variable &  v  )

inline