| Ndrake | |
| Nad | |
| CAutoDiff | A scalar type that performs automatic differentiation, similar to Eigen::AutoDiffScalar<Eigen::VectorXd> |
| CDerivativesConstXpr | The return type for AutoDiff::derivatives() when the AutoDiff is const |
| CDerivativesMutableXpr | The return type for AutoDiff::derivatives() when the AutoDiff is mutable |
| Nassert | |
| CConditionTraits< symbolic::Formula > | |
| Nexamples | |
| Nacrobot | |
| CAcrobotGeometry | Expresses an AcrobotPlant's geometry to a SceneGraph |
| CAcrobotInput | Specializes BasicVector with specific getters and setters |
| CAcrobotInputIndices | Describes the row indices of a AcrobotInput |
| CAcrobotParams | Specializes BasicVector with specific getters and setters |
| CAcrobotParamsIndices | Describes the row indices of a AcrobotParams |
| CAcrobotPlant | The Acrobot - a canonical underactuated system as described in Chapter 3 of Underactuated Robotics |
| CAcrobotSpongController | The Spong acrobot swing-up controller as described in: Spong, Mark W |
| CAcrobotState | Specializes BasicVector with specific getters and setters |
| CAcrobotStateIndices | Describes the row indices of a AcrobotState |
| CAcrobotWEncoder | Constructs the Acrobot with (only) encoder outputs |
| CSpongControllerParams | Specializes BasicVector with specific getters and setters |
| CSpongControllerParamsIndices | Describes the row indices of a SpongControllerParams |
| Ncompass_gait | |
| CCompassGait | Dynamical representation of the idealized hybrid dynamics of a "compass
gait", as described in http://underactuated.mit.edu/underactuated.html?chapter=simple_legs |
| CCompassGaitContinuousState | Specializes BasicVector with specific getters and setters |
| CCompassGaitContinuousStateIndices | Describes the row indices of a CompassGaitContinuousState |
| CCompassGaitGeometry | Expresses a CompassGait's geometry to a SceneGraph |
| CCompassGaitParams | Specializes BasicVector with specific getters and setters |
| CCompassGaitParamsIndices | Describes the row indices of a CompassGaitParams |
| Npendulum | |
| CPendulumGeometry | Expresses a PendulumPlants's geometry to a SceneGraph |
| CPendulumInput | Specializes BasicVector with specific getters and setters |
| CPendulumInputIndices | Describes the row indices of a PendulumInput |
| CPendulumParams | Specializes BasicVector with specific getters and setters |
| CPendulumParamsIndices | Describes the row indices of a PendulumParams |
| CPendulumPlant | A model of a simple pendulum |
| CPendulumState | Specializes BasicVector with specific getters and setters |
| CPendulumStateIndices | Describes the row indices of a PendulumState |
| Nquadrotor | |
| CQuadrotorGeometry | Expresses a QuadrotorPlant's geometry to a SceneGraph |
| CQuadrotorPlant | The Quadrotor - an underactuated aerial vehicle |
| Nrimless_wheel | |
| CRimlessWheel | Dynamical representation of the idealized hybrid dynamics of a "rimless
wheel", as described in http://underactuated.mit.edu/underactuated.html?chapter=simple_legs In addition, this model has two additional (discrete) state variables that are not required in the mathematical model: |
| CRimlessWheelContinuousState | Specializes BasicVector with specific getters and setters |
| CRimlessWheelContinuousStateIndices | Describes the row indices of a RimlessWheelContinuousState |
| CRimlessWheelGeometry | Expresses a RimlessWheel's geometry to a SceneGraph |
| CRimlessWheelParams | Specializes BasicVector with specific getters and setters |
| CRimlessWheelParamsIndices | Describes the row indices of a RimlessWheelParams |
| Nvan_der_pol | |
| CVanDerPolOscillator | Van der Pol oscillator |
| Ngeometry | |
| Noptimization | |
| CAffineBall | Implements an ellipsoidal convex set represented as an affine scaling of the unit ball {Bu + center | |u|₂ ≤ 1} |
| CAffineSubspace | An affine subspace (also known as a "flat", a "linear variety", or a "linear
manifold") is a vector subspace of some Euclidean space, potentially translated so as to not pass through the origin |
| CCartesianProduct | The Cartesian product of convex sets is a convex set: S = X₁ × X₂ × ⋯ × Xₙ = {(x₁, x₂, ..., xₙ) | x₁ ∈ X₁, x₂ ∈ X₂, ..., xₙ ∈ Xₙ} |
| CCIrisCollisionGeometry | This class contains the necessary information about the collision geometry used in C-IRIS |
| CConvexHull | Implements the convex hull of a set of convex sets |
| CConvexSet | Abstract base class for defining a convex set |
| CCspaceFreeBox | This class tries to find large axis-aligned bounding boxes in the configuration space, such that all configurations in the boxes are collision free |
| CSeparatingPlaneLagrangians | When searching for the separating plane, we want to certify that the numerator of a rational is non-negative in the C-space box q_box_lower <= q <= q_box_upper (or equivalently s_box_lower <= s <= s_box_upper) |
| CSeparationCertificateResult | We certify that a pair of geometries is collision free in the C-space box {q | q_box_lower<=q<=q_box_upper} by finding the separating plane and the Lagrangian multipliers |
| CSeparationCertificate | This struct stores the necessary information to search for the separating plane for the polytopic C-space box q_box_lower <= q <= q_box_upper |
| CSeparationCertificateProgram | |
| CCspaceFreePolytope | This class tries to find large convex polytopes in the tangential-configuration space, such that all configurations in the convex polytopes is collision free |
| CSeparatingPlaneLagrangians | When searching for the separating plane, we want to certify that the numerator of a rational is non-negative in the C-space region C*s<=d, s_lower <= s <= s_upper |
| CSeparationCertificateResult | We certify that a pair of geometries is collision free in the C-space region {s | Cs<=d, s_lower<=s<=s_upper} by finding the separating plane and the Lagrangian multipliers |
| CSeparationCertificate | This struct stores the necessary information to search for the separating plane for the polytopic C-space region C*s <= d, s_lower <= s <= s_upper |
| CSeparationCertificateProgram | |
| CFindSeparationCertificateGivenPolytopeOptions | |
| CFindPolytopeGivenLagrangianOptions | Options for finding polytope with given Lagrangians |
| CSearchResult | Result on searching the C-space polytope and separating planes |
| CBilinearAlternationOptions | Options for bilinear alternation |
| CBinarySearchOptions | Options for binary search |
| CCspaceFreePolytopeBase | This virtual class is the base of CspaceFreePolytope and CspaceFreeBox |
| COptions | Optional argument for constructing CspaceFreePolytopeBase |
| CCSpaceSeparatingPlane | Wraps the information that a pair of collision geometries are separated by a plane |
| CFindSeparationCertificateOptions | |
| CGcsGraphvizOptions | |
| CGraphOfConvexSets | GraphOfConvexSets (GCS) implements the design pattern and optimization problems first introduced in the paper "Shortest Paths in Graphs of Convex Sets" |
| CVertex | Each vertex in the graph has a corresponding ConvexSet, and a std::string name |
| CEdge | An edge in the graph connects between vertex u and vertex v |
| CGraphOfConvexSetsOptions | |
| CHPolyhedron | Implements a polyhedral convex set using the half-space representation: {x| A x ≤ b} |
| CHyperellipsoid | Implements an ellipsoidal convex set represented by the quadratic form {x
| (x-center)ᵀAᵀA(x-center) ≤ 1} |
| CHyperrectangle | Axis-aligned hyperrectangle in Rᵈ defined by its lower bounds and upper bounds as {x| lb ≤ x ≤ ub} |
| CImplicitGraphOfConvexSets | A base class to define the interface to an implicit graph of convex sets |
| CImplicitGraphOfConvexSetsFromExplicit | Provides an implicit GCS interface given an explicit GCS |
| CIntersection | A convex set that represents the intersection of multiple sets: S = X₁ ∩ X₂ ∩ ... ∩ Xₙ = {x | x ∈ X₁, x ∈ X₂, ..., x ∈ Xₙ} |
| CIrisOptions | Configuration options for the IRIS algorithm |
| CMinkowskiSum | A convex set that represents the Minkowski sum of multiple sets: S = X₁ ⨁ X₂ ⨁ ... ⨁ Xₙ = {x₁ + x₂ + ... + xₙ | x₁ ∈ X₁, x₂ ∈ X₂, ..., xₙ ∈ Xₙ} |
| CPlaneSeparatesGeometries | Contains the information to enforce a pair of geometries are separated by a plane |
| CPoint | A convex set that contains exactly one element |
| CSampledVolume | The result of a volume calculation from CalcVolumeViaSampling() |
| CSeparationCertificateProgramBase | |
| CSeparationCertificateResultBase | We certify that a pair of geometries is collision free by finding the separating plane over a range of configuration |
| CSpectrahedron | Implements a spectrahedron (the feasible set of a semidefinite program) |
| CVPolytope | A polytope described using the vertex representation |
| Nrender | |
| CClippingRange | Defines the near and far clipping planes for frustum-based (OpenGL) RenderEngine cameras |
| CColorRenderCamera | Collection of camera properties for cameras to be used with color/label images |
| CDepthRange | Defines a depth sensor's functional range |
| CDepthRenderCamera | Collection of camera properties for cameras to be used with depth images |
| CLightParameter | Light parameter for supporting RenderEngine implementations |
| CRenderCameraCore | Collection of core parameters for modeling a pinhole-model camera in a RenderEngine |
| CRenderEngine | The engine for performing rasterization operations on geometry |
| CRenderLabel | Class representing object "labels" for rendering |
| CAabb | Axis-aligned bounding box |
| CAabbMaker | AabbMaker implements the logic to fit an Aabb to a collection of points |
| CBox | Definition of a box |
| CCapsule | Definition of a capsule |
| CCollisionFilterDeclaration | Class for articulating changes to the configuration of SceneGraph's "collision filters"; collision filters limit the scope of various proximity queries |
| CCollisionFilterManager | Class for configuring "collision filters"; collision filters limit the scope of various proximity queries |
| CContactSurface | The ContactSurface characterizes the intersection of two geometries M and N as a contact surface with a scalar field and a vector field, whose purpose is to support the hydroelastic pressure field contact model as described in: |
| CConvex | Definition of a convex surface mesh |
| CCylinder | Definition of a cylinder |
| CDefaultProximityProperties | These properties will be used as defaults when the geometry as added via API calls or parsed from model files doesn't say anything more specific |
| CDrakeVisualizer | A system that publishes LCM messages representing the current state of a SceneGraph instance (whose QueryObject-valued output port is connected to this system's input port) |
| CDrakeVisualizerParams | The set of parameters for configuring DrakeVisualizer |
| CDrakeVisualizerTest | |
| CEllipsoid | Definition of an ellipsoid |
| CEnvironmentMap | |
| CEquirectangularMap | |
| CGeometryFrame | This simple class carries the definition of a frame used in the SceneGraph |
| CGeometryId | Type used to identify geometry instances in SceneGraph |
| CGeometryInstance | A geometry instance combines a geometry definition (i.e., a shape of some sort), a pose (relative to a parent "frame" P), material information, and an opaque collection of metadata |
| CGeometryProperties | The base class for defining a set of geometry properties |
| CGeometrySet | The GeometrySet, as its name implies, is a convenience class for defining a set of geometries |
| CGeometryState | The context-dependent state of SceneGraph |
| CGeometryVersion | A version numbering class that reports revisions of SceneGraph's geometric data |
| CGltfExtension | Specifies how to deal with glTF "extensions" (non-standard capabilities) |
| CHalfSpace | Definition of a half space |
| CIllustrationProperties | The set of properties for geometry used in an "illustration" role |
| CInMemoryMesh | Representation of a mesh file stored in memory |
| CKinematicsVector | A KinematicsVector is a container class used to report kinematics data for registered frames and geometries (keyed by unique FrameId/GeometryId values) to SceneGraph where the set of keys (FrameId/GeometryId) is usually constant and the values (kinematics data) are varying |
| CMesh | Definition of a general (possibly non-convex) mesh |
| CMeshcat | Provides an interface to Meshcat (https://github.com/meshcat-dev/meshcat) |
| CPerspectiveCamera | Properties for a perspective camera in three.js: https://threejs.org/docs/#api/en/cameras/PerspectiveCamera |
| COrthographicCamera | Properties for an orthographic camera in three.js: https://threejs.org/docs/#api/en/cameras/OrthographicCamera |
| CGamepad | Status of a gamepad obtained from the Meshcat javascript client |
| CVirtualSpringKinematics | The geometry of a virtual, interactive spring |
| CMeshcatAnimation | An interface for recording/playback animations in Meshcat |
| CMeshcatCone | Definition of a cone |
| CMeshcatParams | The set of parameters for configuring Meshcat |
| CPropertyTuple | A helper struct for the initial_properties params |
| CMeshcatPointCloudVisualizer | MeshcatPointCloudVisualizer is a systems::LeafSystem that publishes a perception::PointCloud from its input port to Meshcat |
| CMeshcatVisualizer | A system wrapper for Meshcat that publishes the current state of a dynamical diagram with MultibodyPlant and SceneGraph |
| CMeshcatVisualizerParams | The set of parameters for configuring MeshcatVisualizer |
| CMeshcatVisualizerSurfaceVelocityData | Provides MeshcatVisualizer the information it needs to interpret the surface_displacements input port |
| CMeshFieldLinear | MeshFieldLinear represents a continuous piecewise-linear scalar field f defined on a (triangular or tetrahedral) mesh; the field value changes linearly within each element E (triangle or tetrahedron), and the gradient ∇f is constant within each element |
| CMeshSource | Provides a general abstraction to the definition of a mesh |
| CNullTexture | (Internal use only) A place holder indicating that no texture has been provided for environment map (and, therefore, no environment map) |
| CObb | |
| CObbMaker | ObbMaker performs an algorithm to create an oriented bounding box that fits a specified set of vertices in a mesh |
| CObbMakerTester | |
| CPenetrationAsPointPair | A characterization of the intersection of two penetrating geometries |
| CPerceptionProperties | The set of properties for geometry used in a "perception" role |
| CPlane | The definition of a plane in ℜ³, posed in an arbitrary frame |
| CPolygonSurfaceMesh | PolygonSurfaceMesh represents a surface comprised of polygonal elements (three or more sides) |
| CPolygonSurfaceMeshTest | |
| Cpromoted_numerical | Given the two scalar types U and T, returns the most "promoted" type |
| CProximityProperties | The set of properties for geometry used in a proximity role |
| CQueryObject | The QueryObject serves as a mechanism to perform geometry queries on the world's geometry |
| CRenderEngineGlParams | Construction parameters for RenderEngineGl |
| CRenderEngineGltfClientParams | Construction parameters for the MakeRenderEngineGltfClient() to create a client as part of the glTF Render Client-Server API |
| CRenderEngineVtkParams | Construction parameters for the RenderEngineVtk |
| CRgba | Defines RGBA (red, green, blue, alpha) values on the range [0, 1] |
| CSceneGraph | SceneGraph serves as the nexus for all geometry (and geometry-based operations) in a Diagram |
| CSceneGraphConfig | The set of configurable properties on a SceneGraph |
| CSceneGraphInspector | The SceneGraphInspector serves as a mechanism to query the topological structure of a SceneGraph instance |
| CShape | The abstract base class for all shape specifications |
| CShapeReifier | The interface for converting shape descriptions to real shapes |
| CSignedDistancePair | The data for reporting the signed distance between two geometries, A and B |
| CSignedDistanceToPoint | The data for reporting the signed distance from a query point to a geometry |
| CSphere | Definition of sphere |
| CSsaoParameter | Screen-space ambient occlusion (SSAO) parameters |
| CSurfacePolygon | Representation of a polygonal face in a SurfacePolygon |
| CSurfaceTriangle | SurfaceTriangle represents a triangular face in a TriangleSurfaceMesh |
| CTriangleSurfaceMesh | TriangleSurfaceMesh represents a union of triangles |
| CTriangleSurfaceMeshTester | |
| CVolumeElement | VolumeElement represents a tetrahedral element in a VolumeMesh |
| CVolumeMesh | VolumeMesh represents a tetrahedral volume mesh |
| CVolumeMeshTester | |
| Nlcm | |
| CDrakeLcm | A wrapper around a real LCM instance |
| CDrakeLcmBase | A concrete subclass of DrakeInterface that throws for all functions except the constructor and destructor |
| CDrakeLcmInterface | A pure virtual interface that enables LCM to be mocked |
| CDrakeLcmLog | A LCM interface for logging LCM messages to a file or playing back from a existing log |
| CDrakeLcmParams | The set of parameters for configuring DrakeLcm |
| CDrakeSubscriptionInterface | A helper class returned by DrakeLcmInterface::Subscribe() that allows for (possibly automatic) unsubscription and/or queue capacity control |
| CSubscriber | Subscribes to and stores a copy of the most recent message on a given channel, for some Message type |
| Nlogging | |
| Clogger | The singleton class returned by Drake's drake::log() function, offering functions to emit log messages |
| CWarn | When constructed, logs a message (at "warn" severity); the destructor is guaranteed to be trivial |
| Nmanipulation | |
| Nfranka_panda | |
| CPandaCommandReceiver | Handles lcmt_panda_command message from a LcmSubscriberSystem |
| CPandaCommandSender | Creates and outputs lcmt_panda_command messages |
| CPandaStatusReceiver | Handles lcmt_panda_status messages from a LcmSubscriberSystem |
| CPandaStatusSender | Creates and outputs lcmt_panda_status messages |
| Nkinova_jaco | |
| CJacoCommandReceiver | Handles lcmt_jaco_command message from a LcmSubscriberSystem |
| CJacoCommandSender | Creates and outputs lcmt_jaco_command messages |
| CJacoStatusReceiver | Handles lcmt_jaco_status messages from a LcmSubscriberSystem |
| CJacoStatusSender | Creates and outputs lcmt_jaco_status messages |
| Nkuka_iiwa | |
| CIiwaCommandReceiver | Handles lcmt_iiwa_command message from a LcmSubscriberSystem |
| CIiwaCommandSender | Creates and outputs lcmt_iiwa_command messages |
| CIiwaControlPorts | The return type of BuildSimplifiedIiwaControl() |
| CIiwaDriver | This config struct specifies how to wire up Drake systems between an LCM interface and the actuation input ports of a MultibodyPlant |
| CIiwaStatusReceiver | Handles lcmt_iiwa_status messages from a LcmSubscriberSystem |
| CIiwaStatusSender | Creates and outputs lcmt_iiwa_status messages |
| CSimIiwaDriver | SimIiwaDriver simulates the IIWA control and status interface using a MultibodyPlant |
| Nschunk_wsg | |
| CMultibodyForceToWsgForceSystem | Extract the gripper measured force from the generalized forces on the two fingers |
| CSchunkWsgCommandReceiver | Handles the command for the Schunk WSG gripper from a LcmSubscriberSystem |
| CSchunkWsgCommandSender | Send lcmt_schunk_wsg_command messages for a Schunk WSG gripper |
| CSchunkWsgController | This class implements a controller for a Schunk WSG gripper |
| CSchunkWsgDriver | This config struct specifies how to wire up Drake systems between an LCM interface and the actuation input ports of a MultibodyPlant |
| CSchunkWsgPdController | This class implements a controller for a Schunk WSG gripper in position control mode |
| CSchunkWsgPlainController | This class implements a controller for a Schunk WSG gripper as a systems::Diagram |
| CSchunkWsgPositionController | This class implements a controller for a Schunk WSG gripper in position control mode adding a discrete-derivative to estimate the desired velocity from the desired position commands |
| CSchunkWsgStatusReceiver | Handles lcmt_schunk_wsg_status messages from a LcmSubscriberSystem |
| CSchunkWsgStatusSender | Sends lcmt_schunk_wsg_status messages for a Schunk WSG |
| CSchunkWsgTrajectoryGenerator | This system defines input ports for the desired finger position represented as the desired distance between the fingers in meters and the desired force limit in newtons, and emits target position/velocity for the actuated finger to reach the commanded target, expressed as the negative of the distance between the two fingers in meters |
| CSchunkWsgTrajectoryGeneratorStateVector | Specializes BasicVector with specific getters and setters |
| CSchunkWsgTrajectoryGeneratorStateVectorIndices | Describes the row indices of a SchunkWsgTrajectoryGeneratorStateVector |
| Nutil | |
| CMoveIkDemoBase | This class provides some common functionality for generating IK plans for robot arms, including things like creating a MultibodyPlant, setting joint velocity limits, implementing a robot status update handler suitable for invoking from an LCM callback, and generating plans to move a specified link to a goal configuration |
| CMovingAverageFilter | The implementation of a Moving Average Filter |
| CRobotPlanInterpolator | This class implements a source of joint positions for a robot |
| CZeroForceDriver | A driver that applies zero actuation to every joint of a model |
| Nmath | |
| CBarycentricMesh | Represents a multi-linear function (from vector inputs to vector outputs) by interpolating between points on a mesh using (triangular) barycentric interpolation |
| CBsplineBasis | Given a set of non-descending breakpoints t₀ ≤ t₁ ≤ ⋅⋅⋅ ≤ tₘ, a B-spline basis of order k is a set of n + 1 (where n = m - k) piecewise polynomials of degree k - 1 defined over those breakpoints |
| CGetSubMatrixGradientArray | |
| CGetSubMatrixGradientSingleElement | |
| CGradient | Recursively defined template specifying a matrix type of the correct size for a gradient of a matrix function with respect to nq variables, of any order |
| CGradient< Derived, nq, 1 > | Base case for recursively defined gradient template |
| CGrayCodesMatrix | GrayCodesMatrix::type returns an Eigen matrix of integers |
| CLinearSolver | Solves a linear system of equations A*x=b |
| CMatGradMult | |
| CMatGradMultMat | |
| CNumericalGradientOption | |
| CRigidTransform | This class represents a proper rigid transform between two frames which can be regarded in two ways |
| CRollPitchYaw | This class represents the orientation between two arbitrary frames A and D associated with a Space-fixed (extrinsic) X-Y-Z rotation by "roll-pitch-yaw" angles [r, p, y], which is equivalent to a Body-fixed (intrinsic) Z-Y-X rotation by "yaw-pitch-roll" angles [y, p, r] |
| CRotationMatrix | This class represents a 3x3 rotation matrix between two arbitrary frames A and B and helps ensure users create valid rotation matrices |
| Nmultibody | |
| Nbenchmarks | |
| Nacrobot | |
| CAcrobotParameters | This class is used to store the numerical parameters defining the model of an acrobot with the method MakeAcrobotPlant() |
| Nfree_body | |
| CFreeBody | The purpose of the FreeBody class is to provide the data (initial values and gravity) and methods for calculating the exact analytical solution for the translational and rotational motion of a torque-free rigid body B with axially symmetric inertia, in a Newtonian frame (World) N |
| Npendulum | |
| CPendulumParameters | This class is used to store the numerical parameters defining the model of a simple pendulum with the method MakePendulumPlant() |
| CAcrobot | The Acrobot - a canonical underactuated system as described in Chapter 3 of Underactuated Robotics |
| CMassDamperSpringAnalyticalSolution | This class provides an analytical solution to a mass-damper-spring system |
| Ncontact_solvers | |
| Nicf | |
| CIcfSolverParameters | (Advanced) Parameters to configure the Irrotational Contact Fields (ICF) convex solver |
| Nfem | |
| CDampingModel | A viscous Rayleigh damping model in which the damping matrix D is a linear combination of mass and stiffness matrices, as, D = αM + βK where α and β are nonnegative |
| CDeformableBodyConfig | DeformableBodyConfig stores the physical parameters for a deformable body |
| CFemModel | FemModel calculates the components of the spatially discretized FEM equations for dynamic elasticity problems |
| CBuilder | Builder that builds the FemModel |
| CFemPlantData | |
| CFemState | FemState provides access to private workspace FEM state and per-element state-dependent data |
| Nmeshcat | |
| CContactVisualizer | ContactVisualizer is a system that publishes a ContactResults to geometry::Meshcat; For point contact results, it draws double-sided arrows at the location of the contact force with length scaled by the magnitude of the contact force |
| CContactVisualizerParams | The set of parameters for configuring ContactVisualizer |
| CJointSliders | JointSliders adds slider bars to the Meshcat control panel for the joints of a MultibodyPlant |
| CMeshcatMouseSpring | MeshcatMouseSpring lets a user drag the bodies of a MultibodyPlant with the mouse in a Meshcat browser, applying a virtual spring force that pulls the grabbed point toward the cursor |
| Nparsing | |
| CAddCollisionFilterGroup | Directive to add a collision filter group |
| CAddDirectives | Directive to incorporate another model directives file, optionally with its elements prefixed with a namespace |
| CAddFrame | Directive to add a Frame to the scene |
| CAddModel | Directive to add a model from a URDF or SDFormat file to a scene, using a given name for the added instance |
| CAddModelInstance | Directive to add an empty, named model instance to a scene |
| CAddWeld | Directive to add a weld between two named frames, a parent and a child |
| CModelDirective | Union structure for model directives |
| CModelDirectives | Top-level structure for a model directives yaml file schema |
| CModelInstanceInfo | Convenience structure to hold all of the information to add a model instance from a file |
| CAddMultibodyPlantSceneGraphResult | Temporary result from AddMultibodyPlantSceneGraph |
| CAngleBetweenVectorsConstraint | Constrains that the angle between a vector a and another vector b is between [θ_lower, θ_upper] |
| CAngleBetweenVectorsCost | Implements a cost of the form c*(1-cosθ), where θ is the angle between two vectors a and b |
| CArticulatedBodyInertia | Articulated Body Inertia is the inertia that a body appears to have when it is the base (or root) of a rigid-body system, also referred to as Articulated Body in the context of articulated body algorithms |
| CBallRpyJoint | This Joint allows two bodies to rotate freely relative to one another |
| CBinding | A binding on constraint type C is a mapping of the decision variables onto the inputs of C |
| CBoundingBoxConstraint | Implements a constraint of the form \( lb <= x <= ub \) |
| CCalcGridPointsOptions | |
| CCenicIntegrator | Convex Error-controlled Numerical Integration for Contact (CENIC) is a specialized error-controlled implicit integrator for contact-rich robotics simulations [Kurtz and Castro, 2025] |
| CCentroidalMomentumConstraint | Impose the constraint CentroidalMomentum(q, v) - h_WC = 0 with decision variables [q;v;h_WC] or CentroidalAngularMomentum(q, v) - k_WC = 0 with decision variables [q; v; k_WC] h_WC is the 6D spatial momentum (linear and angular momentum about the center of mass C) expressed in the world frame (W) |
| CCollisionFilterGroups | This is storage for parsed collision filter groups and group pairs |
| CComInPolyhedronConstraint | Constrains the center of mass to lie within a polyhedron lb <= A * p_EC <= ub where p_EC is the position of the center-of-mass (C) expressed in a frame E |
| CComPositionConstraint | Impose the constraint p_EScm(q) - p_EC = 0, where p_EScm(q) is a function that computes the center-of-mass (COM) position from robot generalized position q, expressed in a frame E |
| CConstraintRelaxingIk | A wrapper class around the IK planner |
| CIkCartesianWaypoint | Cartesian waypoint |
| CContactResults | A container class storing the contact results information for each contact pair for a given state of the simulation |
| CContactResultsToLcmSystem | A System that encodes ContactResults into a lcmt_contact_results_for_viz message |
| CContactWrench | Stores the contact wrench (spatial force) from Body A to Body B applied at point Cb |
| CContactWrenchEvaluator | |
| CContactWrenchFromForceInWorldFrameEvaluator | The contact wrench is τ_AB_W = 0, f_AB_W = λ Namely we assume that λ is the contact force from A to B, applied directly at B's witness point |
| CCoulombFriction | Parameters for Coulomb's Law of Friction, namely: |
| CCurvilinearJoint | A Joint that allows a body to move along a piecewise constant curvature path contained in a plane |
| CDeformableBody | The DeformableBody class represents a single deformable element within a MultibodyPlant |
| CDeformableContactInfo | A class containing information regarding contact and contact response between two geometries belonging to a pair of bodies with at least one of them being a deformable body |
| CDeformableContactInfo< symbolic::Expression > | Full specialization of DeformableContactInfo for T = Expression, with no member data |
| CDeformableModel | DeformableModel implements the interface in PhysicalModel and provides the functionalities to specify deformable bodies |
| CDifferentialInverseKinematicsController | Differential Inverse Kinematics controller that tracks desired poses / velocities for multiple operational points |
| CDifferentialInverseKinematicsIntegrator | A LeafSystem that integrates successive calls to DoDifferentialInverseKinematics (which produces joint velocity commands) to produce joint position commands |
| CDifferentialInverseKinematicsParameters | Contains parameters for the family of differential inverse kinematics function overloads below, each named DoDifferentialInverseKinematics() |
| CDifferentialInverseKinematicsResult | |
| CDifferentialInverseKinematicsSystem | The DifferentialInverseKinematicsSystem takes as input desired cartesian poses (or cartesian velocities) for an arbitrary number of "goal" frames on the robot, and produces a generalized velocity command as output to move the goal frames toward the desired state |
| CCallbackDetails | (Internal use only) A group of common arguments relevant to multiple different costs and constraints within the DifferentialInverseKinematicsSystem program formulation |
| CIngredient | (Internal use only) A user-provided set of constraint(s) and/or cost(s) for a DifferentialInverseKinematicsSystem recipe, to allow for user customization of the mathematical program formulation |
| CRecipe | A recipe collects a list of ingredients for DifferentialInverseKinematicsSystem, allowing the user to customize the program being solved |
| CLeastSquaresCost | Provides a primary DifferentialInverseKinematicsSystem objective to minimize G*| S * (Vd_TGs - Jv_TGs * v_next)|², also known as the "least squares" formulation |
| CConfig | |
| CJointCenteringCost | Provides a secondary minimization objective |
| CConfig | |
| CCartesianPositionLimitConstraint | Constrains the goal frames to a cartesian bounding box: ∀i p_TG_next_lower ≤ p_TGi + Jv_TGi[3:6] * v_next * Δt ≤ p_TG_next_upper where: |
| CConfig | |
| CCartesianVelocityLimitConstraint | Constrains the spatial velocities of the goal frames: ∀i, ∀j ∈ [0, 5]: abs(Jv_TGi * v_next)[j] ≤ V_next_TG_limit[j] |
| CConfig | |
| CCollisionConstraint | Constrains the collision clearance around the robot to remain above the safety distance: ∀j ϕₛ ≤ ϕⱼ + ∂ϕⱼ/∂q_active * v_next * Δt where: |
| CConfig | |
| CJointVelocityLimitConstraint | Constrains the generalized velocity to prevent a commanded velocity that would push the generalized position outside its limits |
| CConfig | |
| CDistanceConstraint | Constrains the distance between a pair of geometries to be within a range [distance_lower, distance_upper] |
| CDistanceConstraintParams | Parameters for a distance constraint |
| CDoorHinge | This ForceElement models a revolute DoorHinge joint that could exhibit different force/torque characteristics at different states due to the existence of different type of torques on the joint |
| CDoorHingeConfig | Configuration structure for the DoorHinge |
| CExternallyAppliedSpatialForce | |
| CExternallyAppliedSpatialForceMultiplexer | Concatenates multiple std::vector<>'s of ExternallyAppliedSpatialForce<T> |
| CFixedOffsetFrame | FixedOffsetFrame represents a material frame F whose pose is fixed with respect to a parent material frame P |
| CForceDensityField | Implementations of the ForceDensityFieldBase class should inherit from this class |
| CForceDensityFieldBase | The ForceDensityFieldBase class is an abstract base class that represents a force density field affecting deformable bodies in a MultibodyPlant |
| CForceElement | A ForceElement allows modeling state and time dependent forces in a MultibodyPlant model |
| CFrame | Frame is an abstract class representing a material frame (also called a physical frame) of its underlying RigidBody (Link) |
| CGaussianTriangleQuadratureRule | |
| CGazeTargetConstraint | Constrains a target point T to be within a cone K |
| CGeometryPairContactWrenchEvaluatorBinding | |
| CGlobalInverseKinematics | Solves the inverse kinematics problem as a mixed integer convex optimization problem |
| COptions | |
| CPolytope3D | Describes a polytope in 3D as 𝐀 * 𝐱 ≤ 𝐛 (a set of half-spaces), where 𝐀 ∈ ℝⁿˣ³, 𝐱 ∈ ℝ³, 𝐛 ∈ ℝⁿ |
| CGravityForceField | A uniform gravitational force density field for a uniform density object |
| CHydroelasticContactInfo | A class containing information regarding contact and contact response between two geometries attached to a pair of bodies |
| CHydroelasticContactInfo< symbolic::Expression > | Full specialization of HydroelasticContactInfo for T = Expression, with no member data |
| CInverseKinematics | Solves an inverse kinematics (IK) problem on a MultibodyPlant, to find the postures of the robot satisfying certain constraints |
| CJoint | A Joint models the kinematical relationship which characterizes the possible relative motion between two bodies |
| CJointActuator | The JointActuator class is mostly a simple bookkeeping structure to represent an actuator acting on a given Joint |
| CLinearBushingRollPitchYaw | This ForceElement models a massless flexible bushing that connects a frame A of a link (body) L0 to a frame C of a link (body) L1 |
| CLinearConstraint | Implements a constraint of the form \( lb <= Ax <= ub \) |
| CLinearCost | Implements a cost of the form |
| CLinearSpringDamper | This ForceElement models a spring-damper attached between two points on two different bodies (links) |
| CManipulatorEquationConstraint | A Constraint to impose the manipulator equation: 0 = (Buₙ₊₁ + ∑ᵢ (Jᵢ_WBᵀ(qₙ₊₁)ᵀ * Fᵢ_AB_W(λᵢ,ₙ₊₁)) |
| CMinimumDistanceLowerBoundConstraint | Constrain min(d) >= lb, namely the signed distance between all candidate pairs of geometries (according to the logic of SceneGraphInspector::GetCollisionCandidates()) to be no smaller than a specified minimum distance lb |
| CMinimumDistanceUpperBoundConstraint | Constrain min(d) <= ub, namely at least one signed distance between a candidate pairs of geometries (according to the logic of SceneGraphInspector::GetCollisionCandidates()) to be no larger than a specified ub |
| CMultibodyElement | A class representing an element (subcomponent) of a MultibodyPlant or (internally) a MultibodyTree |
| CMultibodyForces | Holds a set of forces applied to a MultibodyTree system |
| CMultibodyPlant | MultibodyPlant is a Drake system framework representation (see systems::System) for the model of a physical system consisting of a collection of interconnected bodies |
| CMultibodyPlantConfig | The set of configurable properties on a MultibodyPlant |
| COrientationConstraint | Constrains that the angle difference θ between the orientation of frame A and the orientation of frame B to satisfy θ ≤ θ_bound |
| COrientationCost | Implements a cost of the form c * (1 - cos(θ)), where θ is the angle between the orientation of frame A and the orientation of frame B, and c is a cost scaling |
| CPackageMap | Maps ROS package names to their full path on the local file system |
| CRemoteParams | Parameters used for AddRemote() |
| CParser | Parses model description input into a MultibodyPlant and (optionally) a SceneGraph |
| CPdControllerGains | PD controller gains |
| CPhysicalModel | (Internal) PhysicalModel provides the functionalities to extend the type of physical model of MultibodyPlant |
| CPiecewisePolynomial | A scalar multi-variate piecewise polynomial |
| CPlanarJoint | This joint models a planar joint allowing two bodies to translate and rotate relative to one another in a plane with three degrees of freedom |
| CPointPairContactInfo | A class containing information regarding contact response between two bodies including: |
| CPointToLineDistanceConstraint | Constrain that the distance between a point P on frame B1 and another line L on frame B2 is within a range [distance_lower, distance_upper] |
| CPointToPointDistanceConstraint | Constrain that the distance between a point P1 on frame B1 and another point P2 on frame B2 is within a range [distance_lower, distance_upper] |
| CPolyhedronConstraint | Constrain the position of points P1, P2, ..., Pn to satisfy the constraint A |
| CPositionConstraint | Constrains the position of a point Q, rigidly attached to a frame B, to be within a bounding box measured and expressed in frame A |
| CPositionCost | Implements a cost of the form (p_AP - p_AQ)ᵀ C (p_AP - p_AQ), where point P is specified relative to frame A and point Q is specified relative to frame B, and the cost is evaluated in frame A |
| CPrismaticJoint | This Joint allows two bodies to translate relative to one another along a common axis |
| CPrismaticSpring | This ForceElement models a linear spring attached to a PrismaticJoint and applies a force to that joint according to |
| CPropeller | A System that connects to the MultibodyPlant in order to model the effects of one or more controlled propellers acting on a Body |
| CPropellerInfo | Parameters that describe the kinematic frame and force-production properties of a single propeller |
| CQuaternionEulerIntegrationConstraint | If we have a body with orientation quaternion z₁ at time t₁, and a quaternion z₂ at time t₂ = t₁ + h, with the angular velocity ω (expressed in the world frame), we impose the constraint that the body rotates at a constant velocity ω from quaternion z₁ to quaternion z₂ within time interval h |
| CQuaternionFloatingJoint | This Joint allows two bodies to move freely relatively to one another |
| CRationalForwardKinematics | For certain robots (whose joint transforms are algebraic functions of joint variables, for example revolute/prismatic/floating-base joints), we can represent the pose (position, orientation) of each body, as rational functions, namely n(s) / d(s) where both the numerator n(s) and denominator d(s) are polynomials of s, and s is some variable related to the generalized position |
| CPose | This is a proxy for math::RigidTransform |
| CRevoluteJoint | This Joint allows two bodies to rotate relatively to one another around a common axis |
| CRevoluteSpring | This ForceElement models a torsional spring attached to a RevoluteJoint and applies a torque to that joint |
| CRigidBody | The term rigid body implies that the deformations of the body under consideration are so small that they have no significant effect on the overall motions of the body and therefore deformations can be neglected |
| CRigidBodyFrame | A RigidBodyFrame (aka LinkFrame) is a material Frame that serves as the unique reference frame for a RigidBody (aka Link) |
| CRotationalInertia | This class describes the mass distribution (inertia properties) of a body or composite body about a particular point |
| CRpyFloatingJoint | This Joint allows a rigid body to move freely with respect to its parent rigid body |
| CScopedName | A delimited string name for a multibody element, e.g., "robot1::torso" |
| CScrewJoint | This joint models a screw joint allowing two bodies to rotate about one axis while translating along that same axis with one degree of freedom |
| CSignedDistanceWithTimeDerivative | The struct containing the signed distance and its time derivative between a pair of geometries |
| CSolverInterface | Interface used by implementations of individual solvers |
| CSpatialAcceleration | This class represents a spatial acceleration A and has 6 elements with an angular (rotational) acceleration α (3-element vector) on top of a translational (linear) acceleration 𝐚 (3-element vector) |
| CSpatialForce | This class represents a spatial force F (also called a wrench) and has 6 elements with a torque 𝛕 (3-element vector) on top of a force 𝐟 (3-element vector) |
| CSpatialInertia | This class represents the physical concept of a Spatial Inertia |
| CSpatialMomentum | This class represents a spatial momentum L and has 6 elements with an angular (rotational) momentum 𝐡 (3-element vector) on top of a translational (linear) momentum 𝐥 (3-element vector) |
| CSpatialVector | This class represents a spatial vector and has 6 elements, with a 3-element rotational vector on top of a 3-element translational vector |
| CSpatialVelocity | This class represents a spatial velocity V (also called a twist) and has 6 elements with an angular (rotational) velocity ω (3-element vector) on top of a translational (linear) velocity v (3-element vector) |
| CSpatialVelocityConstraint | Constrains the spatial velocity of a frame C, rigidly attached to a frame B, measured and expressed in frame A |
| CAngularVelocityBounds | Parametrizes bounds on the magnitude and direction of the angular velocity vector |
| CStaticEquilibriumConstraint | Impose the static equilibrium constraint 0 = τ_g + Bu + ∑J_WBᵀ(q) * Fapp_B_W |
| CStaticEquilibriumProblem | Finds the static equilibrium pose of a multibody system through optimization |
| CStaticFrictionConeConstraint | Formulates the nonlinear friction cone constraint |fₜ| ≤ μ*fₙ, where fₜ is the tangential contact force, fₙ is the normal contact force, and μ is the friction coefficient |
| CToppra | Solves a Time Optimal Path Parameterization based on Reachability Analysis (TOPPRA) to find the fastest traversal of a given path, satisfying the given constraints |
| CTrajectory | A Trajectory represents a time-varying matrix, indexed by a single scalar time |
| CTriangleQuadrature | A class for integrating a function using numerical quadrature over triangular domains |
| CTriangleQuadratureRule | A "rule" (weights and quadrature points) for computing quadrature over triangular domains |
| CUniformGravityFieldElement | This ForceElement allows modeling the effect of a uniform gravity field as felt by bodies on the surface of the Earth or elsewhere |
| CUnitInertia | This class is used to represent rotational inertias for unit mass bodies |
| CUnitQuaternionConstraint | Constrains the quaternion to have a unit length |
| CUniversalJoint | This joint models a universal joint allowing two bodies to rotate relative to one another with two degrees of freedom |
| CWeldJoint | This Joint fixes the relative pose between two frames as if "welding" them together |
| CWing | A System that connects to the MultibodyPlant in order to model the simplified dynamics of an airfoil (or hydrofoil) |
| Nperception | |
| Npc_flags | Point cloud flags |
| CDescriptorType | Describes an descriptor field with a name and the descriptor's size |
| CFields | Allows combination of BaseField and DescriptorType for a PointCloud |
| CDepthImageToPointCloud | Converts a depth image to a point cloud |
| CPointCloud | Implements a point cloud (with contiguous storage), whose main goal is to offer a convenient, synchronized interface to commonly used fields and data types applicable for basic 3D perception |
| CPointCloudToLcm | Converts PointCloud inputs to lcmt_point_cloud output messages |
| Nplanning | |
| Nexperimental | |
| CBodySpheres | Container for all spheres belonging to a single body's collision model |
| CDistanceAndGradient | Wrapper that combines a distance value and gradient |
| CMbpEnvironmentCollisionChecker | Sphere-model robot collision checker using MbP/SG to model environment geometry |
| CPlaceholder | This is a stub class to exercise the build system |
| CPointSignedDistanceAndGradientResult | Wrapper for multiple distance and gradient values |
| CSphereRobotModelCollisionChecker | Base class for collision checkers using a sphere-geometry robot model |
| CSphereSpecification | Class modelling collision spheres used for collision checking |
| CVoxelizedEnvironmentCollisionChecker | Collision checker using a voxelized environment model |
| CVoxelOccupancyMap | |
| CVoxelSignedDistanceField | Container for voxelized signed distance fields |
| CGenerationParameters | Param struct for generating a VoxelSignedDistanceField |
| CVoxelTaggedObjectOccupancyMap | |
| Ngraph_algorithms | |
| CMaxCliqueSolverBase | The problem of finding the maximum clique in a graph is known to be NP-complete |
| CMaxCliqueSolverViaGreedy | Approximately solves the maximum clique problem via a greedy heuristic |
| CMaxCliqueSolverViaMip | Solves the maximum clique problem to global optimality by solving the mixed-integer program |
| CMinCliqueCoverSolverBase | |
| CMinCliqueCoverSolverViaGreedy | Approximately solves the min clique cover problem via a greedy heuristic |
| Ntrajectory_optimization | |
| CDirectCollocation | DirectCollocation implements the approach to trajectory optimization as described in C |
| CDirectCollocationConstraint | Implements the direct collocation constraints for a first-order hold on the input and a cubic polynomial representation of the state trajectories |
| CDirectTranscription | DirectTranscription is perhaps the simplest implementation of a multiple shooting method, where we have decision variables representing the control and input at every sample time in the trajectory, and one-step of numerical integration provides the dynamic constraints between those decision variables |
| CGcsTrajectoryOptimization | GcsTrajectoryOptimization implements a simplified motion planning optimization problem introduced in the paper "Motion Planning around Obstacles with Convex Optimization" by Tobia Marcucci, Mark Petersen, David von Wrangel, Russ Tedrake |
| CSubgraph | A Subgraph is a subset of the larger graph |
| CEdgesBetweenSubgraphs | EdgesBetweenSubgraphs are defined as the connecting edges between two given subgraphs |
| CKinematicTrajectoryOptimization | Optimizes a trajectory, q(t) subject to costs and constraints on the trajectory and its derivatives |
| CMidPointIntegrationConstraint | Implements the midpoint integration |
| CMultipleShooting | MultipleShooting is an abstract class for trajectory optimization that creates decision variables for inputs, states, and (optionally) sample times along the trajectory, then provides a number of methods for working with those decision variables |
| CTimeStep | |
| CBodyShapeDescription | BodyShapeDescription captures all the information necessary to describe a SceneGraph collision shape associated with a MultibodyPlant Body: a shape S, the MultibodyPlant body B (identified by model instance and body names), and the rigid pose of the shape S relative to the body B, X_BS |
| CCollisionChecker | Interface for collision checkers to use |
| CAddedShape | Representation of an "added" shape |
| CCollisionCheckerContext | This class represents the data necessary for CollisionChecker to operate safely across multiple threads in its const API |
| CCollisionCheckerParams | A set of common constructor parameters for a CollisionChecker |
| CCommonSampledIrisOptions | Various options which are common to the sampling-based algorithms IrisNp2 and IrisZo for generating collision free polytopes in configuration space |
| CDistanceAndInterpolationProvider | This class represents the base interface for performing configuration distance and interpolation operations, used by CollisionChecker |
| CDofMask | A mask on the degrees of freedom (dofs) of a MultibodyPlant instance, partitioning the plant's dofs into "selected" and "unselected" dofs |
| CEdgeMeasure | The measure of the distance of the edge from q1 to q2 and the portion of that is collision free |
| CIrisFromCliqueCoverOptions | |
| CIrisNp2Options | IrisNp2Options collects all parameters for the IRIS-NP2 algorithm |
| CIrisParameterizationFunction | Ordinarily, IRIS algorithms grow collision free regions in the robot's configuration space C |
| CIrisZoOptions | IrisZoOptions collects all parameters for the IRIS-ZO algorithm |
| CJointLimits | Wrapper type for position, velocity, and acceleration limits |
| CLinearDistanceAndInterpolationProvider | This class represents a basic "linear" implementation of DistanceAndInterpolationProvider |
| CRaySamplerOptions | RaySamplerOptions contains settings specific to the kRaySampler strategy for drawing the initial samples |
| CRobotClearance | A summary of the clearance – a collection of distance measurements – between the robot and everything in the world |
| CRobotDiagram | Storage for a combined diagram, plant, and scene graph |
| CRobotDiagramBuilder | Storage for a combined diagram builder, plant, and scene graph |
| CSceneGraphCollisionChecker | An implementation of CollisionChecker that uses SceneGraph to provide collision checks |
| CUnimplementedCollisionChecker | A concrete collision checker implementation that throws an exception for every virtual function hook |
| CZmpPlanner | Given a desired two dimensional (X and Y) zero-moment point (ZMP) trajectory parameterized as a piecewise polynomial, an optimal center of mass (CoM) trajectory is planned using a linear inverted pendulum model (LIPM) |
| Nschema | |
| CDeterministic | A single deterministic value |
| CDeterministicVector | A single deterministic vector value |
| CDistribution | Base class for a single distribution, to be used with YAML archives |
| CDistributionVector | Base class for a vector of distributions, to be used with YAML archives |
| CGaussian | A gaussian distribution with mean and stddev |
| CGaussianVector | A gaussian distribution with vector mean and vector or scalar stddev |
| CRotation | A specification for an SO(3) rotation, to be used for serialization purposes, e.g., to define stochastic scenarios |
| CIdentity | No-op rotation |
| CRpy | A roll-pitch-yaw rotation, using the angle conventions of Drake's RollPitchYaw |
| CAngleAxis | Rotation constructed from a fixed axis and an angle |
| CUniform | Rotation sampled from a uniform distribution over SO(3) |
| CTransform | A specification for a 3d rotation and translation, optionally with respect to a base frame |
| CUniform | A uniform distribution with min inclusive and max exclusive |
| CUniformDiscrete | Chooses from among discrete values with equal probability |
| CUniformVector | A uniform distribution with vector min inclusive and vector max exclusive |
| Nsolvers | |
| CAddRotationMatrixBoxSphereIntersectionReturn | Some of the newly added variables in function AddRotationMatrixBoxSphereIntersectionMilpConstraints |
| CAugmentedLagrangianNonsmooth | Compute the augmented Lagrangian (AL) of a given mathematical program |
| CAugmentedLagrangianSmooth | Compute the augmented Lagrangian (AL) of a given mathematical program |
| CBinding | A binding on constraint type C is a mapping of the decision variables onto the inputs of C |
| CBound | Stores the lower and upper bound of a variable |
| CBoundingBoxConstraint | Implements a constraint of the form \( lb <= x <= ub \) |
| CClarabelSolver | An interface to wrap Clarabel https://github.com/oxfordcontrol/Clarabel.cpp |
| CClarabelSolverDetails | The Clarabel solver details after calling the Solve() function |
| CClpSolver | A wrapper to call CLP using Drake's MathematicalProgram |
| CClpSolverDetails | The CLP solver details after calling Solve() function |
| CConstraint | A constraint is a function + lower and upper bounds |
| CCost | Provides an abstract base for all costs |
| CCsdpSolver | Wrap CSDP solver such that it can solve a drake::solvers::MathematicalProgram |
| CCsdpSolverDetails | The CSDP solver details after calling Solve() function |
| CDaqpSolver | A wrapper to call DAQP using Drake's MathematicalProgram |
| CDaqpSolverDetails | The DAQP solver details after calling the Solve() function |
| CEqualityConstrainedQPSolver | Solves a quadratic program with equality constraint |
| CEvaluatorBase | Provides an abstract interface to represent an expression, mapping a fixed or dynamic number of inputs to a fixed number of outputs, that may be evaluated on a scalar type of double or AutoDiffXd |
| CEvaluatorConstraint | A constraint that may be specified using another (potentially nonlinear) evaluator |
| CEvaluatorCost | A cost that may be specified using another (potentially nonlinear) evaluator |
| CExponentialConeConstraint | An exponential cone constraint is a special type of convex cone constraint |
| CExpressionConstraint | Impose a generic (potentially nonlinear) constraint represented as a vector of symbolic Expression |
| CExpressionCost | Impose a generic (potentially nonlinear) cost represented as a symbolic Expression |
| CFunctionEvaluator | An evaluator that may be specified using a callable object |
| CGurobiSolver | An implementation of SolverInterface for the commercially-licensed Gurobi solver (https://www.gurobi.com/) |
| CSolveStatusInfo | Contains info returned to a user function that handles a Node or Solution callback |
| CGurobiSolverDetails | The Gurobi solver details after calling Solve() function |
| CIpoptSolver | A wrapper to call Ipopt using Drake's MathematicalProgram |
| CIpoptSolverDetails | The Ipopt solver details after calling Solve() function |
| CL1NormCost | Implements a cost of the form ‖Ax + b‖₁ |
| CL2NormCost | Implements a cost of the form ‖Ax + b‖₂ |
| CLinearComplementarityConstraint | Implements a constraint of the form: |
| CLinearConstraint | Implements a constraint of the form \( lb <= Ax <= ub \) |
| CLinearCost | Implements a cost of the form |
| CLinearEqualityConstraint | Implements a constraint of the form \( Ax = b \) |
| CLinearMatrixInequalityConstraint | Impose the matrix inequality constraint on variable x |
| CLinearSystemSolver | Finds the least-square solution to the linear system A * x = b |
| CLInfNormCost | Implements a cost of the form ‖Ax + b‖∞ |
| CLogarithmicSos2NewBinaryVariables | The size of the new binary variables in the compile time, for Special Ordered Set of type 2 (SOS2) constraint |
| CLorentzConeConstraint | Constraining the linear expression \( z=Ax+b \) lies within the Lorentz cone |
| CMathematicalProgram | MathematicalProgram stores the decision variables, the constraints and costs of an optimization problem |
| CMathematicalProgramResult | The result returned by MathematicalProgram::Solve() |
| CMinimumValueLowerBoundConstraint | Constrain min(v) >= lb where v=f(x) |
| CMinimumValueUpperBoundConstraint | Constrain min(v) <= ub where v=f(x) |
| CMixedIntegerBranchAndBound | Given a mixed-integer optimization problem (MIP) (or more accurately, mixed binary problem), solve this problem through branch-and-bound process |
| COptions | Configuration settings for the MixedIntegerBranchAndBound constructor |
| CMixedIntegerBranchAndBoundNode | A node in the branch-and-bound (bnb) tree |
| CMixedIntegerRotationConstraintGenerator | We relax the non-convex SO(3) constraint on rotation matrix R to mixed-integer linear constraints |
| CReturnType | |
| CMobyLcpSolver | A class for solving Linear Complementarity Problems (LCPs) |
| CMosekSolver | An implementation of SolverInterface for the commercially-licensed MOSEK (TM) solver (https://www.mosek.com/) |
| CMosekSolverDetails | The MOSEK™ solver details after calling Solve() function |
| CNewSymmetricVariableNames | |
| CNewVariableNames | |
| CNewVariableNames< Rows, Cols > | |
| CNewVariableNames< Size > | The type of the names for the newly added variables |
| CNloptSolver | |
| CNloptSolverDetails | The NLopt solver details after calling Solve() function |
| COsqpSolver | A wrapper to call OSQP using Drake's MathematicalProgram |
| COsqpSolverDetails | The OSQP solver details after calling Solve() function |
| CPerspectiveQuadraticCost | If \( z = Ax + b,\) implements a cost of the form: |
| CPolynomialConstraint | A constraint on the values of multivariate polynomials |
| CPolynomialCost | Implements a cost of the form P(x, y...) where P is a multivariate polynomial in x, y, .. |
| CPolynomialEvaluator | Implements an evaluator of the form P(x, y...) where P is a multivariate polynomial in x, y, .. |
| CPositiveSemidefiniteConstraint | Implements a positive semidefinite constraint on a symmetric matrix S |
| CProjectedGradientDescentSolver | Solves a nonlinear program via the projected gradient descent algorithm |
| CQuadraticConstraint | Lb ≤ .5 xᵀQx + bᵀx ≤ ub Without loss of generality, the class stores a symmetric matrix Q |
| CQuadraticCost | Implements a cost of the form |
| CRotatedLorentzConeConstraint | Constraining that the linear expression \( z=Ax+b \) lies within rotated Lorentz cone |
| CScsSolver | |
| CScsSolverDetails | The SCS solver details after calling Solve() function |
| CSemidefiniteRelaxationOptions | Configuration options for the MakeSemidefiniteRelaxation |
| CSnoptSolver | An implementation of SolverInterface for the commercially-licensed SNOPT solver (https://ccom.ucsd.edu/~optimizers/solvers/snopt/) |
| CSnoptSolverDetails | The SNOPT solver details after calling Solve() function |
| CSolverBase | Abstract base class used by implementations of individual solvers |
| CSolverId | Identifies a SolverInterface implementation |
| CSolverInterface | Interface used by implementations of individual solvers |
| CSolverOptions | Stores options for multiple solvers |
| CSolverTypeConverter | Converts between SolverType and SolverId |
| CUnrevisedLemkeSolver | A class for the Unrevised Implementation of Lemke Algorithm's for solving Linear Complementarity Problems (LCPs) |
| CUnrevisedLemkeSolverId | Non-template class for UnrevisedLemkeSolver<T> constants |
| CVisualizationCallback | Defines a simple evaluator with no outputs that takes a callback function pointer |
| Nsymbolic | |
| CBasisElementGradedReverseLexOrder | Implements Graded reverse lexicographic order |
| CChebyshevBasisElement | ChebyshevBasisElement represents an element of Chebyshev polynomial basis, written as the product of Chebyshev polynomials, in the form Tₚ₀(x₀)Tₚ₁(x₁)...Tₚₙ(xₙ), where each Tₚᵢ(xᵢ) is a (univariate) Chebyshev polynomial of degree pᵢ |
| CChebyshevPolynomial | Represents the Chebyshev polynomial of the first kind Tₙ(x) |
| CCodeGenVisitor | Visitor class for code generation |
| CEnvironment | Represents a symbolic environment (mapping from a variable to a value) |
| CExpression | Represents a symbolic form of an expression |
| CFormula | Represents a symbolic form of a first-order logic formula |
| CGenericPolynomial | Represents symbolic generic polynomials using a given basis (for example, monomial basis, Chebyshev basis, etc) |
| CGradedReverseLexOrder | Implements Graded reverse lexicographic order |
| CMonomial | Represents a monomial, a product of powers of variables with non-negative integer exponents |
| CMonomialBasisElement | MonomialBasisElement represents a monomial, a product of powers of variables with non-negative integer exponents |
| CPolynomial | Represents symbolic polynomials |
| CSubstituteAndExpandCacheData | An encapsulated data type for use with the method SubstituteAndExpand |
| CPolynomialBasisElement | Each polynomial p(x) can be written as a linear combination of its basis elements p(x) = ∑ᵢ cᵢ * ϕᵢ(x), where ϕᵢ(x) is the i'th element in the basis, cᵢ is the coefficient of that element |
| CRationalFunction | Represents symbolic rational function |
| CRewritingRule | A RewritingRule, lhs => rhs, consists of two Patterns lhs and rhs |
| CSinCos | Represents a pair of Variables corresponding to sin(q) and cos(q) |
| CVariable | Represents a symbolic variable |
| CId | Identifier for a symbolic variable |
| CCompareLess | Provides a strict weak ordering on variables (see less), for use as the comparator of an ordered container, e.g., std::set<Variable, Variable::CompareLess> |
| CCompareEqualTo | Checks structural equality of variables (see equal_to), for use as the key-equality predicate of an unordered container, e.g., std::unordered_set<Variable, std::hash<Variable>, Variable::CompareEqualTo> |
| CVariables | Represents a set of variables |
| Nsystems | |
| Nanalysis | |
| CRandomSimulationResult | A snapshot of the generator used to produce the random simulation |
| CRegionOfAttractionOptions | Consolidates the many possible options to be passed to the region of attraction algorithm |
| Ncontrollers | |
| CDynamicProgrammingOptions | Consolidates the many possible options to be passed to the dynamic programming algorithms |
| CPeriodicBoundaryCondition | For algorithms that rely on approximations of the state-dynamics (as in FittedValueIteration), this is a list of state dimensions for which the state space maximum value should be "wrapped around" to ensure that all values are in the range [low, high) |
| CFiniteHorizonLinearQuadraticRegulatorOptions | A structure to facilitate passing the myriad of optional arguments to the FiniteHorizonLinearQuadraticRegulator algorithms |
| CFiniteHorizonLinearQuadraticRegulatorResult | A structure that contains the basic FiniteHorizonLinearQuadraticRegulator results |
| CInverseDynamics | Solves inverse dynamics with no consideration for joint actuator force limits |
| CInverseDynamicsController | A state feedback controller that uses a PidController to generate desired accelerations, which are then converted into MultibodyPlant actuation inputs using InverseDynamics (with mode = InverseDynamics::kInverseDynamics) |
| CJointImpedanceController | Drake does not yet offer a joint impedance controller, which would use feedback to shape the stiffness, damping, and inertia of the closed-loop system |
| CJointStiffnessController | Implements a joint-space stiffness controller of the form |
| CLinearQuadraticRegulatorResult | |
| CPidControlledSystem | A system that encapsulates a PidController and a controlled System (a.k.a the "plant") |
| CConnectResult | The return type of ConnectController |
| CPidController | Implements the PID controller |
| CStateFeedbackControllerInterface | Interface for state feedback controllers |
| Nestimators | |
| CLuenbergerObserver | A simple state observer for a continuous-time dynamical system of the form: |
| Nlcm | |
| CLcmBuses | A mapping from {bus_name: interface} with sugar for error checking with nice error messages during access |
| CLcmInterfaceSystem | LcmInterfaceSystem acts within a Diagram to allow LcmSubscriberSystem instances to receive data from the network during a simulation |
| CLcmLogPlaybackSystem | Advances the cursor of a drake::lcm::DrakeLcmLog based on the timestamps seen the Context that is used to simulate this System |
| CLcmPublisherSystem | Publishes an LCM message containing information from its input port |
| CLcmScopeSystem | LcmScopeSystem provides the ability to convert any vector output port to a simple LCM message and publish that message periodically |
| CLcmSubscriberSystem | Receives LCM messages from a given channel and outputs them to a System<double>'s port |
| CSerializer | Serializer is specific to a single LcmMessage type, and translates between LCM message bytes and drake::Value<LcmMessage> objects |
| CSerializerInterface | SerializerInterface translates between LCM message bytes and drake::AbstractValue objects that contain LCM messages, e.g., a Value<lcmt_drake_signal> |
| Nrendering | |
| CMultibodyPositionToGeometryPose | A direct-feedthrough system that converts a vector of joint positions directly to a geometry::FramePoseVector<T> to behave like a MultibodyPlant::get_geometry_pose_output_port() |
| Nscalar_conversion | |
| CFromDoubleTraits | A concrete traits class providing sugar to support for converting only from the double scalar type |
| CNonSymbolicTraits | A concrete traits class providing sugar to disable support for symbolic evaluation (i.e., the symbolic::Expression scalar type) |
| CTraits | A templated traits class for whether an S<U> can be converted into an S<T>; the default value is true for all values of S, T, and U |
| CTraits< drake::multibody::meshcat::ContactVisualizer > | |
| CTraits< examples::rimless_wheel::RimlessWheel > | |
| CTraits< geometry::DrakeVisualizer > | |
| CTraits< geometry::MeshcatPointCloudVisualizer > | |
| CTraits< geometry::MeshcatVisualizer > | |
| CTraits< LinearTransformDensity > | |
| CTraits< RandomSource > | |
| CTraits< sensors::BeamModel > | |
| CTraits< TrajectoryAffineSystem > | |
| CTraits< TrajectoryLinearSystem > | |
| CTraits< TrajectorySource > | Spells out the supported scalar conversions for TrajectorySource |
| CValueConverter | Converts a scalar U u to its corresponding scalar T t |
| CValueConverter< T, T > | |
| Nsensors | |
| CAccelerometer | Sensor to represent an ideal accelerometer sensor |
| CBeamModel | Implements the "Beam Models of Range Finders" from section 6.3 of Probabilistic Robotics (2006), by Thrun, Burgard, and Fox |
| CBeamModelParams | Specializes BasicVector with specific getters and setters |
| CBeamModelParamsIndices | Describes the row indices of a BeamModelParams |
| CCameraConfig | Configuration of a camera |
| CFocalLength | Specification of a camera's intrinsic focal properties as focal length (in pixels) |
| CFovDegrees | Specification of focal length via fields of view (in degrees) |
| CCameraInfo | Simple class for characterizing the Drake camera model |
| CGyroscope | Sensor to represent an ideal gyroscopic sensor |
| CImage | Simple data format for Image |
| CImageIo | Utility functions for reading and writing images, from/to either files or memory buffers |
| CMetadata | Some characteristics of an image file |
| CByteSpan | When loading from memory, this struct denotes a span of raw bytes as input |
| CImageToLcmImageArrayT | An ImageToLcmImageArrayT takes as input an ImageRgba8U, ImageDepth32F and ImageLabel16I |
| CImageTraits | Traits class for Image, specialized by PixelType |
| CImageTraits< PixelType::kBgr8U > | |
| CImageTraits< PixelType::kBgra8U > | |
| CImageTraits< PixelType::kDepth16U > | |
| CImageTraits< PixelType::kDepth32F > | |
| CImageTraits< PixelType::kGrey8U > | |
| CImageTraits< PixelType::kLabel16I > | |
| CImageTraits< PixelType::kRgb8U > | |
| CImageTraits< PixelType::kRgba8U > | |
| CImageWriter | A system for periodically writing images to the file system |
| CLcmImageArrayToImages | An LcmImageArrayToImages takes as input an AbstractValue containing a Value<lcmt_image_array> LCM message that defines an array of images (lcmt_image) |
| CLcmImageTraits | |
| CLcmImageTraits< PixelType::kBgr8U > | |
| CLcmImageTraits< PixelType::kBgra8U > | |
| CLcmImageTraits< PixelType::kDepth16U > | |
| CLcmImageTraits< PixelType::kDepth32F > | |
| CLcmImageTraits< PixelType::kGrey8U > | |
| CLcmImageTraits< PixelType::kLabel16I > | |
| CLcmImageTraits< PixelType::kRgb8U > | |
| CLcmImageTraits< PixelType::kRgba8U > | |
| CLcmPixelTraits | |
| CLcmPixelTraits< PixelFormat::kBgr > | |
| CLcmPixelTraits< PixelFormat::kBgra > | |
| CLcmPixelTraits< PixelFormat::kDepth > | |
| CLcmPixelTraits< PixelFormat::kGrey > | |
| CLcmPixelTraits< PixelFormat::kLabel > | |
| CLcmPixelTraits< PixelFormat::kRgb > | |
| CLcmPixelTraits< PixelFormat::kRgba > | |
| CRgbdSensor | A meta-sensor that houses RGB, depth, and label cameras, producing their corresponding images based on the contents of the geometry::SceneGraph |
| CRgbdSensorAsync | A sensor similar to RgbdSensorDiscrete but the rendering occurs on a background thread to offer improved performance |
| CRgbdSensorDiscrete | Wraps a continuous RgbdSensor with a zero-order hold to create a discrete sensor |
| CRotaryEncoders | Simple model to capture the quantization and calibration offset effects of a rotary encoder |
| CAbstractValues | AbstractValues is a container for non-numerical state and parameters |
| CAdder | An adder for arbitrarily many inputs of equal size |
| CAffineSystem | A discrete OR continuous affine system (with constant coefficients) |
| CAntiderivativeFunction | A thin wrapper of the ScalarInitialValueProblem class that, in concert with Drake's ODE initial value problem solvers ("integrators"), provide the ability to perform quadrature on an arbitrary scalar integrable function |
| CBarycentricMeshSystem | A (stateless) vector system implemented as a multi-linear (barycentric) interpolation on a mesh over the inputs |
| CBasicVector | BasicVector is a semantics-free wrapper around an Eigen vector that satisfies VectorBase |
| CBogackiShampine3Integrator | A third-order, four-stage, first-same-as-last (FSAL) Runge-Kutta integrator with a second order error estimate |
| CBusCreator | This system packs values from heterogeneous input ports into a single output port of type BusValue |
| CBusSelector | This system unpacks values from a single input port of type BusValue onto heterogeneous output ports, where each output port's value comes from the same- named signal on the bus |
| CBusValue | BusValue is a value type used on input ports and output ports to group labeled signals into a single port |
| CIterator | Provides a forward_iterator over BusValue signals |
| CCache | (Advanced) Stores all the CacheEntryValue objects owned by a particular Context, organized to allow fast access using a CacheIndex as an index |
| CCacheEntry | A CacheEntry belongs to a System and represents the properties of one of that System's cached computations |
| CCacheEntryValue | (Advanced) This is the representation in the Context for the value of one of a System's CacheEntry objects |
| CCompositeEventCollection | This class bundles an instance of each EventCollection<EventType> into one object that stores the heterogeneous collection |
| CConstantValueSource | A source block that always outputs a constant value |
| CConstantVectorSource | A source block with a constant output port at all times |
| CContext | Context is an abstract class template that represents all the typed values that are used in a System's computations: time, numeric-valued input ports, numerical state, and numerical parameters |
| CContextBase | Provides non-templatized Context functionality shared by the templatized derived classes |
| CContinuousState | ContinuousState is a view of, and optionally a container for, all the continuous state variables xc of a Drake System |
| CDemultiplexer | This system splits a vector valued signal on its input into multiple outputs |
| CDenseOutput | An interface for dense output of ODE solutions, to efficiently approximate them at arbitrarily many points when solving them numerically (see IntegratorBase class documentation) |
| CDependencyGraph | Represents the portion of the complete dependency graph that is a subgraph centered on the owning subcontext, plus some edges leading to other subcontexts |
| CDependencyTracker | Manages value interdependencies for a particular value or set of values in a Context |
| CDiagram | Diagram is a System composed of one or more constituent Systems, arranged in a directed graph where the vertices are the constituent Systems themselves, and the edges connect the output of one constituent System to the input of another |
| CDiagramBuilder | DiagramBuilder is a factory class for Diagram |
| CDiagramCompositeEventCollection | CompositeEventCollection for a Diagram |
| CDiagramContext | The DiagramContext is a container for all of the data necessary to uniquely determine the computations performed by a Diagram |
| CDiagramContinuousState | DiagramContinuousState is a ContinuousState consisting of Supervectors xc, q, v, z over the corresponding entries in a set of referenced ContinuousState objects, which may or may not be owned by this DiagramContinuousState |
| CDiagramDiscreteValues | DiagramDiscreteValues is a DiscreteValues container comprised recursively of a sequence of child DiscreteValues objects |
| CDiagramEventCollection | A concrete class that holds all simultaneous homogeneous events for a Diagram |
| CDiagramOutputPort | (Advanced.) Holds information about a subsystem output port that has been exported to become one of this Diagram's output ports |
| CDiagramState | DiagramState is a State, annotated with pointers to all the mutable substates that it spans |
| CDiscreteDerivative | System that outputs the discrete-time derivative of its input: y(t) = (u[n] - u[n-1])/h, where n = floor(t/h), where h is the time period |
| CDiscreteTimeDelay | A discrete time delay block with input u, which is vector-valued (discrete or continuous) or abstract, and output delayed_u which is previously received input, delayed by the given amount |
| CDiscreteTimeIntegrator | A discrete-time integrator for a vector input, using explicit Euler integration |
| CDiscreteUpdateEvent | This class represents a discrete update event |
| CDiscreteValues | DiscreteValues is a container for numerical but non-continuous state and parameters |
| CEvent | Abstract base class that represents an event |
| CEventCollection | There are three concrete event types for any System: publish, discrete state update, and unrestricted state update, listed in order of increasing ability to change the state (i.e., zero to all) |
| CEventStatus | Holds the return status from execution of an event handler function, or the effective status after a series of handler executions due to dispatching of simultaneous events |
| CExplicitEulerIntegrator | A first-order, explicit Euler integrator |
| CExternalSystemConstraint | An "external" constraint on a System |
| CFirstOrderLowPassFilter | An element-wise first order low pass filter system that filters the i-th input uᵢ into the i-th output zᵢ |
| CFixedInputPortValue | A FixedInputPortValue encapsulates a vector or abstract value for use as an internal value source for one of a System's input ports |
| CGain | An element-wise gain block with input u and output y = k * u with k a constant vector |
| CHermitianDenseOutput | A StepwiseDenseOutput class implementation using Hermitian interpolators, and therefore a continuous extension of the solution 𝐱(t) (see [Engquist, 2105]) |
| CIntegrationStep | An integration step representation class, holding just enough for Hermitian interpolation: three (3) related sets containing step times {t₀, ..., tᵢ₋₁, tᵢ} where tᵢ ∈ ℝ, step states {𝐱₀, ..., 𝐱ᵢ₋₁, 𝐱ᵢ} where 𝐱ᵢ ∈ ℝⁿ, and state derivatives {d𝐱/dt₀, ..., d𝐱/dtᵢ₋₁, d𝐱/dtᵢ} where d𝐱/dtᵢ ∈ ℝⁿ |
| CImplicitEulerIntegrator | A first-order, fully implicit integrator with second order error estimation |
| CImplicitIntegrator | An abstract class providing methods shared by implicit integrators |
| CIterationMatrix | A class for storing the factorization of an iteration matrix and using it to solve linear systems of equations |
| CInitializeParams | Parameters for fine control of simulator initialization |
| CInitialValueProblem | A general initial value problem (or IVP) representation class, that allows evaluating the 𝐱(t; 𝐤) solution function to the given ODE d𝐱/dt = f(t, 𝐱; 𝐤), where f : t ⨯ 𝐱 → ℝⁿ, t ∈ ℝ, 𝐱 ∈ ℝⁿ, 𝐤 ∈ ℝᵐ, provided an initial condition 𝐱(t₀; 𝐤) = 𝐱₀ |
| CInputPort | An InputPort is a System resource that describes the kind of input a System accepts, on a given port |
| CInputPortBase | An InputPort is a System resource that describes the kind of input a System accepts, on a given port |
| CIntegrator | A continuous-time integrator for a vector input |
| CIntegratorBase | An abstract class for an integrator for ODEs and DAEs as represented by a Drake System |
| CLeafCompositeEventCollection | A CompositeEventCollection for a LeafSystem |
| CLeafContext | LeafContext contains all prerequisite data necessary to uniquely determine the results of computations performed by the associated LeafSystem |
| CLeafEventCollection | A concrete class that holds all simultaneous homogeneous events for a LeafSystem |
| CLeafOutputPort | (Advanced.) Implements an output port whose value is managed by a cache entry in the same LeafSystem as the port |
| CLeafSystem | A superclass template that extends System with some convenience utilities that are not applicable to Diagrams |
| CLinearSystem | A discrete OR continuous linear system |
| CLinearTransformDensity | Performs linear transformation on the random signal w_in as w_out = A*w_in + b |
| CMatrixGain | A system that specializes LinearSystem by setting coefficient matrices A, B, and C to all be zero |
| CMultilayerPerceptron | The MultilayerPerceptron (MLP) is one of the most common forms of neural networks used in reinforcement learning (RL) today |
| CMultiplexer | This system combines multiple vector-valued inputs into a vector-valued output |
| COutputPort | An OutputPort belongs to a System and represents the properties of one of that System's output ports |
| COutputPortBase | OutputPortBase handles the scalar type-independent aspects of an OutputPort |
| CParameters | Parameters is a container for variables that parameterize a System so that it can represent a family of related models |
| CPassThrough | A pass through system with input u and output y = u |
| CPeriodicEventData | An event data variant describing an event that recurs on a fixed period |
| CPortBase | A PortBase is base class for System ports; users will typically use the InputPort<T> or OutputPort<T> types, not this base class |
| CPortSwitch | A simple system that passes through the value from just one of its input ports to the output |
| CPublishEvent | This class represents a publish event |
| CRadauIntegrator | A selectable order (third- or first-order), fully implicit integrator with error estimation |
| CRandomSource | A source block which generates random numbers at a fixed sampling interval, with a zero-order hold between samples |
| CRungeKutta2Integrator | A second-order, explicit Runge Kutta integrator |
| CRungeKutta3Integrator | A third-order Runge Kutta integrator with a third order error estimate |
| CRungeKutta5Integrator | A fifth-order, seven-stage, first-same-as-last (FSAL) Runge Kutta integrator with a fifth order error estimate |
| CSaturation | An element-wise hard saturation block with inputs signal u, saturation values \( u_{min} \) and/or \( u_{max} \), and output y respectively as in: |
| CScalarDenseOutput | A DenseOutput class interface extension to deal with scalar ODE solutions |
| CScalarInitialValueProblem | A thin wrapper of the InitialValueProblem class to provide a simple interface when solving scalar initial value problems i.e |
| CScalarViewDenseOutput | A ScalarDenseOutput class implementation that wraps a DenseOutput class instance and behaves as a view to one of its elements |
| CSelector | This system combines multiple vector-valued inputs into multiple vector- valued outputs |
| CSelectorParams | The constructor arguments for a Selector |
| CInputPortParams | Helper struct for inputs |
| COutputSelection | Helper struct for output_selections |
| COutputPortParams | Helper struct for outputs |
| CSemiExplicitEulerIntegrator | A first-order, semi-explicit Euler integrator |
| CSharedPointerSystem | SharedPointerSystem holds a single shared_ptr that will be released at System deletion time (i.e., the end of a Diagram lifespan) |
| CSimulator | A class for advancing the state of hybrid dynamic systems, represented by System<T> objects, forward in time |
| CSimulatorConfig | The set of all configurable properties on a Simulator and IntegratorBase |
| CSimulatorStatus | Holds the status return value from a call to Simulator::AdvanceTo() and related methods |
| CSine | A sine system which outputs y = a * sin(f * t + p) and first and second derivatives w.r.t |
| CSingleOutputVectorSource | A base class that specializes LeafSystem for use with no input ports, and only a single, vector output port |
| CSparseMatrixGain | A variant of MatrixGain which supports multiplication by SparseMatrix, D |
| CState | State is a container for all the data comprising the complete state of a particular System at a particular moment |
| CStateInterpolatorWithDiscreteDerivative | Supports the common pattern of combining a (feed-through) position with a velocity estimated with the DiscreteDerivative into a single output vector with positions and velocities stacked |
| CStepwiseDenseOutput | A DenseOutput class interface extension, geared towards step-wise construction procedures |
| CSubvector | Subvector is a concrete class template that implements VectorBase by providing a sliced view of a VectorBase |
| CSupervector | Supervector is a concrete class template that implements VectorBase by concatenating multiple VectorBases, which it does not own |
| CSymbolicVectorSystem | A LeafSystem that is defined by vectors of symbolic::Expression representing the dynamics and output |
| CSymbolicVectorSystemBuilder | Builder design pattern to help with all of the optional arguments in the constructor of SymbolicVectorSystem |
| CSystem | Base class for all System functionality that is dependent on the templatized scalar type T for input, state, parameters, and outputs |
| CSystemBase | Provides non-templatized functionality shared by the templatized System classes |
| CGraphvizFragment | (Advanced) The return type of GetGraphvizFragment() |
| CGraphvizFragmentParams | (Advanced) The arguments to the protected method DoGetGraphvizFragment() |
| CContextSizes | Return type for get_context_sizes() |
| CSystemConstraint | A SystemConstraint is a generic base-class for constraints on Systems |
| CSystemConstraintAdapter | This class is a factory class to generate SystemConstraintWrapper |
| CSystemConstraintBounds | The bounds of a SystemConstraint |
| CSystemConstraintWrapper | This wrapper class wraps a SystemConstraint object to the format of solvers::Constraint |
| CSystemOutput | Conveniently stores a snapshot of the values of every output port of a System |
| CSystemScalarConverter | Helper class to convert a System into a System<T>, intended for internal use by the System framework, not directly by users |
| CSystemSymbolicInspector | The SystemSymbolicInspector uses symbolic::Expressions to analyze various properties of the System, such as time invariance and input-to-output sparsity, along with many others |
| CSystemTypeTag | A tag object that denotes a System subclass S in function signatures |
| CSystemVisitor | Provides a "Visitor Pattern" for System and Diagram |
| CTimeVaryingAffineSystem | Base class for a discrete- or continuous-time, time-varying affine system, with potentially time-varying coefficients |
| CTimeVaryingLinearSystem | Base class for a discrete or continuous linear time-varying (LTV) system |
| CTrajectoryAffineSystem | A continuous- or discrete-time Affine Time-Varying system with system matrices described by trajectories |
| CTrajectoryLinearSystem | A continuous- or discrete-time Linear Time-Varying system with system matrices described by trajectories |
| CTrajectorySource | Given a Trajectory, this System provides an output port with the value of the trajectory evaluated at the current time |
| CTransferFunction | Represents a linear-time-invariant (LTI) system in transfer function form, e.g |
| CUnrestrictedUpdateEvent | This class represents an unrestricted update event |
| CUseDefaultName | (Advanced.) Tag type that indicates a system or port should use a default name, instead of a user-provided name |
| CValueProducer | ValueProducer computes an AbstractValue output based on a ContextBase input |
| CVectorBase | VectorBase is an abstract base class that real-valued signals between Systems and real-valued System state vectors must implement |
| CVectorLog | This utility class serves as an in-memory cache of time-dependent vector values |
| CVectorLogSink | A discrete sink block which logs its vector-valued input to per-context memory |
| CVectorSystem | A base class that specializes LeafSystem for use with only zero or one vector input ports, and only zero or one vector output ports |
| CVelocityImplicitEulerIntegrator | A first-order, fully implicit integrator optimized for second-order systems, with a second-order error estimate |
| CWitnessFunction | Class that stores a function that is able to help determine the time and state at which a step of the initial value problem integration of a System should end, which may be done for any number of purposes, including publishing or state reinitialization (i.e., event handling) |
| CWitnessTriggeredEventData | An event data variant for storing data from a witness function triggering to be passed to event handlers |
| CWrapToSystem | An element-wise wrapping block that transforms the specified indices of the input signal u into the interval [low, high) |
| CZeroOrderHold | A zero order hold block with input u, which may be vector-valued (discrete or continuous) or abstract, and discrete output y, where the y is sampled from u with a fixed period (and optional offset) |
| Ntrajectories | |
| CBezierCurve | A Bézier curve is defined by a set of control points p₀ through pₙ, where n is called the order of the curve (n = 1 for linear, 2 for quadratic, 3 for cubic, etc.) |
| CBsplineTrajectory | Represents a B-spline curve using a given basis with ordered control_points such that each control point is a matrix in ℝʳᵒʷˢ ˣ ᶜᵒˡˢ |
| CCompositeTrajectory | A "composite trajectory" is a series of trajectories joined end to end where the end time of one trajectory coincides with the starting time of the next |
| CDerivativeTrajectory | Trajectory objects provide derivatives by implementing DoEvalDerivative and DoMakeDerivative |
| CDiscreteTimeTrajectory | A DiscreteTimeTrajectory is a Trajectory whose value is only defined at discrete time points |
| CExponentialPlusPiecewisePolynomial | Represents a piecewise-trajectory with piece \(j\) given by: |
| CFunctionHandleTrajectory | FunctionHandleTrajectory takes a function, value = f(t), and provides a Trajectory interface |
| CPathParameterizedTrajectory | A trajectory defined by a path and timing trajectory |
| CPiecewiseConstantCurvatureTrajectory | A piecewise constant curvature trajectory in a plane, where the plane is posed arbitrarily in three dimensions |
| CPiecewisePolynomial | A scalar multi-variate piecewise polynomial |
| CPiecewisePose | A wrapper class that represents a pose trajectory, whose rotation part is a PiecewiseQuaternionSlerp and the translation part is a PiecewisePolynomial |
| CPiecewiseQuaternionSlerp | A class representing a trajectory for quaternions that are interpolated using piecewise slerp (spherical linear interpolation) |
| CPiecewiseTrajectory | Abstract class that implements the basic logic of maintaining consequent segments of time (delimited by breaks) to implement a trajectory that is represented by simpler logic in each segment or "piece" |
| CStackedTrajectory | A StackedTrajectory stacks the values from one or more underlying Trajectory objects into a single Trajectory, without changing the start_time() or end_time() |
| CTrajectory | A Trajectory represents a time-varying matrix, indexed by a single scalar time |
| Nvisualization | |
| CColorizeDepthImage | ColorizeDepthImage converts a depth image, either 32F or 16U, to a color image |
| CColorizeLabelImage | ColorizeLabelImage converts a label image to a color image |
| CConcatenateImages | ConcatenateImages stacks multiple input images into a single output image |
| CInertiaVisualizer | InertiaVisualizer provides illustration geometry to reflect the equivalent inertia of all bodies in a MultibodyPlant that are not welded to the world |
| CMeshcatPoseSliders | MeshcatPoseSliders adds slider bars to the MeshCat control panel for the roll, pitch, yaw, x, y, z control of a pose |
| CVisualizationConfig | Settings for what MultibodyPlant and SceneGraph should send to Meshcat and/or Meldis |
| Nyaml | |
| CLoadYamlOptions | Configuration for LoadYamlFile() and LoadYamlString() to govern when certain conditions are errors or not |
| CAbstractValue | A fully type-erased container class |
| Ccopyable_unique_ptr | A smart pointer with deep copy semantics |
| CDelegatingHasher | An adapter that forwards the HashAlgorithm::operator(data, length) function concept into a runtime-provided std::function of the same signature |
| Cdummy_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 |
| Cdummy_value< int > | |
| Cdummy_value< symbolic::Expression > | Specializes common/dummy_value.h |
| CEigenPtr | 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 |
| CFindResourceResult | Models the outcome of drake::FindResource |
| CIdentifier | A simple identifier class |
| Cis_eigen_nonvector_expression_double_pair | |
| Cis_eigen_nonvector_of | |
| Cis_eigen_scalar_same | |
| Cis_eigen_type | |
| Cis_eigen_vector | |
| Cis_eigen_vector_expression_double_pair | |
| Cis_eigen_vector_of | |
| CManualTimer | Implementation of timing for use with unit tests that control time manually |
| CMemoryFile | A virtual file, stored in memory |
| CNameValue | (Advanced) A basic implementation of the Name-Value Pair concept as used in the Serialize / Archive pattern |
| Cnever_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 |
| CNiceTypeName | Obtains canonicalized, platform-independent, human-readable names for arbitrarily-complicated C++ types |
| CParallelism | Specifies a desired degree of parallelism for a parallelized operation |
| CPolynomial | A scalar multi-variate polynomial, modeled after the msspoly in spotless |
| CProduct | |
| CTerm | An individual variable raised to an integer power; e.g. x**2 |
| CMonomial | An additive atom of a Polynomial: The product of any number of Terms and a coefficient |
| CRandomGenerator | Defines Drake's canonical implementation of the UniformRandomBitGenerator C++ concept (as well as a few conventional extras beyond the concept, e.g., seeds) |
| Creset_after_move | Type wrapper that performs value-initialization on the wrapped type, and guarantees that when moving from this type that the donor object is reset to its value-initialized value |
| Creset_on_copy | Type wrapper that performs value-initialization on copy construction or assignment |
| CRlocationOrError | (Advanced.) The return type of FindRunfile() |
| Cscalar_predicate | A traits struct that describes the return type of predicates over a scalar type (named T) |
| CScopeExit | Helper class to create a scope exit guard – an object that when destroyed runs func |
| CSha256 | Represents a SHA-256 cryptographic checksum |
| CSortedPair | This class is similar to the std::pair class |
| CSteadyTimer | Implementation of timing utility that uses monotonic std::chrono::steady_clock |
| CTimer | Abstract base class for timing utility |
| CTypeSafeIndex | A type-safe non-negative index class |
| Cuhash | A hashing functor, somewhat like std::hash |
| CValue | A container class for an arbitrary type T (with some restrictions) |
| Nfmt | |
| Cformatter< drake::ad::AutoDiff > | Specializes the fmt::formatter<> class template for drake::ad::AutoDiff |
| Cformatter< drake::copyable_unique_ptr< T > > | Specializes the fmt::formatter<> class template for drake::copyable_unique_ptr<T> |
| Cformatter< drake::geometry::Box > | Specializes the fmt::formatter<> class template for drake::geometry::Box |
| Cformatter< drake::geometry::Capsule > | Specializes the fmt::formatter<> class template for drake::geometry::Capsule |
| Cformatter< drake::geometry::Convex > | Specializes the fmt::formatter<> class template for drake::geometry::Convex |
| Cformatter< drake::geometry::Cylinder > | Specializes the fmt::formatter<> class template for drake::geometry::Cylinder |
| Cformatter< drake::geometry::Ellipsoid > | Specializes the fmt::formatter<> class template for drake::geometry::Ellipsoid |
| Cformatter< drake::geometry::GeometryId > | |
| Cformatter< drake::geometry::GeometryProperties > | Specializes the fmt::formatter<> class template for drake::geometry::GeometryProperties |
| Cformatter< drake::geometry::HalfSpace > | Specializes the fmt::formatter<> class template for drake::geometry::HalfSpace |
| Cformatter< drake::geometry::InMemoryMesh > | Specializes the fmt::formatter<> class template for drake::geometry::InMemoryMesh |
| Cformatter< drake::geometry::Mesh > | Specializes the fmt::formatter<> class template for drake::geometry::Mesh |
| Cformatter< drake::geometry::MeshcatCone > | Specializes the fmt::formatter<> class template for drake::geometry::MeshcatCone |
| Cformatter< drake::geometry::render::LightFrame > | Specializes the fmt::formatter<> class template for drake::geometry::render::LightFrame |
| Cformatter< drake::geometry::render::LightType > | Specializes the fmt::formatter<> class template for drake::geometry::render::LightType |
| Cformatter< drake::geometry::render::RenderLabel > | Specializes the fmt::formatter<> class template for drake::geometry::render::RenderLabel |
| Cformatter< drake::geometry::Rgba > | Specializes the fmt::formatter<> class template for drake::geometry::Rgba |
| Cformatter< drake::geometry::Role > | Specializes the fmt::formatter<> class template for drake::geometry::Role |
| Cformatter< drake::geometry::Shape > | Specializes the fmt::formatter<> class template for drake::geometry::Shape |
| Cformatter< drake::geometry::Sphere > | Specializes the fmt::formatter<> class template for drake::geometry::Sphere |
| Cformatter< drake::Identifier< Tag > > | Specializes the fmt::formatter<> class template for drake::Identifier<Tag> |
| Cformatter< drake::math::RigidTransform< T > > | Specializes the fmt::formatter<> class template for drake::math::RigidTransform<T> |
| Cformatter< drake::math::RollPitchYaw< T > > | Specializes the fmt::formatter<> class template for drake::math::RollPitchYaw<T> |
| Cformatter< drake::MemoryFile > | Specializes the fmt::formatter<> class template for drake::MemoryFile |
| Cformatter< drake::multibody::CollisionFilterGroups > | Specializes the fmt::formatter<> class template for drake::multibody::CollisionFilterGroups |
| Cformatter< drake::multibody::DifferentialInverseKinematicsStatus > | Specializes the fmt::formatter<> class template for drake::multibody::DifferentialInverseKinematicsStatus |
| Cformatter< drake::multibody::PackageMap > | Specializes the fmt::formatter<> class template for drake::multibody::PackageMap |
| Cformatter< drake::multibody::RotationalInertia< T > > | Specializes the fmt::formatter<> class template for drake::multibody::RotationalInertia<T> |
| Cformatter< drake::multibody::ScopedName > | Specializes the fmt::formatter<> class template for drake::multibody::ScopedName |
| Cformatter< drake::multibody::SpatialAcceleration< T > > | Specializes the fmt::formatter<> class template for drake::multibody::SpatialAcceleration<T> |
| Cformatter< drake::multibody::SpatialForce< T > > | Specializes the fmt::formatter<> class template for drake::multibody::SpatialForce<T> |
| Cformatter< drake::multibody::SpatialInertia< T > > | Specializes the fmt::formatter<> class template for drake::multibody::SpatialInertia<T> |
| Cformatter< drake::multibody::SpatialMomentum< T > > | Specializes the fmt::formatter<> class template for drake::multibody::SpatialMomentum<T> |
| Cformatter< drake::multibody::SpatialVector< SpatialQuantity, T > > | |
| Cformatter< drake::multibody::SpatialVelocity< T > > | Specializes the fmt::formatter<> class template for drake::multibody::SpatialVelocity<T> |
| Cformatter< drake::multibody::UnitInertia< T > > | Specializes the fmt::formatter<> class template for drake::multibody::UnitInertia<T> |
| Cformatter< drake::perception::pc_flags::DescriptorType > | Specializes the fmt::formatter<> class template for drake::perception::pc_flags::DescriptorType |
| Cformatter< drake::perception::pc_flags::Fields > | Specializes the fmt::formatter<> class template for drake::perception::pc_flags::Fields |
| Cformatter< drake::Polynomial< double >::Monomial > | Specializes the fmt::formatter<> class template for drake::Polynomial<double>::Monomial |
| Cformatter< drake::Polynomial< T > > | Specializes the fmt::formatter<> class template for drake::Polynomial<T> |
| Cformatter< drake::solvers::Binding< C > > | Specializes the fmt::formatter<> class template for drake::solvers::Binding<C> |
| Cformatter< drake::solvers::CommonSolverOption > | Specializes the fmt::formatter<> class template for drake::solvers::CommonSolverOption |
| Cformatter< drake::solvers::IntervalBinning > | Specializes the fmt::formatter<> class template for drake::solvers::IntervalBinning |
| Cformatter< drake::solvers::MathematicalProgram > | Specializes the fmt::formatter<> class template for drake::solvers::MathematicalProgram |
| Cformatter< drake::solvers::MixedIntegerRotationConstraintGenerator::Approach > | Specializes the fmt::formatter<> class template for drake::solvers::MixedIntegerRotationConstraintGenerator::Approach |
| Cformatter< drake::solvers::ProgramAttribute > | Specializes the fmt::formatter<> class template for drake::solvers::ProgramAttribute |
| Cformatter< drake::solvers::ProgramAttributes > | Specializes the fmt::formatter<> class template for drake::solvers::ProgramAttributes |
| Cformatter< drake::solvers::ProgramType > | Specializes the fmt::formatter<> class template for drake::solvers::ProgramType |
| Cformatter< drake::solvers::RemoveFreeVariableMethod > | Specializes the fmt::formatter<> class template for drake::solvers::RemoveFreeVariableMethod |
| Cformatter< drake::solvers::SolutionResult > | Specializes the fmt::formatter<> class template for drake::solvers::SolutionResult |
| Cformatter< drake::solvers::SolverId > | Specializes the fmt::formatter<> class template for drake::solvers::SolverId |
| Cformatter< drake::solvers::SolverOptions > | Specializes the fmt::formatter<> class template for drake::solvers::SolverOptions |
| Cformatter< drake::symbolic::ChebyshevBasisElement > | Specializes the fmt::formatter<> class template for drake::symbolic::ChebyshevBasisElement |
| Cformatter< drake::symbolic::ChebyshevPolynomial > | Specializes the fmt::formatter<> class template for drake::symbolic::ChebyshevPolynomial |
| Cformatter< drake::symbolic::Environment > | Specializes the fmt::formatter<> class template for drake::symbolic::Environment |
| Cformatter< drake::symbolic::Expression > | Specializes the fmt::formatter<> class template for drake::symbolic::Expression |
| Cformatter< drake::symbolic::Formula > | Specializes the fmt::formatter<> class template for drake::symbolic::Formula |
| Cformatter< drake::symbolic::GenericPolynomial< BasisElement > > | Specializes the fmt::formatter<> class template for drake::symbolic::GenericPolynomial<BasisElement> |
| Cformatter< drake::symbolic::MonomialBasisElement > | Specializes the fmt::formatter<> class template for drake::symbolic::MonomialBasisElement |
| Cformatter< drake::symbolic::Polynomial > | Specializes the fmt::formatter<> class template for drake::symbolic::Polynomial |
| Cformatter< drake::symbolic::RationalFunction > | Specializes the fmt::formatter<> class template for drake::symbolic::RationalFunction |
| Cformatter< drake::symbolic::Variable > | Specializes the fmt::formatter<> class template for drake::symbolic::Variable |
| Cformatter< drake::symbolic::Variable::Id > | Specializes the fmt::formatter<> class template for drake::symbolic::Variable::Id |
| Cformatter< drake::symbolic::Variable::Type > | Specializes the fmt::formatter<> class template for drake::symbolic::Variable::Type |
| Cformatter< drake::symbolic::Variables > | Specializes the fmt::formatter<> class template for drake::symbolic::Variables |
| Cformatter< drake::systems::BasicVector< T > > | Specializes the fmt::formatter<> class template for drake::systems::BasicVector<T> |
| Cformatter< drake::systems::Context< T > > | Specializes the fmt::formatter<> class template for drake::systems::Context<T> |
| Cformatter< drake::systems::sensors::ImageFileFormat > | Specializes the fmt::formatter<> class template for drake::systems::sensors::ImageFileFormat |
| Cformatter< drake::systems::sensors::PixelFormat > | Specializes the fmt::formatter<> class template for drake::systems::sensors::PixelFormat |
| Cformatter< drake::systems::sensors::PixelScalar > | Specializes the fmt::formatter<> class template for drake::systems::sensors::PixelScalar |
| Cformatter< drake::systems::sensors::PixelType > | Specializes the fmt::formatter<> class template for drake::systems::sensors::PixelType |
| Cformatter< drake::systems::VectorBase< T > > | Specializes the fmt::formatter<> class template for drake::systems::VectorBase<T> |
| Cformatter< drake::TypeSafeIndex< Tag > > | Specializes the fmt::formatter<> class template for drake::TypeSafeIndex<Tag> |
| Cformatter< drake::yaml::LoadYamlOptions > | Specializes the fmt::formatter<> class template for drake::yaml::LoadYamlOptions |
| Cformatter< T > | |
| Nstd | STL namespace |
| Cequal_to< drake::symbolic::Expression > | |
| Cexponential_distribution< drake::symbolic::Expression > | Provides std::exponential_distribution, Exp(λ), for symbolic expressions |
| Chash< drake::geometry::GeometryId > | Enables use of the identifier to serve as a key in STL containers |
| Chash< drake::geometry::render::RenderLabel > | Enables use of the label to serve as a key in STL containers |
| Chash< drake::Identifier< Tag > > | Enables use of the identifier to serve as a key in STL containers |
| Chash< drake::Sha256 > | The STL container hash for Sha256 objects |
| Chash< drake::solvers::Binding< C > > | |
| Chash< drake::solvers::SolverId > | |
| Chash< drake::SortedPair< T > > | Provides std::hash<SortedPair<T>> |
| Chash< drake::symbolic::ChebyshevBasisElement > | |
| Chash< drake::symbolic::ChebyshevPolynomial > | |
| Chash< drake::symbolic::Expression > | |
| Chash< drake::symbolic::Formula > | |
| Chash< drake::symbolic::GenericPolynomial< BasisElement > > | |
| Chash< drake::symbolic::Monomial > | |
| Chash< drake::symbolic::MonomialBasisElement > | |
| Chash< drake::symbolic::Polynomial > | |
| Chash< drake::symbolic::Variable > | |
| Chash< drake::symbolic::Variable::Id > | |
| Chash< drake::symbolic::Variables > | |
| Chash< drake::systems::sensors::PixelType > | |
| Chash< drake::TypeSafeIndex< Tag > > | Enables use of the type-safe index to serve as a key in STL containers |
| Cless< drake::symbolic::Expression > | |
| Cnormal_distribution< drake::symbolic::Expression > | Provides std::normal_distribution, N(μ, σ), for symbolic expressions |
| Cnumeric_limits< drake::symbolic::Expression > | |
| Ctuple_element< Index, drake::SortedPair< T > > | |
| Ctuple_size< drake::SortedPair< T > > | Support using SortedPair<T> in structured bindings |
| Cuniform_real_distribution< drake::symbolic::Expression > | Provides std::uniform_real_distribution, U(a, b), for symbolic expressions |
| Cformatter | |
