Namespaces
	assert

	internal

	logging

	systems

	trajectories

Classes
class	AbstractValue
	A fully type-erased container class. More...

class	ArcLengthIntegrator
	Wraps maliput::drake::systems::AntiderivativeFunction<double> by using a pImpl. More...

class	copyable_unique_ptr
	A smart pointer with deep copy semantics. More...

struct	DelegatingHasher
	An adapter that forwards the HashAlgorithm::operator(data, length) function concept into a runtime-provided std::function of the same signature. More...

struct	dummy_value
	Provides a "dummy" value for a ScalarType – a value that is unlikely to be mistaken for a purposefully-computed value, useful for initializing a value before the true result is available. More...

struct	dummy_value< int >

class	EigenPtr
	This wrapper class provides a way to write non-template functions taking raw pointers to Eigen objects as parameters while limiting the number of copies, similar to `Eigen::Ref`. More...

struct	EigenSizeMinPreferDynamic
	EigenSizeMinPreferDynamic<a, b>::value gives the min between compile-time sizes `a` and `b`. More...

struct	EigenSizeMinPreferFixed
	EigenSizeMinPreferFixed is a variant of EigenSizeMinPreferDynamic. More...

class	Identifier
	A simple identifier class. More...

struct	IntegratorConfiguration
	Holds the configuration of the integrators. More...

class	InverseArcLengthIntegrator
	Wraps maliput::drake::systems::ScalarInitialValueProblem<double> by using a pImpl. More...

struct	is_eigen_nonvector_of

struct	is_eigen_scalar_same

struct	is_eigen_type

struct	is_eigen_vector

struct	is_eigen_vector_of

struct	MultiplyEigenSizes
	MultiplyEigenSizes<a, b> gives a * b if both of a and b are fixed sizes. More...

class	never_destroyed
	Wraps an underlying type T such that its storage is a direct member field of this object (i.e., without any indirection into the heap), but unlike most member fields T's destructor is never invoked. More...

class	NiceTypeName
	Obtains canonicalized, platform-independent, human-readable names for arbitrarily-complicated C++ types. More...

class	Polynomial
	A scalar multi-variate polynomial, modeled after the msspoly in spotless. More...

class	RandomGenerator
	Defines Drake's canonical implementation of the UniformRandomBitGenerator C++ concept (as well as a few conventional extras beyond the concept, e.g., seeds). More...

class	reset_on_copy
	Type wrapper that performs value-initialization on copy construction or assignment. More...

struct	scalar_predicate
	A traits struct that describes the return type of predicates over a scalar type (named `T`). More...

class	TypeSafeIndex
	A type-safe non-negative index class. More...

struct	uhash
	A hashing functor, somewhat like `std::hash`. More...

class	Value
	A container class for an arbitrary type T (with some restrictions). More...

Typedefs
template<typename T >
using	boolean = typename scalar_predicate< T >::type
	An alias for a boolean-like value, conditioned on the scalar type `T`. More...

template<typename Key , typename T >
using	eigen_aligned_std_map = std::map< Key, T, std::less< Key >, Eigen::aligned_allocator< std::pair< Key const, T > >>
	A std::map that uses Eigen::aligned_allocator so that the contained types may be fixed-size Eigen values. More...

template<typename Key , typename T >
using	eigen_aligned_std_unordered_map = std::unordered_map< Key, T, std::hash< Key >, std::equal_to< Key >, Eigen::aligned_allocator< std::pair< Key const, T > >>
	A std::unordered_map that uses Eigen::aligned_allocator so that the contained types may be fixed-size Eigen values. More...

template<typename T >
using	eigen_aligned_std_vector = std::vector< T, Eigen::aligned_allocator< T > >
	A std::vector that uses Eigen::aligned_allocator so that the contained types may be fixed-size Eigen values. More...

template<typename Scalar >
using	Vector0 = Eigen::Matrix< Scalar, 0, 1 >
	The empty column vector (zero rows, one column), templated on scalar type. More...

template<typename Scalar >
using	Vector1 = Eigen::Matrix< Scalar, 1, 1 >
	A column vector of size 1 (that is, a scalar), templated on scalar type. More...

using	Vector1d = Eigen::Matrix< double, 1, 1 >
	A column vector of size 1 of doubles. More...

template<typename Scalar >
using	Vector2 = Eigen::Matrix< Scalar, 2, 1 >
	A column vector of size 2, templated on scalar type. More...

template<typename Scalar >
using	Vector3 = Eigen::Matrix< Scalar, 3, 1 >
	A column vector of size 3, templated on scalar type. More...

template<typename Scalar >
using	Vector4 = Eigen::Matrix< Scalar, 4, 1 >
	A column vector of size 4, templated on scalar type. More...

template<typename Scalar >
using	Vector6 = Eigen::Matrix< Scalar, 6, 1 >
	A column vector of size 6. More...

using	Vector6d = Eigen::Matrix< double, 6, 1 >
	A column vector of size 6 of doubles. More...

template<typename Scalar , int Rows>
using	Vector = Eigen::Matrix< Scalar, Rows, 1 >
	A column vector templated on the number of rows. More...

template<typename Scalar >
using	VectorX = Eigen::Matrix< Scalar, Eigen::Dynamic, 1 >
	A column vector of any size, templated on scalar type. More...

template<typename Scalar >
using	VectorUpTo6 = Eigen::Matrix< Scalar, Eigen::Dynamic, 1, 0, 6, 1 >
	A vector of dynamic size templated on scalar type, up to a maximum of 6 elements. More...

template<typename Scalar >
using	RowVector2 = Eigen::Matrix< Scalar, 1, 2 >
	A row vector of size 2, templated on scalar type. More...

template<typename Scalar >
using	RowVector3 = Eigen::Matrix< Scalar, 1, 3 >
	A row vector of size 3, templated on scalar type. More...

template<typename Scalar >
using	RowVector4 = Eigen::Matrix< Scalar, 1, 4 >
	A row vector of size 4, templated on scalar type. More...

template<typename Scalar >
using	RowVector6 = Eigen::Matrix< Scalar, 1, 6 >
	A row vector of size 6. More...

template<typename Scalar , int Cols>
using	RowVector = Eigen::Matrix< Scalar, 1, Cols >
	A row vector templated on the number of columns. More...

template<typename Scalar >
using	RowVectorX = Eigen::Matrix< Scalar, 1, Eigen::Dynamic >
	A row vector of any size, templated on scalar type. More...

template<typename Scalar >
using	Matrix2 = Eigen::Matrix< Scalar, 2, 2 >
	A matrix of 2 rows and 2 columns, templated on scalar type. More...

template<typename Scalar >
using	Matrix3 = Eigen::Matrix< Scalar, 3, 3 >
	A matrix of 3 rows and 3 columns, templated on scalar type. More...

template<typename Scalar >
using	Matrix4 = Eigen::Matrix< Scalar, 4, 4 >
	A matrix of 4 rows and 4 columns, templated on scalar type. More...

template<typename Scalar >
using	Matrix6 = Eigen::Matrix< Scalar, 6, 6 >
	A matrix of 6 rows and 6 columns, templated on scalar type. More...

template<typename Scalar >
using	Matrix2X = Eigen::Matrix< Scalar, 2, Eigen::Dynamic >
	A matrix of 2 rows, dynamic columns, templated on scalar type. More...

template<typename Scalar >
using	Matrix3X = Eigen::Matrix< Scalar, 3, Eigen::Dynamic >
	A matrix of 3 rows, dynamic columns, templated on scalar type. More...

template<typename Scalar >
using	Matrix4X = Eigen::Matrix< Scalar, 4, Eigen::Dynamic >
	A matrix of 4 rows, dynamic columns, templated on scalar type. More...

template<typename Scalar >
using	Matrix6X = Eigen::Matrix< Scalar, 6, Eigen::Dynamic >
	A matrix of 6 rows, dynamic columns, templated on scalar type. More...

template<typename Scalar >
using	MatrixX = Eigen::Matrix< Scalar, Eigen::Dynamic, Eigen::Dynamic >
	A matrix of dynamic size, templated on scalar type. More...

template<typename Scalar >
using	MatrixUpTo6 = Eigen::Matrix< Scalar, Eigen::Dynamic, Eigen::Dynamic, 0, 6, 6 >
	A matrix of dynamic size templated on scalar type, up to a maximum of 6 rows and 6 columns. More...

template<typename Scalar >
using	Matrix6xUpTo6 = Eigen::Matrix< Scalar, 6, Eigen::Dynamic, 0, 6, 6 >
	A matrix of 6 rows and dynamic column size up to a maximum of 6, templated on scalar type. More...

template<typename Scalar >
using	Quaternion = Eigen::Quaternion< Scalar >
	A quaternion templated on scalar type. More...

template<typename Scalar >
using	AngleAxis = Eigen::AngleAxis< Scalar >
	An AngleAxis templated on scalar type. More...

template<typename Scalar >
using	Isometry3 = Eigen::Transform< Scalar, 3, Eigen::Isometry >
	An Isometry templated on scalar type. More...

template<typename Scalar >
using	Translation3 = Eigen::Translation< Scalar, 3 >
	A translation in 3D templated on scalar type. More...

template<typename Scalar >
using	TwistVector = Eigen::Matrix< Scalar, kTwistSize, 1 >
	A column vector consisting of one twist. More...

template<typename Scalar >
using	TwistMatrix = Eigen::Matrix< Scalar, kTwistSize, Eigen::Dynamic >
	A matrix with one twist per column, and dynamically many columns. More...

template<typename Scalar >
using	SquareTwistMatrix = Eigen::Matrix< Scalar, kTwistSize, kTwistSize >
	A six-by-six matrix. More...

template<typename Scalar >
using	WrenchVector = Eigen::Matrix< Scalar, 6, 1 >
	A column vector consisting of one wrench (spatial force) = `[r X f; f]`, where f is a force (translational force) applied at a point `P` and `r` is the position vector from a point `O` (called the "moment center") to point `P`. More...

using	DefaultHasher = internal::FNV1aHasher
	The default HashAlgorithm concept implementation across Drake. More...

using	DefaultHash = maliput::drake::uhash< DefaultHasher >
	The default hashing functor, akin to std::hash. More...

template<typename T >
using	is_cloneable = is_cloneable_internal::is_cloneable_helper< T, void >

typedef Polynomial< double >	Polynomiald

typedef Eigen::Matrix< Polynomiald, Eigen::Dynamic, 1 >	VectorXPoly
	A column vector of polynomials; used in several optimization classes. More...

Enumerations
enum	ToleranceType { kAbsolute, kRelative }

enum	RandomDistribution { kUniform = 0, kGaussian = 1, kExponential = 2 }
	Drake supports explicit reasoning about a few carefully chosen random distributions. More...

Functions
template<typename Derived >
Derived::Scalar	all (const Eigen::DenseBase< Derived > &m)
	Checks truth for all elements in matrix `m`. More...

template<typename Derived >
boolean< typename Derived::Scalar >	all_of (const Eigen::MatrixBase< Derived > &m, const std::function< boolean< typename Derived::Scalar >(const typename Derived::Scalar &)> &pred)
	Checks if unary predicate `pred` holds for all elements in the matrix `m`. More...

template<typename Derived >
Derived::Scalar	any (const Eigen::DenseBase< Derived > &m)
	Checks truth for at least one element in matrix `m`. More...

template<typename Derived >
boolean< typename Derived::Scalar >	any_of (const Eigen::MatrixBase< Derived > &m, const std::function< boolean< typename Derived::Scalar >(const typename Derived::Scalar &)> &pred)
	Checks if unary predicate `pred` holds for at least one element in the matrix `m`. More...

template<typename Derived >
Derived::Scalar	none (const Eigen::MatrixBase< Derived > &m)
	Checks that no elements of `m` are true. An empty matrix returns true. More...

template<typename Derived >
boolean< typename Derived::Scalar >	none_of (const Eigen::MatrixBase< Derived > &m, const std::function< boolean< typename Derived::Scalar >(const typename Derived::Scalar &)> &pred)
	Checks if unary predicate `pred` holds for no elements in the matrix `m`. More...

template<typename T >
	DRAKE_DEPRECATED ("2020-08-01", "Provide a specific overload of ExtractDoubleOrThrow for any " "type that really is sensible at compile time and should " "defer failure to runtime; this version was too generic.") typename std
	Converts a ScalarType value to a double, failing at runtime (not compile time) if the type cannot be converted to a double. More...

double	ExtractDoubleOrThrow (double scalar)
	Returns `scalar` as a double. Never throws. More...

template<typename Derived >
std::enable_if_t< std::is_same_v< typename Derived::Scalar, double >, Eigen::Matrix< double, Derived::RowsAtCompileTime, Derived::ColsAtCompileTime, Derived::Options, Derived::MaxRowsAtCompileTime, Derived::MaxColsAtCompileTime > >	ExtractDoubleOrThrow (const Eigen::MatrixBase< Derived > &matrix)
	Returns `matrix` as an Eigen::Matrix<double, ...> with the same size allocation as `matrix`. More...

template<class HashAlgorithm , class T >
std::enable_if_t< std::is_integral_v< T > >	hash_append (HashAlgorithm &hasher, const T &item) noexcept
	Provides hash_append generic hashing for integral constants. More...

template<class HashAlgorithm , class T >
std::enable_if_t< std::is_enum_v< T > >	hash_append (HashAlgorithm &hasher, const T &item) noexcept
	Provides hash_append generic hashing for enumerations. More...

template<class HashAlgorithm , class T >
std::enable_if_t< std::is_floating_point_v< T > >	hash_append (HashAlgorithm &hasher, const T &item) noexcept
	Provides hash_append generic hashing for floating point values. More...

template<class HashAlgorithm , class Traits , class Allocator >
void	hash_append (HashAlgorithm &hasher, const std::basic_string< char, Traits, Allocator > &item) noexcept
	Provides hash_append generic hashing for std::string. More...

template<class HashAlgorithm , class T1 , class T2 >
void	hash_append (HashAlgorithm &hasher, const std::pair< T1, T2 > &item) noexcept
	Provides hash_append generic hashing for std::pair. More...

template<class HashAlgorithm , class T >
void	hash_append (HashAlgorithm &hasher, const std::optional< T > &item) noexcept
	Provides hash_append generic hashing for std::optional. More...

template<class HashAlgorithm , class Iter >
void	hash_append_range (HashAlgorithm &hasher, Iter begin, Iter end) noexcept
	Provides hash_append generic hashing for a range, as given by two iterators. More...

template<class HashAlgorithm , class T1 , class T2 , class Compare , class Allocator >
void	hash_append (HashAlgorithm &hasher, const std::map< T1, T2, Compare, Allocator > &item) noexcept
	Provides hash_append generic hashing for std::map. More...

template<class HashAlgorithm , class Key , class Compare , class Allocator >
void	hash_append (HashAlgorithm &hasher, const std::set< Key, Compare, Allocator > &item) noexcept
	Provides hash_append generic hashing for std::set. More...

template<typename Tag >
std::string	to_string (const maliput::drake::Identifier< Tag > &id)
	Enables use of identifiers with to_string. More...

template<class T , class U >
std::unique_ptr< T >	static_pointer_cast (std::unique_ptr< U > &&other) noexcept
	Casts the object owned by the std::unique_ptr `other` from type `U` to `T`; no runtime type checking is performed. More...

template<class T , class U >
std::unique_ptr< T >	dynamic_pointer_cast (std::unique_ptr< U > &&other) noexcept
	Casts the object owned by the std::unique_ptr `other` from type `U` to `T`; if the cast fails, returns nullptr. More...

template<class T , class U >
std::unique_ptr< T >	dynamic_pointer_cast_or_throw (std::unique_ptr< U > &&other)
	Casts the object owned by the std::unique_ptr `other` from type `U` to `T`; if `other` is nullptr or the cast fails, throws a std::exception. More...

template<typename T >
Polynomial< T >	pow (const Polynomial< T > &base, typename Polynomial< T >::PowerType exponent)
	Provides power function for Polynomial. More...

template<typename T , int Rows, int Cols>
std::ostream &	operator<< (std::ostream &os, const Eigen::Matrix< Polynomial< T >, Rows, Cols > &poly_mat)

template<typename T >
T	CalcProbabilityDensity (RandomDistribution distribution, const Eigen::Ref< const VectorX< T >> &x)
	Calculates the density (probability density function) of the multivariate distribution. More...

template double	CalcProbabilityDensity< double > (RandomDistribution, const Eigen::Ref< const VectorX< double >> &)

logging::logger *	log ()
	Retrieve an instance of a logger to use for logging; for example: More...

template<typename Tag , typename U >
std::enable_if_t< std::is_integral_v< U > &&std::is_unsigned_v< U >, bool >	operator== (const U &value, const TypeSafeIndex< Tag > &tag)

template<typename Tag , typename U >
std::enable_if_t< std::is_integral_v< U > &&std::is_unsigned_v< U >, bool >	operator!= (const U &value, const TypeSafeIndex< Tag > &tag)

template<typename Tag , typename U >
std::enable_if_t< std::is_integral_v< U > &&std::is_unsigned_v< U >, bool >	operator< (const U &value, const TypeSafeIndex< Tag > &tag)

template<typename Tag , typename U >
std::enable_if_t< std::is_integral_v< U > &&std::is_unsigned_v< U >, bool >	operator<= (const U &value, const TypeSafeIndex< Tag > &tag)

template<typename Tag , typename U >
std::enable_if_t< std::is_integral_v< U > &&std::is_unsigned_v< U >, bool >	operator> (const U &value, const TypeSafeIndex< Tag > &tag)

template<typename Tag , typename U >
std::enable_if_t< std::is_integral_v< U > &&std::is_unsigned_v< U >, bool >	operator>= (const U &value, const TypeSafeIndex< Tag > &tag)

template<typename... Args>
void	unused (const Args &...)
	Documents the argument(s) as unused, placating GCC's -Wunused-parameter warning. More...

Variables
constexpr int	kQuaternionSize = 4

constexpr int	kSpaceDimension = 3

constexpr int	kRpySize = 3

constexpr int	kTwistSize = 6
	https://en.wikipedia.org/wiki/Screw_theory#Twist More...

constexpr int	kHomogeneousTransformSize = 16
	http://www.euclideanspace.com/maths/geometry/affine/matrix4x4/ More...

const int	kRotmatSize = kSpaceDimension * kSpaceDimension

constexpr bool	kDrakeAssertIsArmed = true

constexpr bool	kDrakeAssertIsDisarmed = false

constexpr char	kNameChars [] = "@#_.abcdefghijklmnopqrstuvwxyz"

const unsigned int	kNumNameChars = sizeof(kNameChars) - 1

const unsigned int	kNameLength = 4

const unsigned int	kMaxNamePart = 923521

Typedef Documentation

◆ AngleAxis

using AngleAxis = Eigen::AngleAxis<Scalar>

An AngleAxis templated on scalar type.

◆ boolean

using boolean = typename scalar_predicate<T>::type

An alias for a boolean-like value, conditioned on the scalar type T.

In many cases this will be a synonym for bool, e.g., when T = double. When T = symbolic::Expression, this is a synonym for symbolic::Formula. This is a convenience abbreviation for scalar_predicate<T>::type.

◆ DefaultHash

using DefaultHash = maliput::drake::uhash<DefaultHasher>

The default hashing functor, akin to std::hash.

◆ DefaultHasher

using DefaultHasher = internal::FNV1aHasher

The default HashAlgorithm concept implementation across Drake.

This is guaranteed to have a result_type of size_t to be compatible with std::hash.

◆ eigen_aligned_std_map

using eigen_aligned_std_map = std::map<Key, T, std::less<Key>, Eigen::aligned_allocator<std::pair<Key const, T> >>

A std::map that uses Eigen::aligned_allocator so that the contained types may be fixed-size Eigen values.

◆ eigen_aligned_std_unordered_map

using eigen_aligned_std_unordered_map = std::unordered_map<Key, T, std::hash<Key>, std::equal_to<Key>, Eigen::aligned_allocator<std::pair<Key const, T> >>

A std::unordered_map that uses Eigen::aligned_allocator so that the contained types may be fixed-size Eigen values.

◆ eigen_aligned_std_vector

using eigen_aligned_std_vector = std::vector<T, Eigen::aligned_allocator<T> >

A std::vector that uses Eigen::aligned_allocator so that the contained types may be fixed-size Eigen values.

◆ is_cloneable

using is_cloneable = is_cloneable_internal::is_cloneable_helper<T, void>

Provides method for determining at run time if a class is "cloneable".

Usage

This gets used like type_traits functions (e.g., is_copy_constructible, is_same, etc.) To determine if a class is cloneable simply invoke:

bool value = maliput::drake::is_cloneable<Foo>::value;

If Foo is cloneable, it will evaluate to true. It can also be used in compile-time tests (e.g., SFINAE and static_asserts):

static_assert(is_cloneable<Foo>::value, "This method requires its classes to "

"be cloneable.");

Definition of "cloneability"

To be cloneable, the class Foo must have a public method of the form:

unique_ptr<Foo> Foo::Clone() const;

Note that "friend" access for the is_cloneable-using class is not sufficient. The Foo::Clone() method must actually be public.

The pointer contained in the returned unique_ptr must point to a heap-allocated deep copy of the concrete object. This test can confirm the proper signature, but cannot confirm the heap-allocated deep copy. A Clone() method that doesn't return such a copy of the concrete object should be considered a malformed function.

Warning: It is important to note, that a Clone() method that returns a unique_ptr to a super class is not sufficient to be cloneable. In other words the presence of:
unique_ptr<Base> Derived::Clone() const;

will not make the Derived class cloneable.

Template Parameters

T	The class to test for cloneability.

◆ Isometry3

using Isometry3 = Eigen::Transform<Scalar, 3, Eigen::Isometry>

An Isometry templated on scalar type.

◆ Matrix2

using Matrix2 = Eigen::Matrix<Scalar, 2, 2>

A matrix of 2 rows and 2 columns, templated on scalar type.

◆ Matrix2X

using Matrix2X = Eigen::Matrix<Scalar, 2, Eigen::Dynamic>

A matrix of 2 rows, dynamic columns, templated on scalar type.

◆ Matrix3

using Matrix3 = Eigen::Matrix<Scalar, 3, 3>

A matrix of 3 rows and 3 columns, templated on scalar type.

◆ Matrix3X

using Matrix3X = Eigen::Matrix<Scalar, 3, Eigen::Dynamic>

A matrix of 3 rows, dynamic columns, templated on scalar type.

◆ Matrix4

using Matrix4 = Eigen::Matrix<Scalar, 4, 4>

A matrix of 4 rows and 4 columns, templated on scalar type.

◆ Matrix4X

using Matrix4X = Eigen::Matrix<Scalar, 4, Eigen::Dynamic>

A matrix of 4 rows, dynamic columns, templated on scalar type.

◆ Matrix6

using Matrix6 = Eigen::Matrix<Scalar, 6, 6>

A matrix of 6 rows and 6 columns, templated on scalar type.

◆ Matrix6X

using Matrix6X = Eigen::Matrix<Scalar, 6, Eigen::Dynamic>

A matrix of 6 rows, dynamic columns, templated on scalar type.

◆ Matrix6xUpTo6

using Matrix6xUpTo6 = Eigen::Matrix<Scalar, 6, Eigen::Dynamic, 0, 6, 6>

A matrix of 6 rows and dynamic column size up to a maximum of 6, templated on scalar type.

◆ MatrixUpTo6

using MatrixUpTo6 = Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, 0, 6, 6>

A matrix of dynamic size templated on scalar type, up to a maximum of 6 rows and 6 columns.

Rectangular matrices, with different number of rows and columns, are allowed.

◆ MatrixX

using MatrixX = Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic>

A matrix of dynamic size, templated on scalar type.

◆ Polynomiald

typedef Polynomial<double> Polynomiald

◆ Quaternion

using Quaternion = Eigen::Quaternion<Scalar>

A quaternion templated on scalar type.

◆ RowVector

using RowVector = Eigen::Matrix<Scalar, 1, Cols>

A row vector templated on the number of columns.

◆ RowVector2

using RowVector2 = Eigen::Matrix<Scalar, 1, 2>

A row vector of size 2, templated on scalar type.

◆ RowVector3

using RowVector3 = Eigen::Matrix<Scalar, 1, 3>

A row vector of size 3, templated on scalar type.

◆ RowVector4

using RowVector4 = Eigen::Matrix<Scalar, 1, 4>

A row vector of size 4, templated on scalar type.

◆ RowVector6

using RowVector6 = Eigen::Matrix<Scalar, 1, 6>

A row vector of size 6.

◆ RowVectorX

using RowVectorX = Eigen::Matrix<Scalar, 1, Eigen::Dynamic>

A row vector of any size, templated on scalar type.

◆ SquareTwistMatrix

using SquareTwistMatrix = Eigen::Matrix<Scalar, kTwistSize, kTwistSize>

A six-by-six matrix.

◆ Translation3

using Translation3 = Eigen::Translation<Scalar, 3>

A translation in 3D templated on scalar type.

◆ TwistMatrix

using TwistMatrix = Eigen::Matrix<Scalar, kTwistSize, Eigen::Dynamic>

A matrix with one twist per column, and dynamically many columns.

◆ TwistVector

using TwistVector = Eigen::Matrix<Scalar, kTwistSize, 1>

A column vector consisting of one twist.

◆ Vector

using Vector = Eigen::Matrix<Scalar, Rows, 1>

A column vector templated on the number of rows.

◆ Vector0

using Vector0 = Eigen::Matrix<Scalar, 0, 1>

The empty column vector (zero rows, one column), templated on scalar type.

◆ Vector1

using Vector1 = Eigen::Matrix<Scalar, 1, 1>

A column vector of size 1 (that is, a scalar), templated on scalar type.

◆ Vector1d

using Vector1d = Eigen::Matrix<double, 1, 1>

A column vector of size 1 of doubles.

◆ Vector2

using Vector2 = Eigen::Matrix<Scalar, 2, 1>

A column vector of size 2, templated on scalar type.

◆ Vector3

using Vector3 = Eigen::Matrix<Scalar, 3, 1>

A column vector of size 3, templated on scalar type.

◆ Vector4

using Vector4 = Eigen::Matrix<Scalar, 4, 1>

A column vector of size 4, templated on scalar type.

◆ Vector6

using Vector6 = Eigen::Matrix<Scalar, 6, 1>

A column vector of size 6.

◆ Vector6d

using Vector6d = Eigen::Matrix<double, 6, 1>

A column vector of size 6 of doubles.

◆ VectorUpTo6

using VectorUpTo6 = Eigen::Matrix<Scalar, Eigen::Dynamic, 1, 0, 6, 1>

A vector of dynamic size templated on scalar type, up to a maximum of 6 elements.

◆ VectorX

using VectorX = Eigen::Matrix<Scalar, Eigen::Dynamic, 1>

A column vector of any size, templated on scalar type.

◆ VectorXPoly

typedef Eigen::Matrix<Polynomiald, Eigen::Dynamic, 1> VectorXPoly

A column vector of polynomials; used in several optimization classes.

◆ WrenchVector

using WrenchVector = Eigen::Matrix<Scalar, 6, 1>

A column vector consisting of one wrench (spatial force) = [r X f; f], where f is a force (translational force) applied at a point P and r is the position vector from a point O (called the "moment center") to point P.

Enumeration Type Documentation

◆ RandomDistribution

enum RandomDistribution

strong

Drake supports explicit reasoning about a few carefully chosen random distributions.

Enumerator
kUniform	Vector elements are independent and uniformly distributed ∈ [0.0, 1.0).
kGaussian	Vector elements are independent and drawn from a mean-zero, unit-variance normal (Gaussian) distribution.
kExponential	Vector elements are independent and drawn from an exponential distribution with λ=1.0.

◆ ToleranceType

enum ToleranceType

strong

Enumerator
kAbsolute
kRelative

Function Documentation

◆ all()

Derived::Scalar maliput::drake::all ( const Eigen::DenseBase< Derived > & m )

Checks truth for all elements in matrix m.

This is identical to Eigen::DenseBase::all(), except this function allows for lazy evaluation, so works even when scalar_predicate<>::is_bool does not hold. An empty matrix returns true.

◆ all_of()

boolean<typename Derived::Scalar> maliput::drake::all_of	(	const Eigen::MatrixBase< Derived > &	m,
		const std::function< boolean< typename Derived::Scalar >(const typename Derived::Scalar &)> &	pred
	)

Checks if unary predicate pred holds for all elements in the matrix m.

An empty matrix returns true.

◆ any()

Derived::Scalar maliput::drake::any ( const Eigen::DenseBase< Derived > & m )

Checks truth for at least one element in matrix m.

This is identical to Eigen::DenseBase::any(), except this function allows for lazy evaluation, so works even when scalar_predicate<>::is_bool does not hold. An empty matrix returns false.

◆ any_of()

boolean<typename Derived::Scalar> maliput::drake::any_of	(	const Eigen::MatrixBase< Derived > &	m,
		const std::function< boolean< typename Derived::Scalar >(const typename Derived::Scalar &)> &	pred
	)

Checks if unary predicate pred holds for at least one element in the matrix m.

An empty matrix returns false.

◆ CalcProbabilityDensity()

T CalcProbabilityDensity	(	RandomDistribution	distribution,
		const Eigen::Ref< const VectorX< T >> &	x
	)

Calculates the density (probability density function) of the multivariate distribution.

Parameters

distribution	The distribution type.
x	The value of the sampled vector. @tparam_nonsymbolic_scalar

Note: When instantiating this function, the user needs to explicitly pass in the scalar type, for example CalcProbabilityDensity<double>(...), the compiler might have problem to deduce the scalar type automatically.

◆ CalcProbabilityDensity< double >()

template double maliput::drake::CalcProbabilityDensity< double >	(	RandomDistribution	,
		const Eigen::Ref< const VectorX< double >> &
	)

◆ DRAKE_DEPRECATED()

maliput::drake::DRAKE_DEPRECATED	(	"2020-08-01"	,
		"Provide a specific overload of ExtractDoubleOrThrow for any " "type that really is sensible at compile time and should " "defer failure to runtime; this version was too generic."
	)

Converts a ScalarType value to a double, failing at runtime (not compile time) if the type cannot be converted to a double.

This function is useful for writing ScalarType-generic code that (1) can reasonably discard any supplemental scalar data, e.g., the derivatives of an AutoDiffScalar, and (2) is reasonable to fail at runtime if the extraction fails.

The default implementation throws an exception. ScalarTypes that can hold a numeric value must overload this method to provide an appropriate extraction. An overload for double is already provided.

See autodiff_overloads.h to use this with Eigen's AutoDiffScalar. See symbolic_expression.h to use this with symbolic::Expression.

◆ dynamic_pointer_cast()

std::unique_ptr<T> maliput::drake::dynamic_pointer_cast ( std::unique_ptr< U > && other )

noexcept

Casts the object owned by the std::unique_ptr other from type U to T; if the cast fails, returns nullptr.

Casting is performed using dynamic_cast on the managed value (i.e., the result of other.get()). On success, other's managed value is transferred to the result and other is empty; on failure, other will retain its original managed value and the result is empty. As with dynamic_cast, casting nullptr to anything always succeeds, so a nullptr result could indicate either that the argument was nullptr or that the cast failed.

This method is analogous to the built-in std::dynamic_pointer_cast that operates on a std::shared_ptr.

Note that this function only supports default deleters.

◆ dynamic_pointer_cast_or_throw()

std::unique_ptr<T> maliput::drake::dynamic_pointer_cast_or_throw ( std::unique_ptr< U > && other )

Casts the object owned by the std::unique_ptr other from type U to T; if other is nullptr or the cast fails, throws a std::exception.

Casting is performed using dynamic_cast on the managed value (i.e., the result of other.get()). On success, other's managed value is transferred to the result and other is empty; on failure, other will retain its original managed value.

Exceptions

std::exception if the cast fails.

Note that this function only supports default deleters.

◆ ExtractDoubleOrThrow() [1/2]

std::enable_if_t<std::is_same_v<typename Derived::Scalar, double>, Eigen::Matrix<double, Derived::RowsAtCompileTime, Derived::ColsAtCompileTime, Derived::Options, Derived::MaxRowsAtCompileTime, Derived::MaxColsAtCompileTime> > maliput::drake::ExtractDoubleOrThrow ( const Eigen::MatrixBase< Derived > & matrix )

Returns matrix as an Eigen::Matrix<double, ...> with the same size allocation as matrix.

Calls ExtractDoubleOrThrow on each element of the matrix, and therefore throws if any one of the extractions fail.

◆ ExtractDoubleOrThrow() [2/2]

double maliput::drake::ExtractDoubleOrThrow ( double scalar )

Returns scalar as a double. Never throws.

◆ hash_append() [1/8]

void maliput::drake::hash_append	(	HashAlgorithm &	hasher,
		const std::basic_string< char, Traits, Allocator > &	item
	)

noexcept

Provides hash_append generic hashing for std::string.

(Technically, any string based on CharT = char.)

◆ hash_append() [2/8]

void maliput::drake::hash_append	(	HashAlgorithm &	hasher,
		const std::map< T1, T2, Compare, Allocator > &	item
	)

noexcept

Provides hash_append generic hashing for std::map.

Note that there is no hash_append overload for std::unordered_map, and such an overload must never appear. See n3980.html::unordered for details.

◆ hash_append() [3/8]

void maliput::drake::hash_append	(	HashAlgorithm &	hasher,
		const std::optional< T > &	item
	)

noexcept

Provides hash_append generic hashing for std::optional.

Note that std::hash<std::optional<T>> provides the peculiar invariant that the hash of an optional bearing a value v shall evaluate to the same hash as that of the value v itself. Hash operations implemented with this hash_append do not provide that invariant.

◆ hash_append() [4/8]

void maliput::drake::hash_append	(	HashAlgorithm &	hasher,
		const std::pair< T1, T2 > &	item
	)

noexcept

Provides hash_append generic hashing for std::pair.

◆ hash_append() [5/8]

void maliput::drake::hash_append	(	HashAlgorithm &	hasher,
		const std::set< Key, Compare, Allocator > &	item
	)

noexcept

Provides hash_append generic hashing for std::set.

Note that there is no hash_append overload for std::unordered_set, and such an overload must never appear. See n3980.html::unordered for details.

◆ hash_append() [6/8]

std::enable_if_t<std::is_integral_v<T> > maliput::drake::hash_append	(	HashAlgorithm &	hasher,
		const T &	item
	)

noexcept

Provides hash_append generic hashing for integral constants.

◆ hash_append() [7/8]

std::enable_if_t<std::is_enum_v<T> > maliput::drake::hash_append	(	HashAlgorithm &	hasher,
		const T &	item
	)

noexcept

Provides hash_append generic hashing for enumerations.

◆ hash_append() [8/8]

std::enable_if_t<std::is_floating_point_v<T> > maliput::drake::hash_append	(	HashAlgorithm &	hasher,
		const T &	item
	)

noexcept

Provides hash_append generic hashing for floating point values.

◆ hash_append_range()

void maliput::drake::hash_append_range	(	HashAlgorithm &	hasher,
		Iter	begin,
		Iter	end
	)

noexcept

Provides hash_append generic hashing for a range, as given by two iterators.

◆ log()

logging::logger * log ( )

  maliput::drake::log()->info("potato!")

See the text_logging.h documentation for a short tutorial.

◆ none()

Derived::Scalar maliput::drake::none ( const Eigen::MatrixBase< Derived > & m )

Checks that no elements of m are true. An empty matrix returns true.

◆ none_of()

boolean<typename Derived::Scalar> maliput::drake::none_of	(	const Eigen::MatrixBase< Derived > &	m,
		const std::function< boolean< typename Derived::Scalar >(const typename Derived::Scalar &)> &	pred
	)

Checks if unary predicate pred holds for no elements in the matrix m.

An empty matrix returns true.

◆ operator!=()

std::enable_if_t<std::is_integral_v<U> && std::is_unsigned_v<U>, bool> maliput::drake::operator!=	(	const U &	value,
		const TypeSafeIndex< Tag > &	tag
	)

◆ operator<()

std::enable_if_t<std::is_integral_v<U> && std::is_unsigned_v<U>, bool> maliput::drake::operator<	(	const U &	value,
		const TypeSafeIndex< Tag > &	tag
	)

◆ operator<<()

std::ostream& maliput::drake::operator<<	(	std::ostream &	os,
		const Eigen::Matrix< Polynomial< T >, Rows, Cols > &	poly_mat
	)

◆ operator<=()

std::enable_if_t<std::is_integral_v<U> && std::is_unsigned_v<U>, bool> maliput::drake::operator<=	(	const U &	value,
		const TypeSafeIndex< Tag > &	tag
	)

◆ operator==()

std::enable_if_t<std::is_integral_v<U> && std::is_unsigned_v<U>, bool> maliput::drake::operator==	(	const U &	value,
		const TypeSafeIndex< Tag > &	tag
	)

◆ operator>()

std::enable_if_t<std::is_integral_v<U> && std::is_unsigned_v<U>, bool> maliput::drake::operator>	(	const U &	value,
		const TypeSafeIndex< Tag > &	tag
	)

◆ operator>=()

std::enable_if_t<std::is_integral_v<U> && std::is_unsigned_v<U>, bool> maliput::drake::operator>=	(	const U &	value,
		const TypeSafeIndex< Tag > &	tag
	)

◆ pow()

Polynomial<T> maliput::drake::pow	(	const Polynomial< T > &	base,
		typename Polynomial< T >::PowerType	exponent
	)

Provides power function for Polynomial.

◆ static_pointer_cast()

std::unique_ptr<T> maliput::drake::static_pointer_cast ( std::unique_ptr< U > && other )

noexcept

Casts the object owned by the std::unique_ptr other from type U to T; no runtime type checking is performed.

This method is analogous to the built-in std::static_pointer_cast that operates on a std::shared_ptr.

Note that this function only supports default deleters.

◆ to_string()

std::string maliput::drake::to_string ( const maliput::drake::Identifier< Tag > & id )

Enables use of identifiers with to_string.

It requires ADL to work. So, it should be invoked as: to_string(id); and should be preceded by using std::to_string.

◆ unused()

void maliput::drake::unused ( const Args & ... )

Documents the argument(s) as unused, placating GCC's -Wunused-parameter warning.

This can be called within function bodies to mark that certain parameters are unused.

When possible, removing the unused parameter is better than placating the warning. However, in some cases the parameter is part of a virtual API or template concept that is used elsewhere, so we can't remove it. In those cases, this function might be an appropriate work-around.

Here's rough advice on how to fix Wunused-parameter warnings:

(1) If the parameter can be removed entirely, prefer that as the first choice. (This may not be possible if, e.g., a method must match some virtual API or template concept.)

(2) Unless the parameter name has acute value, prefer to omit the name of the parameter, leaving only the type, e.g.

void Print(const State& state) override { /* No state to print. */ }

changes to

void Print(const State&) override { /* No state to print. */}

This no longer triggers the warning and further makes it clear that a parameter required by the API is definitively unused in the function.

This is an especially good solution in the context of method definitions (vs declarations); the parameter name used in a definition is entirely irrelevant to Doxygen and most readers.

(3) When leaving the parameter name intact has acute value, it is acceptable to keep the name and mark it unused. For example, when the name appears as part of a virtual method's base class declaration, the name is used by Doxygen to document the method, e.g.,

   /** Sets the default State of a System.  This default implementation is to
*      set all zeros.  Subclasses may override to use non-zero defaults.  The
*      custom defaults may be based on the given @p context, when relevant.  */
   virtual void SetDefault(const Context<T>& context, State<T>* state) const {
     unused(context);
     state->SetZero();
   }

Variable Documentation

◆ kDrakeAssertIsArmed

constexpr bool kDrakeAssertIsArmed = true

constexpr

◆ kDrakeAssertIsDisarmed

constexpr bool kDrakeAssertIsDisarmed = false

constexpr

◆ kHomogeneousTransformSize

constexpr int kHomogeneousTransformSize = 16

constexpr

http://www.euclideanspace.com/maths/geometry/affine/matrix4x4/

◆ kMaxNamePart

const unsigned int kMaxNamePart = 923521

◆ kNameChars

constexpr char kNameChars[] = "@#_.abcdefghijklmnopqrstuvwxyz"

constexpr

◆ kNameLength

const unsigned int kNameLength = 4

◆ kNumNameChars

const unsigned int kNumNameChars = sizeof(kNameChars) - 1

◆ kQuaternionSize

constexpr int kQuaternionSize = 4

constexpr

◆ kRotmatSize

const int kRotmatSize = kSpaceDimension * kSpaceDimension

◆ kRpySize

constexpr int kRpySize = 3

constexpr

◆ kSpaceDimension

constexpr int kSpaceDimension = 3

constexpr

◆ kTwistSize

constexpr int kTwistSize = 6

constexpr

https://en.wikipedia.org/wiki/Screw_theory#Twist

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

◆ AngleAxis

◆ boolean

◆ DefaultHash

◆ DefaultHasher

◆ eigen_aligned_std_map

◆ eigen_aligned_std_unordered_map

◆ eigen_aligned_std_vector

◆ is_cloneable

◆ Isometry3

◆ Matrix2

◆ Matrix2X

◆ Matrix3

◆ Matrix3X

◆ Matrix4

◆ Matrix4X

◆ Matrix6

◆ Matrix6X

◆ Matrix6xUpTo6

◆ MatrixUpTo6

◆ MatrixX

◆ Polynomiald

◆ Quaternion

◆ RowVector

◆ RowVector2

◆ RowVector3

◆ RowVector4

◆ RowVector6

◆ RowVectorX

◆ SquareTwistMatrix

◆ Translation3

◆ TwistMatrix

◆ TwistVector

◆ Vector

◆ Vector0

◆ Vector1

◆ Vector1d

◆ Vector2

◆ Vector3

◆ Vector4

◆ Vector6

◆ Vector6d

◆ VectorUpTo6

◆ VectorX

◆ VectorXPoly

◆ WrenchVector

Enumeration Type Documentation

◆ RandomDistribution

◆ ToleranceType

Function Documentation

◆ all()

◆ all_of()

◆ any()

◆ any_of()

◆ CalcProbabilityDensity()

◆ CalcProbabilityDensity< double >()

◆ DRAKE_DEPRECATED()

◆ dynamic_pointer_cast()

◆ dynamic_pointer_cast_or_throw()

◆ ExtractDoubleOrThrow() [1/2]

◆ ExtractDoubleOrThrow() [2/2]

◆ hash_append() [1/8]

◆ hash_append() [2/8]

◆ hash_append() [3/8]

◆ hash_append() [4/8]

◆ hash_append() [5/8]

◆ hash_append() [6/8]

◆ hash_append() [7/8]

◆ hash_append() [8/8]

◆ hash_append_range()

◆ log()

◆ none()

◆ none_of()

◆ operator!=()