KDL Namespace Reference

Classes
class	ArticulatedBodyInertia
	6D Inertia of a articulated body More...
class	Chain
	This class encapsulates a serial kinematic interconnection structure. It is built out of segments. More...
class	ChainDynParam
class	ChainExternalWrenchEstimator
	First-order momentum observer for the estimation of external wrenches applied on the robot's end-effector. More...
class	ChainFdSolver
	This abstract class encapsulates the inverse dynamics solver for a KDL::Chain. More...
class	ChainFdSolver_RNE
	Recursive newton euler forward dynamics solver. More...
class	ChainFkSolverPos
	This abstract class encapsulates a solver for the forward position kinematics for a KDL::Chain. More...
class	ChainFkSolverVel
	This abstract class encapsulates a solver for the forward velocity kinematics for a KDL::Chain. More...
class	ChainFkSolverAcc
	This abstract class encapsulates a solver for the forward acceleration kinematics for a KDL::Chain. More...
class	ChainFkSolverPos_recursive
class	ChainFkSolverVel_recursive
class	ChainHdSolver_Vereshchagin
	Abstract: Acceleration constrained hybrid dynamics calculations for a chain, based on Vereshchagin 1989. This class creates an instance of the hybrid dynamics solver. The solver analytically calculates the joint space constraint torques and acceleration in a chain when a constraint force(s) is applied to the chain's end-effector (task space / cartesian space). In the robotics literature, this algorithm is also known under the following names: Acceleration Constrained Hybrid Dynamics (ACHD) and Popov-Vereshchagin solver. More...
class	ChainIdSolver
	This abstract class encapsulates the inverse dynamics solver for a KDL::Chain. More...
class	ChainIdSolver_RNE
	Recursive newton euler inverse dynamics solver. More...
class	ChainIdSolver_Vereshchagin
class	ChainIkSolverPos
	This abstract class encapsulates the inverse position solver for a KDL::Chain. More...
class	ChainIkSolverVel
	This abstract class encapsulates the inverse velocity solver for a KDL::Chain. More...
class	ChainIkSolverAcc
	This abstract class encapsulates the inverse acceleration solver for a KDL::Chain. More...
class	ChainIkSolverPos_LMA
	Solver for the inverse position kinematics that uses Levenberg-Marquardt. More...
class	ChainIkSolverPos_NR
class	ChainIkSolverPos_NR_JL
class	ChainIkSolverVel_pinv
class	ChainIkSolverVel_pinv_givens
class	ChainIkSolverVel_pinv_nso
class	ChainIkSolverVel_wdls
class	ChainJntToJacDotSolver
	Computes the Jacobian time derivative (Jdot) by calculating the partial derivatives regarding to a joint angle, in the Hybrid, Body-fixed or Inertial representation. More...
class	ChainJntToJacSolver
	Class to calculate the jacobian of a general KDL::Chain, it is used by other solvers. More...
class	VectorAcc
class	RotationAcc
class	FrameAcc
class	TwistAcc
class	Vector
	A concrete implementation of a 3 dimensional vector class. More...
class	Rotation
	represents rotations in 3 dimensional space. More...
class	Frame
	represents a frame transformation in 3D space (rotation + translation) More...
class	Twist
	represents both translational and rotational velocities. More...
class	Wrench
	represents both translational and rotational acceleration. More...
class	Vector2
	2D version of Vector More...
class	Rotation2
	A 2D Rotation class, for conventions see Rotation. For further documentation of the methods see Rotation class. More...
class	Frame2
	A 2D frame class, for further documentation see the Frames class for methods with unchanged semantics. More...
class	VectorVel
class	RotationVel
class	FrameVel
class	TwistVel
class	Jacobian
class	JntArray
class	JntArrayAcc
class	JntArrayVel
class	Joint
	This class encapsulates a simple joint, that is with one parameterized degree of freedom and with scalar dynamic properties. More...
class	Path
class	Path_Circle
class	Path_Composite
class	Path_Cyclic_Closed
class	Path_Line
class	Path_Point
class	Path_RoundedComposite
class	RigidBodyInertia
	6D Inertia of a rigid body More...
class	RotationalInterpolation
class	RotationalInterpolation_SingleAxis
class	RotationalInertia
class	Segment
	This class encapsulates a simple segment, that is a "rigid body" (i.e., a frame and a rigid body inertia) with a joint and with "handles", root and tip to connect to other segments. More...
class	SolverI
class	Stiffness
class	Trajectory
class	Trajectory_Composite
class	Trajectory_Segment
class	Trajectory_Stationary
class	TreeElement
class	Tree
	This class encapsulates a tree kinematic interconnection structure. It is built out of segments. More...
class	TreeFkSolverPos
	This abstract class encapsulates a solver for the forward position kinematics for a KDL::Tree. More...
class	TreeFkSolverPos_recursive
class	TreeIdSolver
	This abstract class encapsulates the inverse dynamics solver for a KDL::Tree. More...
class	TreeIdSolver_RNE
	Recursive newton euler inverse dynamics solver for kinematic trees. More...
class	TreeIkSolverPos
	This abstract class encapsulates the inverse position solver for a KDL::Chain. More...
class	TreeIkSolverVel
	This abstract class encapsulates the inverse velocity solver for a KDL::Tree. More...
class	TreeIkSolverPos_NR_JL
class	TreeIkSolverPos_Online
class	TreeIkSolverVel_wdls
class	TreeJntToJacSolver
class	Error
class	Error_IO
class	Error_BasicIO
class	Error_BasicIO_File
class	Error_BasicIO_Exp_Delim
class	Error_BasicIO_Not_A_Space
class	Error_BasicIO_Unexpected
class	Error_BasicIO_ToBig
class	Error_BasicIO_Not_Opened
class	Error_FrameIO
class	Error_Frame_Vector_Unexpected_id
class	Error_Frame_Frame_Unexpected_id
class	Error_Frame_Rotation_Unexpected_id
class	Error_ChainIO
class	Error_Chain_Unexpected_id
class	Error_RedundancyIO
	Error_Redundancy indicates an error that occurred during solving for redundancy. More...
class	Error_Redundancy_Illegal_Resolutiontype
class	Error_Redundancy
class	Error_Redundancy_Unavoidable
class	Error_Redundancy_Low_Manip
class	Error_MotionIO
class	Error_MotionIO_Unexpected_MotProf
class	Error_MotionIO_Unexpected_Traj
class	Error_MotionPlanning
class	Error_MotionPlanning_Circle_ToSmall
class	Error_MotionPlanning_Circle_No_Plane
class	Error_MotionPlanning_Incompatible
class	Error_MotionPlanning_Not_Feasible
class	Error_MotionPlanning_Not_Applicable
class	Error_Integrator
	Abstract subclass of all errors that can be thrown by Adaptive_Integrator. More...
class	Error_Stepsize_Underflow
	Error_Stepsize_Underflow is thrown if the stepsize becomes to small. More...
class	Error_To_Many_Steps
class	Error_Stepsize_To_Small
	Error_Stepsize_To_Small is thrown if the stepsize becomes to small. More...
class	Error_Criterium
class	Error_Criterium_Unexpected_id
class	Error_Limits
class	Error_Limits_Unexpected_id
class	Error_Not_Implemented
class	Rall1d
class	Rall2d
class	scoped_ptr
class	SVD_HH
class	TI
class	TI< double >
class	TI< int >
class	VelocityProfile
class	VelocityProfile_Dirac
class	VelocityProfile_Rectangular
class	VelocityProfile_Spline
	A spline VelocityProfile trajectory interpolation. More...
class	VelocityProfile_Trap
class	VelocityProfile_TrapHalf

Typedefs
typedef std::vector< Wrench >	Wrenches
typedef Rall2d< double, double, double >	doubleAcc
typedef Rall1d< double >	doubleVel
typedef std::map< std::string, TreeElement >	SegmentMap
typedef TreeElement	TreeElementType
typedef std::map< std::string, Wrench >	WrenchMap
typedef std::map< std::string, Twist >	Twists
typedef std::map< std::string, Jacobian >	Jacobians
typedef std::map< std::string, Frame >	Frames

Functions
ArticulatedBodyInertia	operator* (double a, const ArticulatedBodyInertia &I)
ArticulatedBodyInertia	operator+ (const ArticulatedBodyInertia &Ia, const ArticulatedBodyInertia &Ib)
ArticulatedBodyInertia	operator+ (const ArticulatedBodyInertia &Ia, const RigidBodyInertia &Ib)
ArticulatedBodyInertia	operator- (const ArticulatedBodyInertia &Ia, const ArticulatedBodyInertia &Ib)
ArticulatedBodyInertia	operator- (const ArticulatedBodyInertia &Ia, const RigidBodyInertia &Ib)
Wrench	operator* (const ArticulatedBodyInertia &I, const Twist &t)
ArticulatedBodyInertia	operator* (const Frame &T, const ArticulatedBodyInertia &I)
ArticulatedBodyInertia	operator* (const Rotation &R, const ArticulatedBodyInertia &I)
IMETHOD bool	Equal (const FrameAcc &r1, const FrameAcc &r2, double eps=epsilon)
IMETHOD bool	Equal (const Frame &r1, const FrameAcc &r2, double eps=epsilon)
IMETHOD bool	Equal (const FrameAcc &r1, const Frame &r2, double eps=epsilon)
IMETHOD bool	Equal (const RotationAcc &r1, const RotationAcc &r2, double eps=epsilon)
IMETHOD bool	Equal (const Rotation &r1, const RotationAcc &r2, double eps=epsilon)
IMETHOD bool	Equal (const RotationAcc &r1, const Rotation &r2, double eps=epsilon)
IMETHOD bool	Equal (const TwistAcc &a, const TwistAcc &b, double eps=epsilon)
IMETHOD bool	Equal (const Twist &a, const TwistAcc &b, double eps=epsilon)
IMETHOD bool	Equal (const TwistAcc &a, const Twist &b, double eps=epsilon)
IMETHOD bool	Equal (const VectorAcc &r1, const VectorAcc &r2, double eps=epsilon)
IMETHOD bool	Equal (const Vector &r1, const VectorAcc &r2, double eps=epsilon)
IMETHOD bool	Equal (const VectorAcc &r1, const Vector &r2, double eps=epsilon)
VectorAcc	operator+ (const VectorAcc &r1, const VectorAcc &r2)
VectorAcc	operator- (const VectorAcc &r1, const VectorAcc &r2)
VectorAcc	operator+ (const Vector &r1, const VectorAcc &r2)
VectorAcc	operator- (const Vector &r1, const VectorAcc &r2)
VectorAcc	operator+ (const VectorAcc &r1, const Vector &r2)
VectorAcc	operator- (const VectorAcc &r1, const Vector &r2)
VectorAcc	operator- (const VectorAcc &r)
VectorAcc	operator* (const VectorAcc &r1, const VectorAcc &r2)
VectorAcc	operator* (const VectorAcc &r1, const Vector &r2)
VectorAcc	operator* (const Vector &r1, const VectorAcc &r2)
VectorAcc	operator* (double r1, const VectorAcc &r2)
VectorAcc	operator* (const VectorAcc &r1, double r2)
VectorAcc	operator* (const doubleAcc &r1, const VectorAcc &r2)
VectorAcc	operator* (const VectorAcc &r2, const doubleAcc &r1)
doubleAcc	dot (const VectorAcc &lhs, const VectorAcc &rhs)
doubleAcc	dot (const VectorAcc &lhs, const Vector &rhs)
doubleAcc	dot (const Vector &lhs, const VectorAcc &rhs)
VectorAcc	operator/ (const VectorAcc &r1, double r2)
VectorAcc	operator/ (const VectorAcc &r2, const doubleAcc &r1)
RotationAcc	operator* (const RotationAcc &r1, const RotationAcc &r2)
RotationAcc	operator* (const Rotation &r1, const RotationAcc &r2)
RotationAcc	operator* (const RotationAcc &r1, const Rotation &r2)
VectorAcc	operator* (const Rotation &R, const VectorAcc &x)
FrameAcc	operator* (const FrameAcc &lhs, const FrameAcc &rhs)
FrameAcc	operator* (const FrameAcc &lhs, const Frame &rhs)
FrameAcc	operator* (const Frame &lhs, const FrameAcc &rhs)
TwistAcc	operator* (const TwistAcc &lhs, double rhs)
TwistAcc	operator* (double lhs, const TwistAcc &rhs)
TwistAcc	operator/ (const TwistAcc &lhs, double rhs)
TwistAcc	operator* (const TwistAcc &lhs, const doubleAcc &rhs)
TwistAcc	operator* (const doubleAcc &lhs, const TwistAcc &rhs)
TwistAcc	operator/ (const TwistAcc &lhs, const doubleAcc &rhs)
TwistAcc	operator+ (const TwistAcc &lhs, const TwistAcc &rhs)
TwistAcc	operator- (const TwistAcc &lhs, const TwistAcc &rhs)
TwistAcc	operator- (const TwistAcc &arg)
std::ostream &	operator<< (std::ostream &os, const VectorAcc &r)
std::ostream &	operator<< (std::ostream &os, const RotationAcc &r)
std::ostream &	operator<< (std::ostream &os, const FrameAcc &r)
std::ostream &	operator<< (std::ostream &os, const TwistAcc &r)
bool	Equal (const Vector &a, const Vector &b, double eps=epsilon)
bool	Equal (const Frame &a, const Frame &b, double eps=epsilon)
bool	Equal (const Twist &a, const Twist &b, double eps=epsilon)
bool	Equal (const Wrench &a, const Wrench &b, double eps=epsilon)
bool	Equal (const Vector2 &a, const Vector2 &b, double eps=epsilon)
bool	Equal (const Rotation2 &a, const Rotation2 &b, double eps=epsilon)
bool	Equal (const Frame2 &a, const Frame2 &b, double eps=epsilon)
bool	operator== (const Rotation &a, const Rotation &b)
bool	Equal (const Rotation &a, const Rotation &b, double eps=epsilon)
IMETHOD Vector	diff (const Vector &p_w_a, const Vector &p_w_b, double dt=1)
IMETHOD Vector	diff (const Rotation &R_a_b1, const Rotation &R_a_b2, double dt=1)
IMETHOD Twist	diff (const Frame &F_a_b1, const Frame &F_a_b2, double dt=1)
IMETHOD Twist	diff (const Twist &a, const Twist &b, double dt=1)
IMETHOD Wrench	diff (const Wrench &W_a_p1, const Wrench &W_a_p2, double dt=1)
IMETHOD Vector	addDelta (const Vector &p_w_a, const Vector &p_w_da, double dt=1)
	adds vector da to vector a. see also the corresponding diff() routine.
IMETHOD Rotation	addDelta (const Rotation &R_w_a, const Vector &da_w, double dt=1)
IMETHOD Frame	addDelta (const Frame &F_w_a, const Twist &da_w, double dt=1)
IMETHOD Twist	addDelta (const Twist &a, const Twist &da, double dt=1)
	adds the twist da to the twist a. see also the corresponding diff() routine.
IMETHOD Wrench	addDelta (const Wrench &a, const Wrench &da, double dt=1)
	adds the wrench da to the wrench w. see also the corresponding diff() routine. see also the corresponding diff() routine.
IMETHOD Vector	operator+ (const Vector &lhs, const Vector &rhs)
IMETHOD Vector	operator- (const Vector &lhs, const Vector &rhs)
Vector	operator* (const Vector &lhs, double rhs)
Vector	operator* (double lhs, const Vector &rhs)
Vector	operator/ (const Vector &lhs, double rhs)
Vector	operator* (const Vector &lhs, const Vector &rhs)
Wrench	operator* (const Wrench &lhs, double rhs)
Wrench	operator* (double lhs, const Wrench &rhs)
Wrench	operator/ (const Wrench &lhs, double rhs)
Wrench	operator+ (const Wrench &lhs, const Wrench &rhs)
Wrench	operator- (const Wrench &lhs, const Wrench &rhs)
Wrench	operator- (const Wrench &arg)
Twist	operator* (const Twist &lhs, double rhs)
Twist	operator* (double lhs, const Twist &rhs)
Twist	operator/ (const Twist &lhs, double rhs)
Twist	operator+ (const Twist &lhs, const Twist &rhs)
Twist	operator- (const Twist &lhs, const Twist &rhs)
Twist	operator- (const Twist &arg)
Twist	operator* (const Twist &lhs, const Twist &rhs)
Wrench	operator* (const Twist &lhs, const Wrench &rhs)
Frame	operator* (const Frame &lhs, const Frame &rhs)
Vector	operator- (const Vector &arg)
IMETHOD Vector2	operator+ (const Vector2 &lhs, const Vector2 &rhs)
IMETHOD Vector2	operator- (const Vector2 &lhs, const Vector2 &rhs)
IMETHOD Vector2	operator* (const Vector2 &lhs, double rhs)
IMETHOD Vector2	operator* (double lhs, const Vector2 &rhs)
IMETHOD Vector2	operator/ (const Vector2 &lhs, double rhs)
IMETHOD Vector2	operator- (const Vector2 &arg)
IMETHOD Rotation2	operator* (const Rotation2 &lhs, const Rotation2 &rhs)
IMETHOD Frame2	operator* (const Frame2 &lhs, const Frame2 &rhs)
IMETHOD double	dot (const Vector &lhs, const Vector &rhs)
IMETHOD double	dot (const Twist &lhs, const Wrench &rhs)
IMETHOD double	dot (const Wrench &rhs, const Twist &lhs)
IMETHOD void	SetToZero (Vector &v)
IMETHOD void	SetToZero (Twist &v)
IMETHOD void	SetToZero (Wrench &v)
IMETHOD void	SetToZero (Vector2 &v)
IMETHOD Rotation	Rot (const Vector &axis_a_b)
IMETHOD void	random (Vector &a)
	addDelta operator for displacement rotational velocity.
IMETHOD void	random (Twist &a)
IMETHOD void	random (Wrench &a)
IMETHOD void	random (Rotation &R)
IMETHOD void	random (Frame &F)
IMETHOD void	posrandom (Vector &a)
IMETHOD void	posrandom (Twist &a)
IMETHOD void	posrandom (Wrench &a)
IMETHOD void	posrandom (Rotation &R)
IMETHOD void	posrandom (Frame &F)
IMETHOD bool	operator== (const Frame &a, const Frame &b)
IMETHOD bool	operator!= (const Frame &a, const Frame &b)
IMETHOD bool	operator== (const Vector &a, const Vector &b)
IMETHOD bool	operator!= (const Vector &a, const Vector &b)
IMETHOD bool	operator== (const Twist &a, const Twist &b)
IMETHOD bool	operator!= (const Twist &a, const Twist &b)
IMETHOD bool	operator== (const Wrench &a, const Wrench &b)
IMETHOD bool	operator!= (const Wrench &a, const Wrench &b)
IMETHOD bool	operator!= (const Rotation &a, const Rotation &b)
IMETHOD bool	operator== (const Vector2 &a, const Vector2 &b)
IMETHOD bool	operator!= (const Vector2 &a, const Vector2 &b)
std::ostream &	operator<< (std::ostream &os, const Vector &v)
std::ostream &	operator<< (std::ostream &os, const Rotation &R)
std::ostream &	operator<< (std::ostream &os, const Frame &T)
std::ostream &	operator<< (std::ostream &os, const Twist &T)
std::ostream &	operator<< (std::ostream &os, const Wrench &T)
std::ostream &	operator<< (std::ostream &os, const Vector2 &v)
std::ostream &	operator<< (std::ostream &os, const Rotation2 &R)
std::ostream &	operator<< (std::ostream &os, const Frame2 &T)
std::istream &	operator>> (std::istream &is, Vector &v)
std::istream &	operator>> (std::istream &is, Rotation &R)
std::istream &	operator>> (std::istream &is, Frame &T)
std::istream &	operator>> (std::istream &os, Twist &T)
std::istream &	operator>> (std::istream &os, Wrench &T)
std::istream &	operator>> (std::istream &is, Vector2 &v)
std::istream &	operator>> (std::istream &is, Rotation2 &R)
std::istream &	operator>> (std::istream &is, Frame2 &T)
IMETHOD doubleVel	diff (const doubleVel &a, const doubleVel &b, double dt=1.0)
IMETHOD doubleVel	addDelta (const doubleVel &a, const doubleVel &da, double dt=1.0)
IMETHOD void	random (doubleVel &F)
IMETHOD void	posrandom (doubleVel &F)
IMETHOD bool	Equal (const VectorVel &r1, const VectorVel &r2, double eps=epsilon)
IMETHOD bool	Equal (const Vector &r1, const VectorVel &r2, double eps=epsilon)
IMETHOD bool	Equal (const VectorVel &r1, const Vector &r2, double eps=epsilon)
IMETHOD bool	Equal (const RotationVel &r1, const RotationVel &r2, double eps=epsilon)
IMETHOD bool	Equal (const Rotation &r1, const RotationVel &r2, double eps=epsilon)
IMETHOD bool	Equal (const RotationVel &r1, const Rotation &r2, double eps=epsilon)
IMETHOD bool	Equal (const FrameVel &r1, const FrameVel &r2, double eps=epsilon)
IMETHOD bool	Equal (const Frame &r1, const FrameVel &r2, double eps=epsilon)
IMETHOD bool	Equal (const FrameVel &r1, const Frame &r2, double eps=epsilon)
IMETHOD bool	Equal (const TwistVel &a, const TwistVel &b, double eps=epsilon)
IMETHOD bool	Equal (const Twist &a, const TwistVel &b, double eps=epsilon)
IMETHOD bool	Equal (const TwistVel &a, const Twist &b, double eps=epsilon)
IMETHOD VectorVel	diff (const VectorVel &a, const VectorVel &b, double dt=1.0)
IMETHOD VectorVel	addDelta (const VectorVel &a, const VectorVel &da, double dt=1.0)
IMETHOD VectorVel	diff (const RotationVel &a, const RotationVel &b, double dt=1.0)
IMETHOD RotationVel	addDelta (const RotationVel &a, const VectorVel &da, double dt=1.0)
IMETHOD TwistVel	diff (const FrameVel &a, const FrameVel &b, double dt=1.0)
IMETHOD FrameVel	addDelta (const FrameVel &a, const TwistVel &da, double dt=1.0)
IMETHOD void	random (VectorVel &a)
IMETHOD void	random (TwistVel &a)
IMETHOD void	random (RotationVel &R)
IMETHOD void	random (FrameVel &F)
IMETHOD void	posrandom (VectorVel &a)
IMETHOD void	posrandom (TwistVel &a)
IMETHOD void	posrandom (RotationVel &R)
IMETHOD void	posrandom (FrameVel &F)
FrameVel	operator* (const FrameVel &lhs, const FrameVel &rhs)
FrameVel	operator* (const FrameVel &lhs, const Frame &rhs)
FrameVel	operator* (const Frame &lhs, const FrameVel &rhs)
bool	operator== (const FrameVel &r1, const FrameVel &r2)
bool	operator!= (const FrameVel &r1, const FrameVel &r2)
bool	operator== (const Frame &r1, const FrameVel &r2)
bool	operator!= (const Frame &r1, const FrameVel &r2)
bool	operator== (const FrameVel &r1, const Frame &r2)
bool	operator!= (const FrameVel &r1, const Frame &r2)
RotationVel	operator* (const RotationVel &r1, const RotationVel &r2)
RotationVel	operator* (const Rotation &r1, const RotationVel &r2)
RotationVel	operator* (const RotationVel &r1, const Rotation &r2)
VectorVel	operator+ (const VectorVel &r1, const VectorVel &r2)
VectorVel	operator- (const VectorVel &r1, const VectorVel &r2)
VectorVel	operator+ (const VectorVel &r1, const Vector &r2)
VectorVel	operator- (const VectorVel &r1, const Vector &r2)
VectorVel	operator+ (const Vector &r1, const VectorVel &r2)
VectorVel	operator- (const Vector &r1, const VectorVel &r2)
VectorVel	operator- (const VectorVel &r)
void	SetToZero (VectorVel &v)
VectorVel	operator* (const VectorVel &r1, const VectorVel &r2)
VectorVel	operator* (const VectorVel &r1, const Vector &r2)
VectorVel	operator* (const Vector &r1, const VectorVel &r2)
VectorVel	operator* (double r1, const VectorVel &r2)
VectorVel	operator* (const VectorVel &r1, double r2)
VectorVel	operator* (const doubleVel &r1, const VectorVel &r2)
VectorVel	operator* (const VectorVel &r2, const doubleVel &r1)
VectorVel	operator/ (const VectorVel &r1, double r2)
VectorVel	operator/ (const VectorVel &r2, const doubleVel &r1)
VectorVel	operator* (const Rotation &R, const VectorVel &x)
bool	operator== (const VectorVel &r1, const VectorVel &r2)
bool	operator!= (const VectorVel &r1, const VectorVel &r2)
bool	operator== (const Vector &r1, const VectorVel &r2)
bool	operator!= (const Vector &r1, const VectorVel &r2)
bool	operator== (const VectorVel &r1, const Vector &r2)
bool	operator!= (const VectorVel &r1, const Vector &r2)
bool	operator== (const RotationVel &r1, const RotationVel &r2)
bool	operator!= (const RotationVel &r1, const RotationVel &r2)
bool	operator== (const Rotation &r1, const RotationVel &r2)
bool	operator!= (const Rotation &r1, const RotationVel &r2)
bool	operator== (const RotationVel &r1, const Rotation &r2)
bool	operator!= (const RotationVel &r1, const Rotation &r2)
bool	operator== (const TwistVel &a, const TwistVel &b)
bool	operator!= (const TwistVel &a, const TwistVel &b)
bool	operator== (const Twist &a, const TwistVel &b)
bool	operator!= (const Twist &r1, const TwistVel &r2)
bool	operator== (const TwistVel &r1, const Twist &r2)
bool	operator!= (const TwistVel &r1, const Twist &r2)
IMETHOD doubleVel	dot (const VectorVel &lhs, const VectorVel &rhs)
IMETHOD doubleVel	dot (const VectorVel &lhs, const Vector &rhs)
IMETHOD doubleVel	dot (const Vector &lhs, const VectorVel &rhs)
TwistVel	operator* (const TwistVel &lhs, double rhs)
TwistVel	operator* (double lhs, const TwistVel &rhs)
TwistVel	operator/ (const TwistVel &lhs, double rhs)
TwistVel	operator* (const TwistVel &lhs, const doubleVel &rhs)
TwistVel	operator* (const doubleVel &lhs, const TwistVel &rhs)
TwistVel	operator/ (const TwistVel &lhs, const doubleVel &rhs)
TwistVel	operator+ (const TwistVel &lhs, const TwistVel &rhs)
TwistVel	operator- (const TwistVel &lhs, const TwistVel &rhs)
TwistVel	operator- (const TwistVel &arg)
void	SetToZero (TwistVel &v)
std::ostream &	operator<< (std::ostream &os, const VectorVel &r)
std::ostream &	operator<< (std::ostream &os, const RotationVel &r)
std::ostream &	operator<< (std::ostream &os, const FrameVel &r)
std::ostream &	operator<< (std::ostream &os, const TwistVel &r)
bool	Equal (const Jacobian &a, const Jacobian &b, double eps=epsilon)
void	SetToZero (Jacobian &jac)
bool	changeRefPoint (const Jacobian &src1, const Vector &base_AB, Jacobian &dest)
bool	changeBase (const Jacobian &src1, const Rotation &rot, Jacobian &dest)
bool	changeRefFrame (const Jacobian &src1, const Frame &frame, Jacobian &dest)
bool	operator== (const JntArray &src1, const JntArray &src2)
void	Add (const JntArray &src1, const JntArray &src2, JntArray &dest)
void	Subtract (const JntArray &src1, const JntArray &src2, JntArray &dest)
void	Multiply (const JntArray &src, const double &factor, JntArray &dest)
void	Divide (const JntArray &src, const double &factor, JntArray &dest)
void	MultiplyJacobian (const Jacobian &jac, const JntArray &src, Twist &dest)
void	SetToZero (JntArray &array)
bool	Equal (const JntArray &src1, const JntArray &src2, double eps=epsilon)
bool	Equal (const JntArrayAcc &src1, const JntArrayAcc &src2, double eps=epsilon)
void	Add (const JntArrayAcc &src1, const JntArrayAcc &src2, JntArrayAcc &dest)
void	Add (const JntArrayAcc &src1, const JntArrayVel &src2, JntArrayAcc &dest)
void	Add (const JntArrayAcc &src1, const JntArray &src2, JntArrayAcc &dest)
void	Subtract (const JntArrayAcc &src1, const JntArrayAcc &src2, JntArrayAcc &dest)
void	Subtract (const JntArrayAcc &src1, const JntArrayVel &src2, JntArrayAcc &dest)
void	Subtract (const JntArrayAcc &src1, const JntArray &src2, JntArrayAcc &dest)
void	Multiply (const JntArrayAcc &src, const double &factor, JntArrayAcc &dest)
void	Multiply (const JntArrayAcc &src, const doubleVel &factor, JntArrayAcc &dest)
void	Multiply (const JntArrayAcc &src, const doubleAcc &factor, JntArrayAcc &dest)
void	Divide (const JntArrayAcc &src, const double &factor, JntArrayAcc &dest)
void	Divide (const JntArrayAcc &src, const doubleVel &factor, JntArrayAcc &dest)
void	Divide (const JntArrayAcc &src, const doubleAcc &factor, JntArrayAcc &dest)
void	SetToZero (JntArrayAcc &array)
bool	Equal (const JntArrayVel &src1, const JntArrayVel &src2, double eps=epsilon)
void	Add (const JntArrayVel &src1, const JntArrayVel &src2, JntArrayVel &dest)
void	Add (const JntArrayVel &src1, const JntArray &src2, JntArrayVel &dest)
void	Subtract (const JntArrayVel &src1, const JntArrayVel &src2, JntArrayVel &dest)
void	Subtract (const JntArrayVel &src1, const JntArray &src2, JntArrayVel &dest)
void	Multiply (const JntArrayVel &src, const double &factor, JntArrayVel &dest)
void	Multiply (const JntArrayVel &src, const doubleVel &factor, JntArrayVel &dest)
void	Divide (const JntArrayVel &src, const double &factor, JntArrayVel &dest)
void	Divide (const JntArrayVel &src, const doubleVel &factor, JntArrayVel &dest)
void	SetToZero (JntArrayVel &array)
std::ostream &	operator<< (std::ostream &os, const Joint &joint)
std::istream &	operator>> (std::istream &is, Joint &joint)
std::ostream &	operator<< (std::ostream &os, const Segment &segment)
std::istream &	operator>> (std::istream &is, Segment &segment)
std::ostream &	operator<< (std::ostream &os, const Chain &chain)
std::istream &	operator>> (std::istream &is, Chain &chain)
std::ostream &	operator<< (std::ostream &os, const Tree &tree)
std::istream &	operator>> (std::istream &is, Tree &tree)
std::ostream &	operator<< (std::ostream &os, SegmentMap::const_iterator it)
std::ostream &	operator<< (std::ostream &os, const JntArray &array)
std::istream &	operator>> (std::istream &is, JntArray &array)
std::ostream &	operator<< (std::ostream &os, const Jacobian &jac)
std::istream &	operator>> (std::istream &is, Jacobian &jac)
std::ostream &	operator<< (std::ostream &os, const JntSpaceInertiaMatrix &jntspaceinertiamatrix)
std::istream &	operator>> (std::istream &is, JntSpaceInertiaMatrix &jntspaceinertiamatrix)
std::string	tree2str (const Tree &tree, const std::string &separator=" ", const std::string &preamble="")
std::string	tree2str (const SegmentMap::const_iterator it, const std::string &separator=" ", const std::string &preamble="", unsigned int level=0)
RigidBodyInertia	operator* (double a, const RigidBodyInertia &I)
RigidBodyInertia	operator+ (const RigidBodyInertia &Ia, const RigidBodyInertia &Ib)
Wrench	operator* (const RigidBodyInertia &I, const Twist &t)
RigidBodyInertia	operator* (const Frame &T, const RigidBodyInertia &I)
RigidBodyInertia	operator* (const Rotation &R, const RigidBodyInertia &I)
RotationalInertia	operator* (double a, const RotationalInertia &I)
RotationalInertia	operator+ (const RotationalInertia &Ia, const RotationalInertia &Ib)
Wrench	operator* (const Stiffness &s, const Twist &t)
Stiffness	operator+ (const Stiffness &s1, const Stiffness &s2)
void	posrandom (Stiffness &F)
void	random (Stiffness &F)
void	IOTrace (const std::string &description)
void	IOTracePop ()
	pops a description of the IO-stack
void	IOTraceOutput (std::ostream &os)
	outputs the IO-stack to a stream to provide a better errormessage.
void	IOTracePopStr (char *buffer, int size)
template<class T>
void	hash_combine (std::size_t &seed, const T &v)
	Combine hash of object v to the seed.
int	ldl_solver_eigen (const Eigen::MatrixXd &A, const Eigen::VectorXd &v, Eigen::MatrixXd &L, Eigen::VectorXd &D, Eigen::VectorXd &vtmp, Eigen::VectorXd &q)
	Solves the system of equations Aq = v for q via LDL decomposition, where A is a square positive definite matrix.
template<class T, class V, class S>
INLINE Rall1d< T, V, S >	operator/ (const Rall1d< T, V, S > &lhs, const Rall1d< T, V, S > &rhs)
template<class T, class V, class S>
INLINE Rall1d< T, V, S >	operator* (const Rall1d< T, V, S > &lhs, const Rall1d< T, V, S > &rhs)
template<class T, class V, class S>
INLINE Rall1d< T, V, S >	operator+ (const Rall1d< T, V, S > &lhs, const Rall1d< T, V, S > &rhs)
template<class T, class V, class S>
INLINE Rall1d< T, V, S >	operator- (const Rall1d< T, V, S > &lhs, const Rall1d< T, V, S > &rhs)
template<class T, class V, class S>
INLINE Rall1d< T, V, S >	operator- (const Rall1d< T, V, S > &arg)
template<class T, class V, class S>
INLINE Rall1d< T, V, S >	operator* (S s, const Rall1d< T, V, S > &v)
template<class T, class V, class S>
INLINE Rall1d< T, V, S >	operator* (const Rall1d< T, V, S > &v, S s)
template<class T, class V, class S>
INLINE Rall1d< T, V, S >	operator+ (S s, const Rall1d< T, V, S > &v)
template<class T, class V, class S>
INLINE Rall1d< T, V, S >	operator+ (const Rall1d< T, V, S > &v, S s)
template<class T, class V, class S>
INLINE Rall1d< T, V, S >	operator- (S s, const Rall1d< T, V, S > &v)
template<class T, class V, class S>
INLINE Rall1d< T, V, S >	operator- (const Rall1d< T, V, S > &v, S s)
template<class T, class V, class S>
INLINE Rall1d< T, V, S >	operator/ (S s, const Rall1d< T, V, S > &v)
template<class T, class V, class S>
INLINE Rall1d< T, V, S >	operator/ (const Rall1d< T, V, S > &v, S s)
template<class T, class V, class S>
INLINE Rall1d< T, V, S >	exp (const Rall1d< T, V, S > &arg)
template<class T, class V, class S>
INLINE Rall1d< T, V, S >	log (const Rall1d< T, V, S > &arg)
template<class T, class V, class S>
INLINE Rall1d< T, V, S >	sin (const Rall1d< T, V, S > &arg)
template<class T, class V, class S>
INLINE Rall1d< T, V, S >	cos (const Rall1d< T, V, S > &arg)
template<class T, class V, class S>
INLINE Rall1d< T, V, S >	tan (const Rall1d< T, V, S > &arg)
template<class T, class V, class S>
INLINE Rall1d< T, V, S >	sinh (const Rall1d< T, V, S > &arg)
template<class T, class V, class S>
INLINE Rall1d< T, V, S >	cosh (const Rall1d< T, V, S > &arg)
template<class T, class V, class S>
INLINE Rall1d< T, V, S >	sqr (const Rall1d< T, V, S > &arg)
template<class T, class V, class S>
INLINE Rall1d< T, V, S >	pow (const Rall1d< T, V, S > &arg, double m)
template<class T, class V, class S>
INLINE Rall1d< T, V, S >	sqrt (const Rall1d< T, V, S > &arg)
template<class T, class V, class S>
INLINE Rall1d< T, V, S >	atan (const Rall1d< T, V, S > &x)
template<class T, class V, class S>
INLINE Rall1d< T, V, S >	hypot (const Rall1d< T, V, S > &y, const Rall1d< T, V, S > &x)
template<class T, class V, class S>
INLINE Rall1d< T, V, S >	asin (const Rall1d< T, V, S > &x)
template<class T, class V, class S>
INLINE Rall1d< T, V, S >	acos (const Rall1d< T, V, S > &x)
template<class T, class V, class S>
INLINE Rall1d< T, V, S >	abs (const Rall1d< T, V, S > &x)
template<class T, class V, class S>
INLINE S	Norm (const Rall1d< T, V, S > &value)
template<class T, class V, class S>
INLINE Rall1d< T, V, S >	tanh (const Rall1d< T, V, S > &arg)
template<class T, class V, class S>
INLINE Rall1d< T, V, S >	atan2 (const Rall1d< T, V, S > &y, const Rall1d< T, V, S > &x)
template<class T, class V, class S>
INLINE Rall1d< T, V, S >	LinComb (S alfa, const Rall1d< T, V, S > &a, const T &beta, const Rall1d< T, V, S > &b)
template<class T, class V, class S>
INLINE void	LinCombR (S alfa, const Rall1d< T, V, S > &a, const T &beta, const Rall1d< T, V, S > &b, Rall1d< T, V, S > &result)
template<class T, class V, class S>
INLINE void	SetToZero (Rall1d< T, V, S > &value)
template<class T, class V, class S>
INLINE void	SetToIdentity (Rall1d< T, V, S > &value)
template<class T, class V, class S>
INLINE bool	Equal (const Rall1d< T, V, S > &y, const Rall1d< T, V, S > &x, double eps=epsilon)
template<class T, class V, class S>
INLINE bool	operator== (const Rall1d< T, V, S > &y, const Rall1d< T, V, S > &x)
template<class T, class V, class S>
INLINE bool	operator!= (const Rall1d< T, V, S > &y, const Rall1d< T, V, S > &x)
template<class T, class V, class S>
std::ostream &	operator<< (std::ostream &os, const Rall1d< T, V, S > &r)
template<class T, class V, class S>
INLINE Rall2d< T, V, S >	operator/ (const Rall2d< T, V, S > &lhs, const Rall2d< T, V, S > &rhs)
template<class T, class V, class S>
INLINE Rall2d< T, V, S >	operator* (const Rall2d< T, V, S > &lhs, const Rall2d< T, V, S > &rhs)
template<class T, class V, class S>
INLINE Rall2d< T, V, S >	operator+ (const Rall2d< T, V, S > &lhs, const Rall2d< T, V, S > &rhs)
template<class T, class V, class S>
INLINE Rall2d< T, V, S >	operator- (const Rall2d< T, V, S > &lhs, const Rall2d< T, V, S > &rhs)
template<class T, class V, class S>
INLINE Rall2d< T, V, S >	operator- (const Rall2d< T, V, S > &arg)
template<class T, class V, class S>
INLINE Rall2d< T, V, S >	operator* (S s, const Rall2d< T, V, S > &v)
template<class T, class V, class S>
INLINE Rall2d< T, V, S >	operator* (const Rall2d< T, V, S > &v, S s)
template<class T, class V, class S>
INLINE Rall2d< T, V, S >	operator+ (S s, const Rall2d< T, V, S > &v)
template<class T, class V, class S>
INLINE Rall2d< T, V, S >	operator+ (const Rall2d< T, V, S > &v, S s)
template<class T, class V, class S>
INLINE Rall2d< T, V, S >	operator- (S s, const Rall2d< T, V, S > &v)
template<class T, class V, class S>
INLINE Rall2d< T, V, S >	operator- (const Rall2d< T, V, S > &v, S s)
template<class T, class V, class S>
INLINE Rall2d< T, V, S >	operator/ (S s, const Rall2d< T, V, S > &rhs)
template<class T, class V, class S>
INLINE Rall2d< T, V, S >	operator/ (const Rall2d< T, V, S > &v, S s)
template<class T, class V, class S>
INLINE Rall2d< T, V, S >	exp (const Rall2d< T, V, S > &arg)
template<class T, class V, class S>
INLINE Rall2d< T, V, S >	log (const Rall2d< T, V, S > &arg)
template<class T, class V, class S>
INLINE Rall2d< T, V, S >	sin (const Rall2d< T, V, S > &arg)
template<class T, class V, class S>
INLINE Rall2d< T, V, S >	cos (const Rall2d< T, V, S > &arg)
template<class T, class V, class S>
INLINE Rall2d< T, V, S >	tan (const Rall2d< T, V, S > &arg)
template<class T, class V, class S>
INLINE Rall2d< T, V, S >	sinh (const Rall2d< T, V, S > &arg)
template<class T, class V, class S>
INLINE Rall2d< T, V, S >	cosh (const Rall2d< T, V, S > &arg)
template<class T, class V, class S>
INLINE Rall2d< T, V, S >	tanh (const Rall2d< T, V, S > &arg)
template<class T, class V, class S>
INLINE Rall2d< T, V, S >	sqr (const Rall2d< T, V, S > &arg)
template<class T, class V, class S>
INLINE Rall2d< T, V, S >	pow (const Rall2d< T, V, S > &arg, double m)
template<class T, class V, class S>
INLINE Rall2d< T, V, S >	sqrt (const Rall2d< T, V, S > &arg)
template<class T, class V, class S>
INLINE Rall2d< T, V, S >	asin (const Rall2d< T, V, S > &arg)
template<class T, class V, class S>
INLINE Rall2d< T, V, S >	acos (const Rall2d< T, V, S > &arg)
template<class T, class V, class S>
INLINE Rall2d< T, V, S >	atan (const Rall2d< T, V, S > &x)
template<class T, class V, class S>
INLINE Rall2d< T, V, S >	atan2 (const Rall2d< T, V, S > &y, const Rall2d< T, V, S > &x)
template<class T, class V, class S>
INLINE Rall2d< T, V, S >	abs (const Rall2d< T, V, S > &x)
template<class T, class V, class S>
INLINE Rall2d< T, V, S >	hypot (const Rall2d< T, V, S > &y, const Rall2d< T, V, S > &x)
template<class T, class V, class S>
INLINE S	Norm (const Rall2d< T, V, S > &value)
template<class T, class V, class S>
INLINE Rall2d< T, V, S >	LinComb (S alfa, const Rall2d< T, V, S > &a, const T &beta, const Rall2d< T, V, S > &b)
template<class T, class V, class S>
INLINE void	LinCombR (S alfa, const Rall2d< T, V, S > &a, const T &beta, const Rall2d< T, V, S > &b, Rall2d< T, V, S > &result)
template<class T, class V, class S>
INLINE void	SetToZero (Rall2d< T, V, S > &value)
template<class T, class V, class S>
INLINE void	SetToIdentity (Rall2d< T, V, S > &value)
template<class T, class V, class S>
INLINE bool	Equal (const Rall2d< T, V, S > &y, const Rall2d< T, V, S > &x, double eps=epsilon)
template<class T, class V, class S>
INLINE bool	operator== (const Rall2d< T, V, S > &y, const Rall2d< T, V, S > &x)
template<class T, class V, class S>
INLINE bool	operator!= (const Rall2d< T, V, S > &y, const Rall2d< T, V, S > &x)
template<class T, class V, class S>
std::ostream &	operator<< (std::ostream &os, const Rall2d< T, V, S > &r)
template<typename T>
void	swap (scoped_ptr< T > &a, scoped_ptr< T > &b)
double	PYTHAG (double a, double b)
double	SIGN (double a, double b)
int	svd_eigen_HH (const Eigen::MatrixXd &A, Eigen::MatrixXd &U, Eigen::VectorXd &S, Eigen::MatrixXd &V, Eigen::VectorXd &tmp, int maxiter=150, double epsilon=1e-300)
int	svd_eigen_Macie (const Eigen::MatrixXd &A, Eigen::MatrixXd &U, Eigen::VectorXd &S, Eigen::MatrixXd &V, Eigen::MatrixXd &B, Eigen::VectorXd &tempi, double threshold, bool toggle)
double	sin (double a)
double	cos (double a)
double	exp (double a)
double	log (double a)
double	tan (double a)
double	cosh (double a)
double	sinh (double a)
double	sqrt (double a)
double	atan (double a)
double	acos (double a)
double	asin (double a)
double	tanh (double a)
double	pow (double a, double b)
double	atan2 (double a, double b)
double	max (double a, double b)
double	min (double a, double b)
double	LinComb (double alfa, double a, double beta, double b)
void	LinCombR (double alfa, double a, double beta, double b, double &result)
void	SetToZero (double &arg)
	to uniformly set double, RNDouble,Vector,... objects to zero in template-classes
void	SetToIdentity (double &arg)
	to uniformly set double, RNDouble,Vector,... objects to the identity element in template-classes
double	sign (double arg)
double	sqr (double arg)
double	Norm (double arg)
bool	Equal (double a, double b, double eps=epsilon)
void	random (double &a)
void	posrandom (double &a)
double	diff (double a, double b, double dt)
double	addDelta (double a, double da, double dt)
void	_check_istream (std::istream &is)
void	Eat (std::istream &is, int delim)
void	Eat (std::istream &is, const char *descript)
void	EatWord (std::istream &is, const char *delim, char *storage, int maxsize)
void	EatEnd (std::istream &is, int delim)

Variables
int	STREAMBUFFERSIZE
int	MAXLENFILENAME
	maximal length of a file name
const double	PI
	the value of pi
const double	PI_2
	the value of pi/2
const double	PI_4
	the value of pi/4
const double	deg2rad
	the value pi/180
const double	rad2deg
	the value 180/pi
double	epsilon
	default precision while comparing with Equal(..,..) functions. Initialized at 0.0000001.
int	VSIZE
	the number of derivatives used in the RN-... objects.

Typedef Documentation

doubleAcc

typedef Rall2d<double,double,double> KDL::doubleAcc

doubleVel

typedef Rall1d<double> KDL::doubleVel

Frames

typedef std::map<std::string, Frame> KDL::Frames

Jacobians

typedef std::map<std::string, Jacobian> KDL::Jacobians

SegmentMap

typedef std::map<std::string,TreeElement> KDL::SegmentMap

TreeElementType

typedef TreeElement KDL::TreeElementType

Twists

typedef std::map<std::string, Twist> KDL::Twists

Wrenches

typedef std::vector< Wrench > KDL::Wrenches

WrenchMap

typedef std::map<std::string,Wrench> KDL::WrenchMap

Function Documentation

_check_istream()

void KDL::_check_istream

(

std::istream &

is

)

checks validity of basic io of is

abs() [1/2]

template<class T, class V, class S>

INLINE Rall1d< T, V, S > KDL::abs

(

const Rall1d< T, V, S > &

x

)

abs() [2/2]

template<class T, class V, class S>

INLINE Rall2d< T, V, S > KDL::abs

(

const Rall2d< T, V, S > &

x

)

acos() [1/3]

template<class T, class V, class S>

INLINE Rall1d< T, V, S > KDL::acos

(

const Rall1d< T, V, S > &

x

)

acos() [2/3]

template<class T, class V, class S>

INLINE Rall2d< T, V, S > KDL::acos

(

const Rall2d< T, V, S > &

arg

)

acos() [3/3]

double KDL::acos ( double a )

inline

Add() [1/6]

void KDL::Add	(	const JntArray &	src1,
		const JntArray &	src2,
		JntArray &	dest )

Function to add two joint arrays, all the arguments must have the same size: A + B = C. This function is aliasing-safe, A or B can be the same array as C.

Parameters

src1	A
src2	B
dest	C

Add() [2/6]

void KDL::Add	(	const JntArrayAcc &	src1,
		const JntArray &	src2,
		JntArrayAcc &	dest )

Add() [3/6]

void KDL::Add	(	const JntArrayAcc &	src1,
		const JntArrayAcc &	src2,
		JntArrayAcc &	dest )

Add() [4/6]

void KDL::Add	(	const JntArrayAcc &	src1,
		const JntArrayVel &	src2,
		JntArrayAcc &	dest )

Add() [5/6]

void KDL::Add	(	const JntArrayVel &	src1,
		const JntArray &	src2,
		JntArrayVel &	dest )

Add() [6/6]

void KDL::Add	(	const JntArrayVel &	src1,
		const JntArrayVel &	src2,
		JntArrayVel &	dest )

addDelta() [1/10]

IMETHOD doubleVel KDL::addDelta	(	const doubleVel &	a,
		const doubleVel &	da,
		double	dt = 1.0 )

addDelta() [2/10]

IMETHOD Frame KDL::addDelta	(	const Frame &	F_w_a,
		const Twist &	da_w,
		double	dt = 1 )

returns the frame resulting from the rotation of frame a by the axis and angle specified in da_w and the translation of the origin (also specified in da_w).

see also the corresponding diff() routine.

Parameters

R_w_a	Rotation matrix of frame a expressed to some frame w.
da_w	axis and angle of the rotation (da_w.rot), together with a displacement vector for the origin (da_w.vel), expressed to some frame w.

Returns

the frame resulting from the rotation of frame a by the axis and angle specified with da.rot, and the translation of the origin da_w.vel . The resulting frame is expressed with respect to frame w.

addDelta() [3/10]

IMETHOD FrameVel KDL::addDelta	(	const FrameVel &	a,
		const TwistVel &	da,
		double	dt = 1.0 )

addDelta() [4/10]

IMETHOD Rotation KDL::addDelta	(	const Rotation &	R_w_a,
		const Vector &	da_w,
		double	dt = 1 )

returns the rotation matrix resulting from the rotation of frame a by the axis and angle specified with da_w.

see also the corresponding diff() routine.

Parameters

R_w_a	Rotation matrix of frame a expressed to some frame w.
da_w	axis and angle of the rotation expressed to some frame w.

Returns

the rotation matrix resulting from the rotation of frame a by the axis and angle specified with da. The resulting rotation matrix is expressed with respect to frame w.

addDelta() [5/10]

IMETHOD RotationVel KDL::addDelta	(	const RotationVel &	a,
		const VectorVel &	da,
		double	dt = 1.0 )

addDelta() [6/10]

IMETHOD Twist KDL::addDelta	(	const Twist &	a,
		const Twist &	da,
		double	dt = 1 )

adds the twist da to the twist a. see also the corresponding diff() routine.

Parameters

a	a twist wrt some frame
da	a twist difference wrt some frame

Returns

The twist (a+da) wrt the corresponding frame.

addDelta() [7/10]

IMETHOD Vector KDL::addDelta	(	const Vector &	p_w_a,
		const Vector &	p_w_da,
		double	dt = 1 )

adds vector da to vector a. see also the corresponding diff() routine.

Parameters

p_w_a	vector a expressed to some frame w.
p_w_da	vector da expressed to some frame w.

Returns

the vector resulting from the displacement of vector a by vector da, expressed in the frame w.

addDelta() [8/10]

IMETHOD VectorVel KDL::addDelta	(	const VectorVel &	a,
		const VectorVel &	da,
		double	dt = 1.0 )

addDelta() [9/10]

IMETHOD Wrench KDL::addDelta	(	const Wrench &	a,
		const Wrench &	da,
		double	dt = 1 )

adds the wrench da to the wrench w. see also the corresponding diff() routine. see also the corresponding diff() routine.

Parameters

a	a wrench wrt some frame
da	a wrench difference wrt some frame

Returns

the wrench (a+da) wrt the corresponding frame.

addDelta() [10/10]

double KDL::addDelta ( double a, double da, double dt )

inline

asin() [1/3]

template<class T, class V, class S>

INLINE Rall1d< T, V, S > KDL::asin

(

const Rall1d< T, V, S > &

x

)

asin() [2/3]

template<class T, class V, class S>

INLINE Rall2d< T, V, S > KDL::asin

(

const Rall2d< T, V, S > &

arg

)

asin() [3/3]

double KDL::asin ( double a )

inline

atan() [1/3]

template<class T, class V, class S>

INLINE Rall1d< T, V, S > KDL::atan

(

const Rall1d< T, V, S > &

x

)

atan() [2/3]

template<class T, class V, class S>

INLINE Rall2d< T, V, S > KDL::atan

(

const Rall2d< T, V, S > &

x

)

atan() [3/3]

double KDL::atan ( double a )

inline

atan2() [1/3]

template<class T, class V, class S>

INLINE Rall1d< T, V, S > KDL::atan2	(	const Rall1d< T, V, S > &	y,
		const Rall1d< T, V, S > &	x )

atan2() [2/3]

template<class T, class V, class S>

INLINE Rall2d< T, V, S > KDL::atan2	(	const Rall2d< T, V, S > &	y,
		const Rall2d< T, V, S > &	x )

atan2() [3/3]

double KDL::atan2 ( double a, double b )

inline

changeBase()

bool KDL::changeBase	(	const Jacobian &	src1,
		const Rotation &	rot,
		Jacobian &	dest )

changeRefFrame()

bool KDL::changeRefFrame	(	const Jacobian &	src1,
		const Frame &	frame,
		Jacobian &	dest )

changeRefPoint()

bool KDL::changeRefPoint	(	const Jacobian &	src1,
		const Vector &	base_AB,
		Jacobian &	dest )

cos() [1/3]

template<class T, class V, class S>

INLINE Rall1d< T, V, S > KDL::cos

(

const Rall1d< T, V, S > &

arg

)

cos() [2/3]

template<class T, class V, class S>

INLINE Rall2d< T, V, S > KDL::cos

(

const Rall2d< T, V, S > &

arg

)

cos() [3/3]

double KDL::cos ( double a )

inline

cosh() [1/3]

template<class T, class V, class S>

INLINE Rall1d< T, V, S > KDL::cosh

(

const Rall1d< T, V, S > &

arg

)

cosh() [2/3]

template<class T, class V, class S>

INLINE Rall2d< T, V, S > KDL::cosh

(

const Rall2d< T, V, S > &

arg

)

cosh() [3/3]

double KDL::cosh ( double a )

inline

diff() [1/10]

IMETHOD doubleVel KDL::diff	(	const doubleVel &	a,
		const doubleVel &	b,
		double	dt = 1.0 )

diff() [2/10]

IMETHOD Twist KDL::diff	(	const Frame &	F_a_b1,
		const Frame &	F_a_b2,
		double	dt = 1 )

determines the rotation axis necessary to rotate the frame b1 to the same orientation as frame b2 and the vector necessary to translate the origin of b1 to the origin of b2, and stores the result in a Twist datastructure.

Parameters

F_a_b1	frame b1 expressed with respect to some frame a.
F_a_b2	frame b2 expressed with respect to some frame a.

Warning

The result is not a Twist!
see diff() for Rotation and Vector arguments for further detail on the semantics.

diff() [3/10]

IMETHOD TwistVel KDL::diff	(	const FrameVel &	a,
		const FrameVel &	b,
		double	dt = 1.0 )

diff() [4/10]

IMETHOD Vector KDL::diff	(	const Rotation &	R_a_b1,
		const Rotation &	R_a_b2,
		double	dt = 1 )

determines the (scaled) rotation axis necessary to rotate from b1 to b2.

This rotation axis is expressed w.r.t. frame a. The rotation axis is scaled by the necessary rotation angle. The rotation angle is always in the (inclusive) interval \( [0 , \pi] \).

This definition is chosen in this way to facilitate numerical differentiation. With this definition diff(a,b) == -diff(b,a).

The diff() function is overloaded for all classes in frames.hpp and framesvel.hpp, such that numerical differentiation, equality checks with tolerances, etc. can be performed without caring exactly on which type the operation is performed.

Parameters

R_a_b1	The rotation matrix \( _a^{b1} R \) of b1 with respect to frame a.
R_a_b2	The Rotation matrix \( _a^{b2} R \) of b2 with respect to frame a.
dt	[optional][obsolete] time interval over which the numerical differentiation takes place. By default this is set to 1.0.

Returns

rotation axis to rotate from b1 to b2, scaled by the rotation angle, expressed in frame a.

Warning

- The result is not a rotational vector, i.e. it is not a mathematical vector. (no communitative addition).

- When used in the context of numerical differentiation, with the frames b1 and b2 very close to each other, the semantics correspond to the twist, scaled by the time.

- For angles equal to \( \pi \), The negative of the return value is equally valid.

diff() [5/10]

IMETHOD VectorVel KDL::diff	(	const RotationVel &	a,
		const RotationVel &	b,
		double	dt = 1.0 )

diff() [6/10]

IMETHOD Twist KDL::diff	(	const Twist &	a,
		const Twist &	b,
		double	dt = 1 )

determines the difference between two twists i.e. the difference between the underlying velocity vectors and rotational velocity vectors.

diff() [7/10]

IMETHOD Vector KDL::diff	(	const Vector &	p_w_a,
		const Vector &	p_w_b,
		double	dt = 1 )

determines the difference of vector b with vector a.

see diff for Rotation matrices for further background information.

Parameters

p_w_a	start vector a expressed to some frame w
p_w_b	end vector b expressed to some frame w .
dt	[optional][obsolete] time interval over which the numerical differentiation takes place.

Returns

the difference (b-a) expressed to the frame w.

diff() [8/10]

IMETHOD VectorVel KDL::diff	(	const VectorVel &	a,
		const VectorVel &	b,
		double	dt = 1.0 )

diff() [9/10]

IMETHOD Wrench KDL::diff	(	const Wrench &	W_a_p1,
		const Wrench &	W_a_p2,
		double	dt = 1 )

determines the difference between two wrenches i.e. the difference between the underlying torque vectors and force vectors.

diff() [10/10]

double KDL::diff ( double a, double b, double dt )

inline

Divide() [1/6]

void KDL::Divide	(	const JntArray &	src,
		const double &	factor,
		JntArray &	dest )

Function to divide all the array values with a scalar factor: A/b=C. This function is aliasing-safe, A can be the same array as C.

Parameters

src	A
factor	b
dest	C

Divide() [2/6]

void KDL::Divide	(	const JntArrayAcc &	src,
		const double &	factor,
		JntArrayAcc &	dest )

Divide() [3/6]

void KDL::Divide	(	const JntArrayAcc &	src,
		const doubleAcc &	factor,
		JntArrayAcc &	dest )

Divide() [4/6]

void KDL::Divide	(	const JntArrayAcc &	src,
		const doubleVel &	factor,
		JntArrayAcc &	dest )

Divide() [5/6]

void KDL::Divide	(	const JntArrayVel &	src,
		const double &	factor,
		JntArrayVel &	dest )

Divide() [6/6]

void KDL::Divide	(	const JntArrayVel &	src,
		const doubleVel &	factor,
		JntArrayVel &	dest )

dot() [1/9]

IMETHOD double KDL::dot	(	const Twist &	lhs,
		const Wrench &	rhs )

dot() [2/9]

IMETHOD double KDL::dot	(	const Vector &	lhs,
		const Vector &	rhs )

dot() [3/9]

doubleAcc KDL::dot	(	const Vector &	lhs,
		const VectorAcc &	rhs )

dot() [4/9]

IMETHOD doubleVel KDL::dot	(	const Vector &	lhs,
		const VectorVel &	rhs )

dot() [5/9]

doubleAcc KDL::dot	(	const VectorAcc &	lhs,
		const Vector &	rhs )

dot() [6/9]

doubleAcc KDL::dot	(	const VectorAcc &	lhs,
		const VectorAcc &	rhs )

dot() [7/9]

IMETHOD doubleVel KDL::dot	(	const VectorVel &	lhs,
		const Vector &	rhs )

dot() [8/9]

IMETHOD doubleVel KDL::dot	(	const VectorVel &	lhs,
		const VectorVel &	rhs )

dot() [9/9]

IMETHOD double KDL::dot	(	const Wrench &	rhs,
		const Twist &	lhs )

Eat() [1/2]

void KDL::Eat	(	std::istream &	is,
		const char *	descript )

Eats characters of the stream as long as they satisfy the description in descript

Parameters

is	a stream
descript	description string. A sequence of spaces, tabs, new-lines and comments is regarded as 1 space in the description string.

Eat() [2/2]

void KDL::Eat	(	std::istream &	is,
		int	delim )

Eats characters of the stream until the character delim is encountered

Parameters

is	a stream
delim	eat until this character is encountered

EatEnd()

void KDL::EatEnd	(	std::istream &	is,
		int	delim )

Eats characters of the stream until the character delim is encountered similar to Eat(is,delim) but spaces at the end are not read.

Parameters

is	a stream
delim	eat until this character is encountered

EatWord()

void KDL::EatWord	(	std::istream &	is,
		const char *	delim,
		char *	storage,
		int	maxsize )

Eats a word of the stream delimited by the letters in delim or space(tabs...)

Parameters

is	a stream
delim	a string containing the delimmiting characters
storage	for returning the word
maxsize	a word can be maximally maxsize-1 long.

Equal() [1/39]

IMETHOD bool KDL::Equal ( const Frame & a, const Frame & b, double eps = epsilon )

inline

Equal() [2/39]

bool KDL::Equal	(	const Frame &	r1,
		const FrameAcc &	r2,
		double	eps = epsilon )

Equal() [3/39]

bool KDL::Equal	(	const Frame &	r1,
		const FrameVel &	r2,
		double	eps = epsilon )

Equal() [4/39]

IMETHOD bool KDL::Equal ( const Frame2 & a, const Frame2 & b, double eps = epsilon )

inline

Equal() [5/39]

bool KDL::Equal	(	const FrameAcc &	r1,
		const Frame &	r2,
		double	eps = epsilon )

Equal() [6/39]

bool KDL::Equal	(	const FrameAcc &	r1,
		const FrameAcc &	r2,
		double	eps = epsilon )

Equal() [7/39]

bool KDL::Equal	(	const FrameVel &	r1,
		const Frame &	r2,
		double	eps = epsilon )

Equal() [8/39]

bool KDL::Equal	(	const FrameVel &	r1,
		const FrameVel &	r2,
		double	eps = epsilon )

Equal() [9/39]

bool KDL::Equal	(	const Jacobian &	a,
		const Jacobian &	b,
		double	eps = epsilon )

Equal() [10/39]

bool KDL::Equal	(	const JntArray &	src1,
		const JntArray &	src2,
		double	eps = epsilon )

Function to check if two arrays are the same with a precision of eps

Parameters

src1
src2
eps	default: epsilon

Returns

true if each element of src1 is within eps of the same element in src2, or if both src1 and src2 have no data (ie 0==rows())

Equal() [11/39]

bool KDL::Equal	(	const JntArrayAcc &	src1,
		const JntArrayAcc &	src2,
		double	eps = epsilon )

Equal() [12/39]

bool KDL::Equal	(	const JntArrayVel &	src1,
		const JntArrayVel &	src2,
		double	eps = epsilon )

Equal() [13/39]

template<class T, class V, class S>

INLINE bool KDL::Equal	(	const Rall1d< T, V, S > &	y,
		const Rall1d< T, V, S > &	x,
		double	eps = epsilon )

Equal() [14/39]

template<class T, class V, class S>

INLINE bool KDL::Equal	(	const Rall2d< T, V, S > &	y,
		const Rall2d< T, V, S > &	x,
		double	eps = epsilon )

Equal() [15/39]

bool KDL::Equal	(	const Rotation &	a,
		const Rotation &	b,
		double	eps = epsilon )

Equal() [16/39]

bool KDL::Equal	(	const Rotation &	r1,
		const RotationAcc &	r2,
		double	eps = epsilon )

Equal() [17/39]

bool KDL::Equal	(	const Rotation &	r1,
		const RotationVel &	r2,
		double	eps = epsilon )

Equal() [18/39]

IMETHOD bool KDL::Equal ( const Rotation2 & a, const Rotation2 & b, double eps = epsilon )

inline

Equal() [19/39]

bool KDL::Equal	(	const RotationAcc &	r1,
		const Rotation &	r2,
		double	eps = epsilon )

Equal() [20/39]

bool KDL::Equal	(	const RotationAcc &	r1,
		const RotationAcc &	r2,
		double	eps = epsilon )

Equal() [21/39]

bool KDL::Equal	(	const RotationVel &	r1,
		const Rotation &	r2,
		double	eps = epsilon )

Equal() [22/39]

bool KDL::Equal	(	const RotationVel &	r1,
		const RotationVel &	r2,
		double	eps = epsilon )

Equal() [23/39]

IMETHOD bool KDL::Equal ( const Twist & a, const Twist & b, double eps = epsilon )

inline

Equal() [24/39]

bool KDL::Equal	(	const Twist &	a,
		const TwistAcc &	b,
		double	eps = epsilon )

Equal() [25/39]

bool KDL::Equal	(	const Twist &	a,
		const TwistVel &	b,
		double	eps = epsilon )

Equal() [26/39]

bool KDL::Equal	(	const TwistAcc &	a,
		const Twist &	b,
		double	eps = epsilon )

Equal() [27/39]

bool KDL::Equal	(	const TwistAcc &	a,
		const TwistAcc &	b,
		double	eps = epsilon )

Equal() [28/39]

bool KDL::Equal	(	const TwistVel &	a,
		const Twist &	b,
		double	eps = epsilon )

Equal() [29/39]

bool KDL::Equal	(	const TwistVel &	a,
		const TwistVel &	b,
		double	eps = epsilon )

Equal() [30/39]

IMETHOD bool KDL::Equal ( const Vector & a, const Vector & b, double eps = epsilon )

inline

Equal() [31/39]

bool KDL::Equal	(	const Vector &	r1,
		const VectorAcc &	r2,
		double	eps = epsilon )

Equal() [32/39]

bool KDL::Equal	(	const Vector &	r1,
		const VectorVel &	r2,
		double	eps = epsilon )

Equal() [33/39]

IMETHOD bool KDL::Equal ( const Vector2 & a, const Vector2 & b, double eps = epsilon )

inline

Equal() [34/39]

bool KDL::Equal	(	const VectorAcc &	r1,
		const Vector &	r2,
		double	eps = epsilon )

Equal() [35/39]

bool KDL::Equal	(	const VectorAcc &	r1,
		const VectorAcc &	r2,
		double	eps = epsilon )

Equal() [36/39]

bool KDL::Equal	(	const VectorVel &	r1,
		const Vector &	r2,
		double	eps = epsilon )

Equal() [37/39]

bool KDL::Equal	(	const VectorVel &	r1,
		const VectorVel &	r2,
		double	eps = epsilon )

Equal() [38/39]

IMETHOD bool KDL::Equal ( const Wrench & a, const Wrench & b, double eps = epsilon )

inline

Equal() [39/39]

bool KDL::Equal ( double a, double b, double eps = epsilon )

inline

exp() [1/3]

template<class T, class V, class S>

INLINE Rall1d< T, V, S > KDL::exp

(

const Rall1d< T, V, S > &

arg

)

exp() [2/3]

template<class T, class V, class S>

INLINE Rall2d< T, V, S > KDL::exp

(

const Rall2d< T, V, S > &

arg

)

exp() [3/3]

double KDL::exp ( double a )

inline

hash_combine()

template<class T>

void KDL::hash_combine ( std::size_t & seed, const T & v )

inline

Combine hash of object v to the seed.

Parameters

seed	Seed to append the hash of v
v	Object of which the hash should be appended to the seed

Inspired by: https://github.com/boostorg/multiprecision/blob/boost-1.79.0/include/boost/multiprecision/detail/hash.hpp#L35-L41

hypot() [1/2]

template<class T, class V, class S>

INLINE Rall1d< T, V, S > KDL::hypot	(	const Rall1d< T, V, S > &	y,
		const Rall1d< T, V, S > &	x )

hypot() [2/2]

template<class T, class V, class S>

INLINE Rall2d< T, V, S > KDL::hypot	(	const Rall2d< T, V, S > &	y,
		const Rall2d< T, V, S > &	x )

IOTrace()

void KDL::IOTrace

(

const std::string &

description

)

IOTraceOutput()

void KDL::IOTraceOutput

(

std::ostream &

os

)

outputs the IO-stack to a stream to provide a better errormessage.

IOTracePop()

void KDL::IOTracePop

(

)

pops a description of the IO-stack

IOTracePopStr()

void KDL::IOTracePopStr	(	char *	buffer,
		int	size )

outputs one element of the IO-stack to the buffer (maximally size chars) returns empty string if no elements on the stack.

ldl_solver_eigen()

int KDL::ldl_solver_eigen	(	const Eigen::MatrixXd &	A,
		const Eigen::VectorXd &	v,
		Eigen::MatrixXd &	L,
		Eigen::VectorXd &	D,
		Eigen::VectorXd &	vtmp,
		Eigen::VectorXd &	q )

Solves the system of equations Aq = v for q via LDL decomposition, where A is a square positive definite matrix.

The algorithm factor A into the product of three matrices LDL^T, where L is a lower triangular matrix and D is a diagonal matrix. This allows q to be computed without explicitly inverting A. Note that the LDL decomposition is a variant of the classical Cholesky Decomposition that does not require the computation of square roots. Input parameters:

Parameters

A	matrix<double>(nxn)
v	vector<double> n
vtmp	vector<double> n [temp variable] Output parameters:
L	matrix<double>(nxn)
D	vector<double> n
q	vector<double> n

Returns

0 if successful, E_SIZE_MISMATCH if dimensions do not match References: https://en.wikipedia.org/wiki/Cholesky_decomposition

LinComb() [1/3]

double KDL::LinComb ( double alfa, double a, double beta, double b )

inline

LinComb() [2/3]

template<class T, class V, class S>

INLINE Rall1d< T, V, S > KDL::LinComb	(	S	alfa,
		const Rall1d< T, V, S > &	a,
		const T &	beta,
		const Rall1d< T, V, S > &	b )

LinComb() [3/3]

template<class T, class V, class S>

INLINE Rall2d< T, V, S > KDL::LinComb	(	S	alfa,
		const Rall2d< T, V, S > &	a,
		const T &	beta,
		const Rall2d< T, V, S > &	b )

LinCombR() [1/3]

void KDL::LinCombR ( double alfa, double a, double beta, double b, double & result )

inline

LinCombR() [2/3]

template<class T, class V, class S>

INLINE void KDL::LinCombR	(	S	alfa,
		const Rall1d< T, V, S > &	a,
		const T &	beta,
		const Rall1d< T, V, S > &	b,
		Rall1d< T, V, S > &	result )

LinCombR() [3/3]

template<class T, class V, class S>

INLINE void KDL::LinCombR	(	S	alfa,
		const Rall2d< T, V, S > &	a,
		const T &	beta,
		const Rall2d< T, V, S > &	b,
		Rall2d< T, V, S > &	result )

log() [1/3]

template<class T, class V, class S>

INLINE Rall1d< T, V, S > KDL::log

(

const Rall1d< T, V, S > &

arg

)

log() [2/3]

template<class T, class V, class S>

INLINE Rall2d< T, V, S > KDL::log

(

const Rall2d< T, V, S > &

arg

)

log() [3/3]

double KDL::log ( double a )

inline

max()

double KDL::max ( double a, double b )

inline

min()

double KDL::min ( double a, double b )

inline

Multiply() [1/6]

void KDL::Multiply	(	const JntArray &	src,
		const double &	factor,
		JntArray &	dest )

Function to multiply all the array values with a scalar factor: A*b=C. This function is aliasing-safe, A can be the same array as C.

Parameters

src	A
factor	b
dest	C

Multiply() [2/6]

void KDL::Multiply	(	const JntArrayAcc &	src,
		const double &	factor,
		JntArrayAcc &	dest )

Multiply() [3/6]

void KDL::Multiply	(	const JntArrayAcc &	src,
		const doubleAcc &	factor,
		JntArrayAcc &	dest )

Multiply() [4/6]

void KDL::Multiply	(	const JntArrayAcc &	src,
		const doubleVel &	factor,
		JntArrayAcc &	dest )

Multiply() [5/6]

void KDL::Multiply	(	const JntArrayVel &	src,
		const double &	factor,
		JntArrayVel &	dest )

Multiply() [6/6]

void KDL::Multiply	(	const JntArrayVel &	src,
		const doubleVel &	factor,
		JntArrayVel &	dest )

MultiplyJacobian()

void KDL::MultiplyJacobian	(	const Jacobian &	jac,
		const JntArray &	src,
		Twist &	dest )

Function to multiply a KDL::Jacobian with a KDL::JntArray to get a KDL::Twist, it should not be used to calculate the forward velocity kinematics, the solver classes are built for this purpose. J*q = t

Parameters

jac	J
src	q
dest	t

Postcondition

dest==Twist::Zero() if 0==src.rows() (ie src is empty)

Norm() [1/3]

template<class T, class V, class S>

INLINE S KDL::Norm

(

const Rall1d< T, V, S > &

value

)

Norm() [2/3]

template<class T, class V, class S>

INLINE S KDL::Norm

(

const Rall2d< T, V, S > &

value

)

Norm() [3/3]

double KDL::Norm ( double arg )

inline

operator!=() [1/20]

IMETHOD bool KDL::operator!=	(	const Frame &	a,
		const Frame &	b )

operator!=() [2/20]

bool KDL::operator!=	(	const Frame &	r1,
		const FrameVel &	r2 )

operator!=() [3/20]

bool KDL::operator!=	(	const FrameVel &	r1,
		const Frame &	r2 )

operator!=() [4/20]

bool KDL::operator!=	(	const FrameVel &	r1,
		const FrameVel &	r2 )

operator!=() [5/20]

template<class T, class V, class S>

INLINE bool KDL::operator!=	(	const Rall1d< T, V, S > &	y,
		const Rall1d< T, V, S > &	x )

operator!=() [6/20]

template<class T, class V, class S>

INLINE bool KDL::operator!=	(	const Rall2d< T, V, S > &	y,
		const Rall2d< T, V, S > &	x )

operator!=() [7/20]

IMETHOD bool KDL::operator!=	(	const Rotation &	a,
		const Rotation &	b )

operator!=() [8/20]

bool KDL::operator!=	(	const Rotation &	r1,
		const RotationVel &	r2 )

operator!=() [9/20]

bool KDL::operator!=	(	const RotationVel &	r1,
		const Rotation &	r2 )

operator!=() [10/20]

bool KDL::operator!=	(	const RotationVel &	r1,
		const RotationVel &	r2 )

operator!=() [11/20]

IMETHOD bool KDL::operator!=	(	const Twist &	a,
		const Twist &	b )

operator!=() [12/20]

bool KDL::operator!=	(	const Twist &	r1,
		const TwistVel &	r2 )

operator!=() [13/20]

bool KDL::operator!=	(	const TwistVel &	a,
		const TwistVel &	b )

operator!=() [14/20]

bool KDL::operator!=	(	const TwistVel &	r1,
		const Twist &	r2 )

operator!=() [15/20]

IMETHOD bool KDL::operator!=	(	const Vector &	a,
		const Vector &	b )

operator!=() [16/20]

bool KDL::operator!=	(	const Vector &	r1,
		const VectorVel &	r2 )

operator!=() [17/20]

IMETHOD bool KDL::operator!=	(	const Vector2 &	a,
		const Vector2 &	b )

operator!=() [18/20]

bool KDL::operator!=	(	const VectorVel &	r1,
		const Vector &	r2 )

operator!=() [19/20]

bool KDL::operator!=	(	const VectorVel &	r1,
		const VectorVel &	r2 )

operator!=() [20/20]

IMETHOD bool KDL::operator!=	(	const Wrench &	a,
		const Wrench &	b )

operator*() [1/66]

Wrench KDL::operator*	(	const ArticulatedBodyInertia &	I,
		const Twist &	t )

calculate spatial momentum: h = I*v make sure that the twist v and the inertia are expressed in the same reference frame/point

operator*() [2/66]

TwistAcc KDL::operator*	(	const doubleAcc &	lhs,
		const TwistAcc &	rhs )

operator*() [3/66]

VectorAcc KDL::operator*	(	const doubleAcc &	r1,
		const VectorAcc &	r2 )

operator*() [4/66]

TwistVel KDL::operator*	(	const doubleVel &	lhs,
		const TwistVel &	rhs )

operator*() [5/66]

VectorVel KDL::operator*	(	const doubleVel &	r1,
		const VectorVel &	r2 )

operator*() [6/66]

Frame KDL::operator*	(	const Frame &	lhs,
		const Frame &	rhs )

operator*() [7/66]

FrameAcc KDL::operator*	(	const Frame &	lhs,
		const FrameAcc &	rhs )

operator*() [8/66]

FrameVel KDL::operator*	(	const Frame &	lhs,
		const FrameVel &	rhs )

operator*() [9/66]

ArticulatedBodyInertia KDL::operator*	(	const Frame &	T,
		const ArticulatedBodyInertia &	I )

Coordinate system transform Ia = T_a_b*Ib with T_a_b the frame from a to b.

operator*() [10/66]

RigidBodyInertia KDL::operator*	(	const Frame &	T,
		const RigidBodyInertia &	I )

Coordinate system transform Ia = T_a_b*Ib with T_a_b the frame from a to b.

operator*() [11/66]

IMETHOD Frame2 KDL::operator*	(	const Frame2 &	lhs,
		const Frame2 &	rhs )

operator*() [12/66]

FrameAcc KDL::operator*	(	const FrameAcc &	lhs,
		const Frame &	rhs )

operator*() [13/66]

FrameAcc KDL::operator*	(	const FrameAcc &	lhs,
		const FrameAcc &	rhs )

operator*() [14/66]

FrameVel KDL::operator*	(	const FrameVel &	lhs,
		const Frame &	rhs )

operator*() [15/66]

FrameVel KDL::operator*	(	const FrameVel &	lhs,
		const FrameVel &	rhs )

operator*() [16/66]

template<class T, class V, class S>

INLINE Rall1d< T, V, S > KDL::operator*	(	const Rall1d< T, V, S > &	lhs,
		const Rall1d< T, V, S > &	rhs )

operator*() [17/66]

template<class T, class V, class S>

INLINE Rall1d< T, V, S > KDL::operator*	(	const Rall1d< T, V, S > &	v,
		S	s )

operator*() [18/66]

template<class T, class V, class S>

INLINE Rall2d< T, V, S > KDL::operator*	(	const Rall2d< T, V, S > &	lhs,
		const Rall2d< T, V, S > &	rhs )

operator*() [19/66]

template<class T, class V, class S>

INLINE Rall2d< T, V, S > KDL::operator*	(	const Rall2d< T, V, S > &	v,
		S	s )

operator*() [20/66]

Wrench KDL::operator*	(	const RigidBodyInertia &	I,
		const Twist &	t )

calculate spatial momentum: h = I*v make sure that the twist v and the inertia are expressed in the same reference frame/point

operator*() [21/66]

ArticulatedBodyInertia KDL::operator*	(	const Rotation &	R,
		const ArticulatedBodyInertia &	I )

Reference frame orientation change Ia = R_a_b*Ib with R_a_b the rotation of b expressed in a

operator*() [22/66]

RigidBodyInertia KDL::operator*	(	const Rotation &	R,
		const RigidBodyInertia &	I )

Reference frame orientation change Ia = R_a_b*Ib with R_a_b the rotation of b expressed in a

operator*() [23/66]

VectorAcc KDL::operator*	(	const Rotation &	R,
		const VectorAcc &	x )

operator*() [24/66]

VectorVel KDL::operator*	(	const Rotation &	R,
		const VectorVel &	x )

operator*() [25/66]

RotationAcc KDL::operator*	(	const Rotation &	r1,
		const RotationAcc &	r2 )

operator*() [26/66]

RotationVel KDL::operator*	(	const Rotation &	r1,
		const RotationVel &	r2 )

operator*() [27/66]

IMETHOD Rotation2 KDL::operator*	(	const Rotation2 &	lhs,
		const Rotation2 &	rhs )

operator*() [28/66]

RotationAcc KDL::operator*	(	const RotationAcc &	r1,
		const Rotation &	r2 )

operator*() [29/66]

RotationAcc KDL::operator*	(	const RotationAcc &	r1,
		const RotationAcc &	r2 )

operator*() [30/66]

RotationVel KDL::operator*	(	const RotationVel &	r1,
		const Rotation &	r2 )

operator*() [31/66]

RotationVel KDL::operator*	(	const RotationVel &	r1,
		const RotationVel &	r2 )

operator*() [32/66]

Wrench KDL::operator* ( const Stiffness & s, const Twist & t )

inline

operator*() [33/66]

Twist KDL::operator*	(	const Twist &	lhs,
		const Twist &	rhs )

operator*() [34/66]

Wrench KDL::operator*	(	const Twist &	lhs,
		const Wrench &	rhs )

operator*() [35/66]

Twist KDL::operator*	(	const Twist &	lhs,
		double	rhs )

operator*() [36/66]

TwistAcc KDL::operator*	(	const TwistAcc &	lhs,
		const doubleAcc &	rhs )

operator*() [37/66]

TwistAcc KDL::operator*	(	const TwistAcc &	lhs,
		double	rhs )

operator*() [38/66]

TwistVel KDL::operator*	(	const TwistVel &	lhs,
		const doubleVel &	rhs )

operator*() [39/66]

TwistVel KDL::operator*	(	const TwistVel &	lhs,
		double	rhs )

operator*() [40/66]

Vector KDL::operator*	(	const Vector &	lhs,
		const Vector &	rhs )

operator*() [41/66]

Vector KDL::operator*	(	const Vector &	lhs,
		double	rhs )

operator*() [42/66]

VectorAcc KDL::operator*	(	const Vector &	r1,
		const VectorAcc &	r2 )

operator*() [43/66]

VectorVel KDL::operator*	(	const Vector &	r1,
		const VectorVel &	r2 )

operator*() [44/66]

IMETHOD Vector2 KDL::operator*	(	const Vector2 &	lhs,
		double	rhs )

operator*() [45/66]

VectorAcc KDL::operator*	(	const VectorAcc &	r1,
		const Vector &	r2 )

operator*() [46/66]

VectorAcc KDL::operator*	(	const VectorAcc &	r1,
		const VectorAcc &	r2 )

operator*() [47/66]

VectorAcc KDL::operator*	(	const VectorAcc &	r1,
		double	r2 )

operator*() [48/66]

VectorAcc KDL::operator*	(	const VectorAcc &	r2,
		const doubleAcc &	r1 )

operator*() [49/66]

VectorVel KDL::operator*	(	const VectorVel &	r1,
		const Vector &	r2 )

operator*() [50/66]

VectorVel KDL::operator*	(	const VectorVel &	r1,
		const VectorVel &	r2 )

operator*() [51/66]

VectorVel KDL::operator*	(	const VectorVel &	r1,
		double	r2 )

operator*() [52/66]

VectorVel KDL::operator*	(	const VectorVel &	r2,
		const doubleVel &	r1 )

operator*() [53/66]

Wrench KDL::operator*	(	const Wrench &	lhs,
		double	rhs )

operator*() [54/66]

ArticulatedBodyInertia KDL::operator*	(	double	a,
		const ArticulatedBodyInertia &	I )

Scalar product: I_new = double * I_old

operator*() [55/66]

RigidBodyInertia KDL::operator*	(	double	a,
		const RigidBodyInertia &	I )

Scalar product: I_new = double * I_old

operator*() [56/66]

RotationalInertia KDL::operator*	(	double	a,
		const RotationalInertia &	I )

operator*() [57/66]

Twist KDL::operator*	(	double	lhs,
		const Twist &	rhs )

operator*() [58/66]

TwistAcc KDL::operator*	(	double	lhs,
		const TwistAcc &	rhs )

operator*() [59/66]

TwistVel KDL::operator*	(	double	lhs,
		const TwistVel &	rhs )

operator*() [60/66]

Vector KDL::operator*	(	double	lhs,
		const Vector &	rhs )

operator*() [61/66]

IMETHOD Vector2 KDL::operator*	(	double	lhs,
		const Vector2 &	rhs )

operator*() [62/66]

Wrench KDL::operator*	(	double	lhs,
		const Wrench &	rhs )

operator*() [63/66]

VectorAcc KDL::operator*	(	double	r1,
		const VectorAcc &	r2 )

operator*() [64/66]

VectorVel KDL::operator*	(	double	r1,
		const VectorVel &	r2 )

operator*() [65/66]

template<class T, class V, class S>

INLINE Rall1d< T, V, S > KDL::operator*	(	S	s,
		const Rall1d< T, V, S > &	v )

operator*() [66/66]

template<class T, class V, class S>

INLINE Rall2d< T, V, S > KDL::operator*	(	S	s,
		const Rall2d< T, V, S > &	v )

operator+() [1/23]

ArticulatedBodyInertia KDL::operator+	(	const ArticulatedBodyInertia &	Ia,
		const ArticulatedBodyInertia &	Ib )

addition I: I_new = I_old1 + I_old2, make sure that I_old1 and I_old2 are expressed in the same reference frame/point, otherwise the result is worth nothing

operator+() [2/23]

ArticulatedBodyInertia KDL::operator+	(	const ArticulatedBodyInertia &	Ia,
		const RigidBodyInertia &	Ib )

operator+() [3/23]

template<class T, class V, class S>

INLINE Rall1d< T, V, S > KDL::operator+	(	const Rall1d< T, V, S > &	lhs,
		const Rall1d< T, V, S > &	rhs )

operator+() [4/23]

template<class T, class V, class S>

INLINE Rall1d< T, V, S > KDL::operator+	(	const Rall1d< T, V, S > &	v,
		S	s )

operator+() [5/23]

template<class T, class V, class S>

INLINE Rall2d< T, V, S > KDL::operator+	(	const Rall2d< T, V, S > &	lhs,
		const Rall2d< T, V, S > &	rhs )

operator+() [6/23]

template<class T, class V, class S>

INLINE Rall2d< T, V, S > KDL::operator+	(	const Rall2d< T, V, S > &	v,
		S	s )

operator+() [7/23]

RigidBodyInertia KDL::operator+	(	const RigidBodyInertia &	Ia,
		const RigidBodyInertia &	Ib )

addition I: I_new = I_old1 + I_old2, make sure that I_old1 and I_old2 are expressed in the same reference frame/point, otherwise the result is worth nothing

operator+() [8/23]

RotationalInertia KDL::operator+	(	const RotationalInertia &	Ia,
		const RotationalInertia &	Ib )

operator+() [9/23]

Stiffness KDL::operator+ ( const Stiffness & s1, const Stiffness & s2 )

inline

operator+() [10/23]

Twist KDL::operator+	(	const Twist &	lhs,
		const Twist &	rhs )

operator+() [11/23]

TwistAcc KDL::operator+	(	const TwistAcc &	lhs,
		const TwistAcc &	rhs )

operator+() [12/23]

TwistVel KDL::operator+	(	const TwistVel &	lhs,
		const TwistVel &	rhs )

operator+() [13/23]

IMETHOD Vector KDL::operator+	(	const Vector &	lhs,
		const Vector &	rhs )

operator+() [14/23]

VectorAcc KDL::operator+	(	const Vector &	r1,
		const VectorAcc &	r2 )

operator+() [15/23]

VectorVel KDL::operator+	(	const Vector &	r1,
		const VectorVel &	r2 )

operator+() [16/23]

IMETHOD Vector2 KDL::operator+	(	const Vector2 &	lhs,
		const Vector2 &	rhs )

operator+() [17/23]

VectorAcc KDL::operator+	(	const VectorAcc &	r1,
		const Vector &	r2 )

operator+() [18/23]

VectorAcc KDL::operator+	(	const VectorAcc &	r1,
		const VectorAcc &	r2 )

operator+() [19/23]

VectorVel KDL::operator+	(	const VectorVel &	r1,
		const Vector &	r2 )

operator+() [20/23]

VectorVel KDL::operator+	(	const VectorVel &	r1,
		const VectorVel &	r2 )

operator+() [21/23]

Wrench KDL::operator+	(	const Wrench &	lhs,
		const Wrench &	rhs )

operator+() [22/23]

template<class T, class V, class S>

INLINE Rall1d< T, V, S > KDL::operator+	(	S	s,
		const Rall1d< T, V, S > &	v )

operator+() [23/23]

template<class T, class V, class S>

INLINE Rall2d< T, V, S > KDL::operator+	(	S	s,
		const Rall2d< T, V, S > &	v )

operator-() [1/30]

ArticulatedBodyInertia KDL::operator-	(	const ArticulatedBodyInertia &	Ia,
		const ArticulatedBodyInertia &	Ib )

operator-() [2/30]

ArticulatedBodyInertia KDL::operator-	(	const ArticulatedBodyInertia &	Ia,
		const RigidBodyInertia &	Ib )

operator-() [3/30]

template<class T, class V, class S>

INLINE Rall1d< T, V, S > KDL::operator-

(

const Rall1d< T, V, S > &

arg

)

operator-() [4/30]

template<class T, class V, class S>

INLINE Rall1d< T, V, S > KDL::operator-	(	const Rall1d< T, V, S > &	lhs,
		const Rall1d< T, V, S > &	rhs )

operator-() [5/30]

template<class T, class V, class S>

INLINE Rall1d< T, V, S > KDL::operator-	(	const Rall1d< T, V, S > &	v,
		S	s )

operator-() [6/30]

template<class T, class V, class S>

INLINE Rall2d< T, V, S > KDL::operator-

(

const Rall2d< T, V, S > &

arg

)

operator-() [7/30]

template<class T, class V, class S>

INLINE Rall2d< T, V, S > KDL::operator-	(	const Rall2d< T, V, S > &	lhs,
		const Rall2d< T, V, S > &	rhs )

operator-() [8/30]

template<class T, class V, class S>

INLINE Rall2d< T, V, S > KDL::operator-	(	const Rall2d< T, V, S > &	v,
		S	s )

operator-() [9/30]

Twist KDL::operator-

(

const Twist &

arg

)

operator-() [10/30]

Twist KDL::operator-	(	const Twist &	lhs,
		const Twist &	rhs )

operator-() [11/30]

TwistAcc KDL::operator-

(

const TwistAcc &

arg

)

operator-() [12/30]

TwistAcc KDL::operator-	(	const TwistAcc &	lhs,
		const TwistAcc &	rhs )

operator-() [13/30]

TwistVel KDL::operator-

(

const TwistVel &

arg

)

operator-() [14/30]

TwistVel KDL::operator-	(	const TwistVel &	lhs,
		const TwistVel &	rhs )

operator-() [15/30]

Vector KDL::operator-

(

const Vector &

arg

)

operator-() [16/30]

IMETHOD Vector KDL::operator-	(	const Vector &	lhs,
		const Vector &	rhs )

operator-() [17/30]

VectorAcc KDL::operator-	(	const Vector &	r1,
		const VectorAcc &	r2 )

operator-() [18/30]

VectorVel KDL::operator-	(	const Vector &	r1,
		const VectorVel &	r2 )

operator-() [19/30]

IMETHOD Vector2 KDL::operator-

(

const Vector2 &

arg

)

operator-() [20/30]

IMETHOD Vector2 KDL::operator-	(	const Vector2 &	lhs,
		const Vector2 &	rhs )

operator-() [21/30]

VectorAcc KDL::operator-

(

const VectorAcc &

r

)

operator-() [22/30]

VectorAcc KDL::operator-	(	const VectorAcc &	r1,
		const Vector &	r2 )

operator-() [23/30]

VectorAcc KDL::operator-	(	const VectorAcc &	r1,
		const VectorAcc &	r2 )

operator-() [24/30]

VectorVel KDL::operator-

(

const VectorVel &

r

)

operator-() [25/30]

VectorVel KDL::operator-	(	const VectorVel &	r1,
		const Vector &	r2 )

operator-() [26/30]

VectorVel KDL::operator-	(	const VectorVel &	r1,
		const VectorVel &	r2 )

operator-() [27/30]

Wrench KDL::operator-

(

const Wrench &

arg

)

operator-() [28/30]

Wrench KDL::operator-	(	const Wrench &	lhs,
		const Wrench &	rhs )

operator-() [29/30]

template<class T, class V, class S>

INLINE Rall1d< T, V, S > KDL::operator-	(	S	s,
		const Rall1d< T, V, S > &	v )

operator-() [30/30]

template<class T, class V, class S>

INLINE Rall2d< T, V, S > KDL::operator-	(	S	s,
		const Rall2d< T, V, S > &	v )

operator/() [1/18]

template<class T, class V, class S>

INLINE Rall1d< T, V, S > KDL::operator/	(	const Rall1d< T, V, S > &	lhs,
		const Rall1d< T, V, S > &	rhs )

operator/() [2/18]

template<class T, class V, class S>

INLINE Rall1d< T, V, S > KDL::operator/	(	const Rall1d< T, V, S > &	v,
		S	s )

operator/() [3/18]

template<class T, class V, class S>

INLINE Rall2d< T, V, S > KDL::operator/	(	const Rall2d< T, V, S > &	lhs,
		const Rall2d< T, V, S > &	rhs )

operator/() [4/18]

template<class T, class V, class S>

INLINE Rall2d< T, V, S > KDL::operator/	(	const Rall2d< T, V, S > &	v,
		S	s )

operator/() [5/18]

Twist KDL::operator/	(	const Twist &	lhs,
		double	rhs )

operator/() [6/18]

TwistAcc KDL::operator/	(	const TwistAcc &	lhs,
		const doubleAcc &	rhs )

operator/() [7/18]

TwistAcc KDL::operator/	(	const TwistAcc &	lhs,
		double	rhs )

operator/() [8/18]

TwistVel KDL::operator/	(	const TwistVel &	lhs,
		const doubleVel &	rhs )

operator/() [9/18]

TwistVel KDL::operator/	(	const TwistVel &	lhs,
		double	rhs )

operator/() [10/18]

Vector KDL::operator/	(	const Vector &	lhs,
		double	rhs )

operator/() [11/18]

IMETHOD Vector2 KDL::operator/	(	const Vector2 &	lhs,
		double	rhs )

operator/() [12/18]

VectorAcc KDL::operator/	(	const VectorAcc &	r1,
		double	r2 )

operator/() [13/18]

VectorAcc KDL::operator/	(	const VectorAcc &	r2,
		const doubleAcc &	r1 )

operator/() [14/18]

VectorVel KDL::operator/	(	const VectorVel &	r1,
		double	r2 )

operator/() [15/18]

VectorVel KDL::operator/	(	const VectorVel &	r2,
		const doubleVel &	r1 )

operator/() [16/18]

Wrench KDL::operator/	(	const Wrench &	lhs,
		double	rhs )

operator/() [17/18]

template<class T, class V, class S>

INLINE Rall1d< T, V, S > KDL::operator/	(	S	s,
		const Rall1d< T, V, S > &	v )

operator/() [18/18]

template<class T, class V, class S>

INLINE Rall2d< T, V, S > KDL::operator/	(	S	s,
		const Rall2d< T, V, S > &	rhs )

operator<<() [1/26]

std::ostream & KDL::operator<<	(	std::ostream &	os,
		const Chain &	chain )

operator<<() [2/26]

std::ostream & KDL::operator<<	(	std::ostream &	os,
		const Frame &	T )

operator<<() [3/26]

std::ostream & KDL::operator<<	(	std::ostream &	os,
		const Frame2 &	T )

operator<<() [4/26]

std::ostream & KDL::operator<< ( std::ostream & os, const FrameAcc & r )

inline

operator<<() [5/26]

std::ostream & KDL::operator<< ( std::ostream & os, const FrameVel & r )

inline

operator<<() [6/26]

std::ostream & KDL::operator<<	(	std::ostream &	os,
		const Jacobian &	jac )

operator<<() [7/26]

std::ostream & KDL::operator<<	(	std::ostream &	os,
		const JntArray &	array )

operator<<() [8/26]

std::ostream & KDL::operator<<	(	std::ostream &	os,
		const JntSpaceInertiaMatrix &	jntspaceinertiamatrix )

operator<<() [9/26]

std::ostream & KDL::operator<<	(	std::ostream &	os,
		const Joint &	joint )

operator<<() [10/26]

template<class T, class V, class S>

std::ostream & KDL::operator<< ( std::ostream & os, const Rall1d< T, V, S > & r )

inline

operator<<() [11/26]

template<class T, class V, class S>

std::ostream & KDL::operator<<	(	std::ostream &	os,
		const Rall2d< T, V, S > &	r )

operator<<() [12/26]

std::ostream & KDL::operator<<	(	std::ostream &	os,
		const Rotation &	R )

operator<<() [13/26]

std::ostream & KDL::operator<<	(	std::ostream &	os,
		const Rotation2 &	R )

operator<<() [14/26]

std::ostream & KDL::operator<< ( std::ostream & os, const RotationAcc & r )

inline

operator<<() [15/26]

std::ostream & KDL::operator<< ( std::ostream & os, const RotationVel & r )

inline

operator<<() [16/26]

std::ostream & KDL::operator<<	(	std::ostream &	os,
		const Segment &	segment )

operator<<() [17/26]

std::ostream & KDL::operator<<	(	std::ostream &	os,
		const Tree &	tree )

operator<<() [18/26]

std::ostream & KDL::operator<<	(	std::ostream &	os,
		const Twist &	T )

operator<<() [19/26]

std::ostream & KDL::operator<< ( std::ostream & os, const TwistAcc & r )

inline

operator<<() [20/26]

std::ostream & KDL::operator<< ( std::ostream & os, const TwistVel & r )

inline

operator<<() [21/26]

std::ostream & KDL::operator<<	(	std::ostream &	os,
		const Vector &	v )

width to be used when printing variables out with frames_io.h global variable, can be changed.

operator<<() [22/26]

std::ostream & KDL::operator<<	(	std::ostream &	os,
		const Vector2 &	v )

operator<<() [23/26]

std::ostream & KDL::operator<< ( std::ostream & os, const VectorAcc & r )

inline

operator<<() [24/26]

std::ostream & KDL::operator<< ( std::ostream & os, const VectorVel & r )

inline

operator<<() [25/26]

std::ostream & KDL::operator<<	(	std::ostream &	os,
		const Wrench &	T )

operator<<() [26/26]

std::ostream & KDL::operator<<	(	std::ostream &	os,
		SegmentMap::const_iterator	it )

operator==() [1/21]

IMETHOD bool KDL::operator==	(	const Frame &	a,
		const Frame &	b )

operator==() [2/21]

bool KDL::operator==	(	const Frame &	r1,
		const FrameVel &	r2 )

operator==() [3/21]

bool KDL::operator==	(	const FrameVel &	r1,
		const Frame &	r2 )

operator==() [4/21]

bool KDL::operator==	(	const FrameVel &	r1,
		const FrameVel &	r2 )

operator==() [5/21]

bool KDL::operator==	(	const JntArray &	src1,
		const JntArray &	src2 )

operator==() [6/21]

template<class T, class V, class S>

INLINE bool KDL::operator==	(	const Rall1d< T, V, S > &	y,
		const Rall1d< T, V, S > &	x )

operator==() [7/21]

template<class T, class V, class S>

INLINE bool KDL::operator==	(	const Rall2d< T, V, S > &	y,
		const Rall2d< T, V, S > &	x )

operator==() [8/21]

bool KDL::operator==	(	const Rotation &	a,
		const Rotation &	b )

operator==() [9/21]

bool KDL::operator==	(	const Rotation &	r1,
		const RotationVel &	r2 )

operator==() [10/21]

bool KDL::operator==	(	const RotationVel &	r1,
		const Rotation &	r2 )

operator==() [11/21]

bool KDL::operator==	(	const RotationVel &	r1,
		const RotationVel &	r2 )

operator==() [12/21]

IMETHOD bool KDL::operator==	(	const Twist &	a,
		const Twist &	b )

operator==() [13/21]

bool KDL::operator==	(	const Twist &	a,
		const TwistVel &	b )

operator==() [14/21]

bool KDL::operator==	(	const TwistVel &	a,
		const TwistVel &	b )

operator==() [15/21]

bool KDL::operator==	(	const TwistVel &	r1,
		const Twist &	r2 )

operator==() [16/21]

IMETHOD bool KDL::operator==	(	const Vector &	a,
		const Vector &	b )

operator==() [17/21]

bool KDL::operator==	(	const Vector &	r1,
		const VectorVel &	r2 )

operator==() [18/21]

IMETHOD bool KDL::operator==	(	const Vector2 &	a,
		const Vector2 &	b )

operator==() [19/21]

bool KDL::operator==	(	const VectorVel &	r1,
		const Vector &	r2 )

operator==() [20/21]

bool KDL::operator==	(	const VectorVel &	r1,
		const VectorVel &	r2 )

operator==() [21/21]

IMETHOD bool KDL::operator==	(	const Wrench &	a,
		const Wrench &	b )

operator>>() [1/15]

std::istream & KDL::operator>>	(	std::istream &	is,
		Chain &	chain )

operator>>() [2/15]

std::istream & KDL::operator>>	(	std::istream &	is,
		Frame &	T )

operator>>() [3/15]

std::istream & KDL::operator>>	(	std::istream &	is,
		Frame2 &	T )

operator>>() [4/15]

std::istream & KDL::operator>>	(	std::istream &	is,
		Jacobian &	jac )

operator>>() [5/15]

std::istream & KDL::operator>>	(	std::istream &	is,
		JntArray &	array )

operator>>() [6/15]

std::istream & KDL::operator>>	(	std::istream &	is,
		JntSpaceInertiaMatrix &	jntspaceinertiamatrix )

operator>>() [7/15]

std::istream & KDL::operator>>	(	std::istream &	is,
		Joint &	joint )

operator>>() [8/15]

std::istream & KDL::operator>>	(	std::istream &	is,
		Rotation &	R )

operator>>() [9/15]

std::istream & KDL::operator>>	(	std::istream &	is,
		Rotation2 &	R )

operator>>() [10/15]

std::istream & KDL::operator>>	(	std::istream &	is,
		Segment &	segment )

operator>>() [11/15]

std::istream & KDL::operator>>	(	std::istream &	is,
		Tree &	tree )

operator>>() [12/15]

std::istream & KDL::operator>>	(	std::istream &	is,
		Vector &	v )

operator>>() [13/15]

std::istream & KDL::operator>>	(	std::istream &	is,
		Vector2 &	v )

operator>>() [14/15]

std::istream & KDL::operator>>	(	std::istream &	os,
		Twist &	T )

operator>>() [15/15]

std::istream & KDL::operator>>	(	std::istream &	os,
		Wrench &	T )

posrandom() [1/12]

void KDL::posrandom ( double & a )

inline

posrandom() [2/12]

IMETHOD void KDL::posrandom

(

doubleVel &

F

)

posrandom() [3/12]

IMETHOD void KDL::posrandom

(

Frame &

F

)

posrandom() [4/12]

IMETHOD void KDL::posrandom

(

FrameVel &

F

)

posrandom() [5/12]

IMETHOD void KDL::posrandom

(

Rotation &

R

)

posrandom() [6/12]

IMETHOD void KDL::posrandom

(

RotationVel &

R

)

posrandom() [7/12]

void KDL::posrandom ( Stiffness & F )

inline

posrandom() [8/12]

IMETHOD void KDL::posrandom

(

Twist &

a

)

posrandom() [9/12]

IMETHOD void KDL::posrandom

(

TwistVel &

a

)

posrandom() [10/12]

IMETHOD void KDL::posrandom

(

Vector &

a

)

posrandom() [11/12]

IMETHOD void KDL::posrandom

(

VectorVel &

a

)

posrandom() [12/12]

IMETHOD void KDL::posrandom

(

Wrench &

a

)

pow() [1/3]

template<class T, class V, class S>

INLINE Rall1d< T, V, S > KDL::pow	(	const Rall1d< T, V, S > &	arg,
		double	m )

pow() [2/3]

template<class T, class V, class S>

INLINE Rall2d< T, V, S > KDL::pow	(	const Rall2d< T, V, S > &	arg,
		double	m )

pow() [3/3]

double KDL::pow ( double a, double b )

inline

PYTHAG()

double KDL::PYTHAG ( double a, double b )

inline

random() [1/12]

void KDL::random ( double & a )

inline

random() [2/12]

IMETHOD void KDL::random

(

doubleVel &

F

)

random() [3/12]

IMETHOD void KDL::random

(

Frame &

F

)

random() [4/12]

IMETHOD void KDL::random

(

FrameVel &

F

)

random() [5/12]

IMETHOD void KDL::random

(

Rotation &

R

)

random() [6/12]

IMETHOD void KDL::random

(

RotationVel &

R

)

random() [7/12]

void KDL::random ( Stiffness & F )

inline

random() [8/12]

IMETHOD void KDL::random

(

Twist &

a

)

random() [9/12]

IMETHOD void KDL::random

(

TwistVel &

a

)

random() [10/12]

IMETHOD void KDL::random

(

Vector &

a

)

addDelta operator for displacement rotational velocity.

The Vector arguments here represent a displacement rotational velocity. i.e. a rotation around a fixed axis for a certain angle. For this representation you cannot use diff() but have to use diff_displ().

Parameters

a	: displacement rotational velocity
da	: rotational velocity

Returns

displacement rotational velocity

Warning

do not confuse displacement rotational velocities and velocities

do not confuse displacement twist and twist.

IMETHOD Vector addDelta_displ(const Vector& a,const Vector&da,double dt) { return getRot(addDelta(Rot(a),da,dt)); }

addDelta operator for displacement twist.

The Vector arguments here represent a displacement rotational velocity. i.e. a rotation around a fixed axis for a certain angle. For this representation you cannot use diff() but have to use diff_displ().

Parameters

a	: displacement twist
da	: twist

Returns

displacement twist

Warning

do not confuse displacement rotational velocities and velocities

do not confuse displacement twist and twist.

IMETHOD Twist addDelta_displ(const Twist& a,const Twist&da,double dt) { return Twist(addDelta(a.vel,da.vel,dt),addDelta_displ(a.rot,da.rot,dt)); }

random() [11/12]

IMETHOD void KDL::random

(

VectorVel &

a

)

random() [12/12]

IMETHOD void KDL::random

(

Wrench &

a

)

Rot()

IMETHOD Rotation KDL::Rot

(

const Vector &

axis_a_b

)

axis_a_b is a rotation vector, its norm is a rotation angle axis_a_b rotates the a frame towards the b frame. This routine returns the rotation matrix R_a_b

SetToIdentity() [1/3]

void KDL::SetToIdentity ( double & arg )

inline

to uniformly set double, RNDouble,Vector,... objects to the identity element in template-classes

SetToIdentity() [2/3]

template<class T, class V, class S>

INLINE void KDL::SetToIdentity

(

Rall1d< T, V, S > &

value

)

SetToIdentity() [3/3]

template<class T, class V, class S>

INLINE void KDL::SetToIdentity

(

Rall2d< T, V, S > &

value

)

SetToZero() [1/13]

void KDL::SetToZero ( double & arg )

inline

to uniformly set double, RNDouble,Vector,... objects to zero in template-classes

SetToZero() [2/13]

void KDL::SetToZero

(

Jacobian &

jac

)

SetToZero() [3/13]

void KDL::SetToZero

(

JntArray &

array

)

Function to set all the values of the array to 0

Parameters

array

SetToZero() [4/13]

void KDL::SetToZero

(

JntArrayAcc &

array

)

SetToZero() [5/13]

void KDL::SetToZero

(

JntArrayVel &

array

)

SetToZero() [6/13]

template<class T, class V, class S>

INLINE void KDL::SetToZero

(

Rall1d< T, V, S > &

value

)

SetToZero() [7/13]

template<class T, class V, class S>

INLINE void KDL::SetToZero

(

Rall2d< T, V, S > &

value

)

SetToZero() [8/13]

IMETHOD void KDL::SetToZero

(

Twist &

v

)

SetToZero() [9/13]

void KDL::SetToZero

(

TwistVel &

v

)

SetToZero() [10/13]

IMETHOD void KDL::SetToZero

(

Vector &

v

)

SetToZero() [11/13]

IMETHOD void KDL::SetToZero

(

Vector2 &

v

)

SetToZero() [12/13]

void KDL::SetToZero

(

VectorVel &

v

)

SetToZero() [13/13]

IMETHOD void KDL::SetToZero

(

Wrench &

v

)

SIGN()

double KDL::SIGN ( double a, double b )

inline

sign()

double KDL::sign ( double arg )

inline

sin() [1/3]

template<class T, class V, class S>

INLINE Rall1d< T, V, S > KDL::sin

(

const Rall1d< T, V, S > &

arg

)

sin() [2/3]

template<class T, class V, class S>

INLINE Rall2d< T, V, S > KDL::sin

(

const Rall2d< T, V, S > &

arg

)

sin() [3/3]

double KDL::sin ( double a )

inline

sinh() [1/3]

template<class T, class V, class S>

INLINE Rall1d< T, V, S > KDL::sinh

(

const Rall1d< T, V, S > &

arg

)

sinh() [2/3]

template<class T, class V, class S>

INLINE Rall2d< T, V, S > KDL::sinh

(

const Rall2d< T, V, S > &

arg

)

sinh() [3/3]

double KDL::sinh ( double a )

inline

sqr() [1/3]

template<class T, class V, class S>

INLINE Rall1d< T, V, S > KDL::sqr

(

const Rall1d< T, V, S > &

arg

)

sqr() [2/3]

template<class T, class V, class S>

INLINE Rall2d< T, V, S > KDL::sqr

(

const Rall2d< T, V, S > &

arg

)

sqr() [3/3]

double KDL::sqr ( double arg )

inline

sqrt() [1/3]

template<class T, class V, class S>

INLINE Rall1d< T, V, S > KDL::sqrt

(

const Rall1d< T, V, S > &

arg

)

sqrt() [2/3]

template<class T, class V, class S>

INLINE Rall2d< T, V, S > KDL::sqrt

(

const Rall2d< T, V, S > &

arg

)

sqrt() [3/3]

double KDL::sqrt ( double a )

inline

Subtract() [1/6]

void KDL::Subtract	(	const JntArray &	src1,
		const JntArray &	src2,
		JntArray &	dest )

Function to subtract two joint arrays, all the arguments must have the same size: A - B = C. This function is aliasing-safe, A or B can be the same array as C.

Parameters

src1	A
src2	B
dest	C

Subtract() [2/6]

void KDL::Subtract	(	const JntArrayAcc &	src1,
		const JntArray &	src2,
		JntArrayAcc &	dest )

Subtract() [3/6]

void KDL::Subtract	(	const JntArrayAcc &	src1,
		const JntArrayAcc &	src2,
		JntArrayAcc &	dest )

Subtract() [4/6]

void KDL::Subtract	(	const JntArrayAcc &	src1,
		const JntArrayVel &	src2,
		JntArrayAcc &	dest )

Subtract() [5/6]

void KDL::Subtract	(	const JntArrayVel &	src1,
		const JntArray &	src2,
		JntArrayVel &	dest )

Subtract() [6/6]

void KDL::Subtract	(	const JntArrayVel &	src1,
		const JntArrayVel &	src2,
		JntArrayVel &	dest )

svd_eigen_HH()

int KDL::svd_eigen_HH	(	const Eigen::MatrixXd &	A,
		Eigen::MatrixXd &	U,
		Eigen::VectorXd &	S,
		Eigen::MatrixXd &	V,
		Eigen::VectorXd &	tmp,
		int	maxiter = 150,
		double	epsilon = 1e-300 )

svd calculation of eigen matrices

Parameters

A	matrix<double>(mxn)
U	matrix<double>(mxn)
S	vector<double> n
V	matrix<double>(nxn)
tmp	vector<double> n
maxiter	defaults to 150

Returns

-2 if maxiter exceeded, 0 otherwise

svd_eigen_Macie()

int KDL::svd_eigen_Macie	(	const Eigen::MatrixXd &	A,
		Eigen::MatrixXd &	U,
		Eigen::VectorXd &	S,
		Eigen::MatrixXd &	V,
		Eigen::MatrixXd &	B,
		Eigen::VectorXd &	tempi,
		double	threshold,
		bool	toggle )

svd_eigen_Macie provides Maciejewski implementation for SVD.

computes the singular value decomposition of a matrix A, such that A=U*Sm*V

(Maciejewski and Klein,1989) and (Braun, Ulrey, Maciejewski and Siegel,2002)

Parameters

A	[INPUT] is an \(m \times n\)-matrix, where \( m \geq n \).
S	[OUTPUT] is an \(n\)-vector, representing the diagonal elements of the diagonal matrix Sm.
U	[INPUT/OUTPUT] is an \(m \times m\) orthonormal matrix.
V	[INPUT/OUTPUT] is an \(n \times n\) orthonormal matrix.
B	[TEMPORARY] is an \(m \times n\) matrix used for temporary storage.
tempi	[TEMPORARY] is an \(m\) vector used for temporary storage.
threshold	[INPUT] Threshold to determine orthogonality.
toggle	[INPUT] toggle this boolean variable on each call of this routine.

Returns

number of sweeps.

swap()

template<typename T>

void KDL::swap	(	scoped_ptr< T > &	a,
		scoped_ptr< T > &	b )

tan() [1/3]

template<class T, class V, class S>

INLINE Rall1d< T, V, S > KDL::tan

(

const Rall1d< T, V, S > &

arg

)

tan() [2/3]

template<class T, class V, class S>

INLINE Rall2d< T, V, S > KDL::tan

(

const Rall2d< T, V, S > &

arg

)

tan() [3/3]

double KDL::tan ( double a )

inline

tanh() [1/3]

template<class T, class V, class S>

INLINE Rall1d< T, V, S > KDL::tanh

(

const Rall1d< T, V, S > &

arg

)

tanh() [2/3]

template<class T, class V, class S>

INLINE Rall2d< T, V, S > KDL::tanh

(

const Rall2d< T, V, S > &

arg

)

tanh() [3/3]

double KDL::tanh ( double a )

inline

tree2str() [1/2]

std::string KDL::tree2str	(	const SegmentMap::const_iterator	it,
		const std::string &	separator = "  ",
		const std::string &	preamble = "",
		unsigned int	level = 0 )

tree2str() [2/2]

std::string KDL::tree2str	(	const Tree &	tree,
		const std::string &	separator = "  ",
		const std::string &	preamble = "" )

Variable Documentation

deg2rad

const double KDL::deg2rad

extern

the value pi/180

epsilon

double KDL::epsilon

extern

default precision while comparing with Equal(..,..) functions. Initialized at 0.0000001.

MAXLENFILENAME

int KDL::MAXLENFILENAME

extern

maximal length of a file name

PI

const double KDL::PI

extern

the value of pi

PI_2

const double KDL::PI_2

extern

the value of pi/2

PI_4

const double KDL::PI_4

extern

the value of pi/4

rad2deg

const double KDL::rad2deg

extern

the value 180/pi

STREAMBUFFERSIZE

int KDL::STREAMBUFFERSIZE

extern

/note linkage Something fishy about the difference between C++ and C in C++ const values default to INTERNAL linkage, in C they default to EXTERNAL linkage. Here the constants should have EXTERNAL linkage because they, for at least some of them, can be changed by the user. If you want to explicitly declare internal linkage, use "static".

VSIZE

int KDL::VSIZE

extern

the number of derivatives used in the RN-... objects.