Drake

►Ndrake  
►Nassert  
CConditionTraits< Bool< T > >  Provides the specialization of ConditionTraits for Bool<T> so that a value of Bool<T> can be passed to DRAKE_ASSERT/DRAKE_DEMAND macros 
CConditionTraits< symbolic::Formula >  
►Nautomotive  
CAutomotiveSimulator  AutomotiveSimulator is a helper class for constructing and running automotiverelated simulations 
CBicycleCar  BicycleCar implements a nonlinear rigid body bicycle model from Althoff & Dolan (2014) [1] 
CBoxCarVis  BoxCarVis displays a box as the visual representation of a vehicle 
CCarVis  CarVis is a base class that provides visualization geometries and their poses 
CCarVisApplicator  CarVisApplicator takes as input a PoseVector containing vehicle poses 
CClosestPose  ClosestPose bundles together the RoadOdometry of a particular target along with its distance measure relative to the ego vehicle 
►CCurve2  Curve2 represents a path through twodimensional Cartesian space 
CPositionResult  A result type for the GetPosition method 
CDrivingCommandMux  A specialpurpose multiplexer that packs two scalar inputs, steering angle (in units rad) and acceleration (in units m/s^2), into a vectorvalued output of type DrivingCommand<T>, where the inputs feed directly through to the output 
CDynamicBicycleCar  DynamicBicycleCar implements a planar rigid body bicycle model of an automobile with a nonlinear brush tire model from Bobier (2012) [1] 
CIdmController  IdmController implements the IDM (Intelligent Driver Model) planner, computed based only on the nearest car ahead 
CIdmPlanner  IdmPlanner implements the IDM (Intelligent Driver Model) equation governing longitudinal accelerations of a vehicle in singlelane traffic [1, 2] 
CLaneDirection  LaneDirection holds the lane that a MaliputRailcar is traversing and the direction in which it is moving 
CMaliputRailcar  MaliputRailcar models a vehicle that follows a maliput::api::Lane as if it were on rails and neglecting all physics 
CMobilPlanner  MOBIL (Minimizing Overall Braking Induced by Lane Changes) [1] is a planner that minimizes braking requirement for the ego car while also minimizing (per a weighting factor) the braking requirements of any trailing cars within the ego car's immediate neighborhood 
CMonolaneOnrampMerge  MonolaneOnrampMerge contains an example lanemerge scenario expressed as a maliput monolane road geometry 
CMultilaneOnrampMerge  MultilaneOnrampMerge contains an example lanemerge scenario expressed as a maliput mulitilane road geometry 
CMultilaneRoadCharacteristics  MultilaneRoadCharacteristics computes and stores characteristics of a multilane road network; i.e 
CPoseSelector  PoseSelector is a class that provides the relevant pose or poses with respect to a given ego vehicle driving within a given maliput road geometry 
CPoseVelocity  Wraps the raw data contained in a trajectory expressed in terms of pose and velocity values 
CPriusVis  PriusVis displays a visualization of a 2015 Toyota Prius 
CPurePursuit  PurePursuit computes the required steering angle to achieve a goal point on an continuous planar path 
CPurePursuitController  PurePursuitController implements a pure pursuit controller 
CRoadCharacteristics  RoadCharacteristics computes and stores characteristics of a road network; i.e 
CRoadOdometry  RoadOdometry contains the position of the vehicle with respect to a lane in a road, along with its velocity vector in the world frame 
CRoadPath  RoadPath converts a sequence of Maliput Lanes into a PiecewisePolynomial for the purpose of generating a path for a car to follow 
CSimpleCar  SimpleCar models an idealized response to driving commands, neglecting all physics 
CSimplePowertrain  SimplePowertrain models a powertrain with firstorder lag 
CTrajectory  A class that wraps a piecewise trajectory instantiated from pose data 
CTrajectoryCar  TrajectoryCar models a car that follows a preestablished trajectory 
CTrajectoryFollower  TrajectoryFollower simply moves along a preestablished trajectory 
CTrivialRightOfWayStateProvider  A trivial implementation of an api::rules::RightOfWayStateProvider 
►Nbenchmarks  
►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 toquefree rigid body B with axially symmetric inertia, in a Newtonian frame (World) N 
►Nbouncing_ball  
CBouncingBall  Dynamical representation of the idealized hybrid dynamics of a ball dropping from a height and bouncing on a surface 
►Ncommon  
►Ninternal  
CPythonAccessor  
CPythonApi  
CPythonAttrPolicy  
CPythonItemPolicy  
CMatlabRemoteVariable  Holds a reference to a variable stored on the matlab client, which can be passed back into a future lcm_call_matlab call 
CPythonRemoteVariable  Presents variable stored in Python side 
►Ndetail  
Cassert_default_constructible  
Cassertion_error  This is what DRAKE_ASSERT and DRAKE_DEMAND throw when our assertions are configured to throw 
CFNV1aHasher  The FNV1a hash algorithm, used for hash_append generic hashing 
Ctype_at_impl  
Ctype_at_impl< N, N, T, Ts... >  
Ctype_pack_extract_impl  
Ctype_pack_extract_impl< Tpl< Ts... > >  
►Ctype_visit_impl  
Crunner  
Crunner< T, false >  
►Nexamples  
►Nacrobot  
CAcrobotCommandReceiver  Receives the output of an LcmSubscriberSystem that subscribes to the acrobot input channel with LCM type lcmt_acrobot_u, and outputs the acrobot input as a BasicVector 
CAcrobotCommandSender  Receives the output of an acrobot controller, and outputs it as an LCM message with type lcm_acrobot_u 
CAcrobotPlant  The Acrobot  a canonical underactuated system as described in Chapter 3 of Underactuated Robotics 
CAcrobotSpongController  
CAcrobotStateReceiver  Receives the output of an LcmSubsriberSystem that subsribes to the acrobot state channel with LCM type lcmt_acrobot_x, and outputs the acrobot states as an AcrobotState 
CAcrobotStateSender  Receives the output of an acrobot_plant, and outputs it as an LCM message with type lcm_acrobot_x 
CAcrobotWEncoder  Constructs the Acrobot with (only) encoder outputs 
►Nbead_on_a_wire  
CBeadOnAWire  Dynamical system of a point (unit) mass constrained to lie on a wire 
►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 with a few small differences 
►Ndouble_pendulum  
►Ngeometry_world  
►Nbouncing_ball  
CBouncingBallPlant  A model of a bouncing ball with HuntCrossley compliant contact model 
►Nhumanoid_controller  
CAtlasCommandTranslatorSystem  A class that extends QpOutputTranslatorSystem to output an additional bot_core::atlas_command_t 
CBodyOfInterest  An object that holds important kinematic properties 
CHumanoidController  A controller for humanoid balancing built on top of HumanoidPlanEvalSystem and QpInverseDynamicsSystemSystem 
CHumanoidPlanEvalSystem  This class extends PlanEvalBaseSystem to interpret plans for humanoid robots 
CHumanoidStatus  Mostly a thin wrapper on RigidBodyTree 
CRobotStateMsgToHumanoidStatusSystem  Translates a bot_core::robot_state_t message to HumanoidStatus 
►Nkinova_jaco_arm  
CJacoCommandReceiver  Handles lcmt_jaco_command messages 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_arm  
►Npick_and_place  
CAction  Base class for actions used by the pick and place demo 
CIiwaMove  A class that represents an action that sends a sequence of desired joint positions through LCM to move the KUKA iiwa arm 
COptitrackConfiguration  Optitrack information required for a pickandplace scenario with multiple arms, tables, and manipulable objects 
COptitrackInfo  Information required to track a model from an Optitrack frame 
CPickAndPlaceStateMachine  A class which controls the pick and place actions for moving a single target in the environment 
CPlannerConfiguration  Information required to set up a planner for a pickandplace task 
CSimulatedPlantConfiguration  Information required to set up a simulation of a pickandplace scenario with multiple arms, tables, and manipulable objects 
CWorldState  A class that represents the iiwa pick and place world, which contains a KUKA iiwa arm, a Schunk WSG gripper, and an object that is being manipulated 
CWsgAction  An Action that closes / opens the gripper 
CIiwaAndWsgPlantWithStateEstimator  A custom systems::Diagram composed of a systems::RigidBodyPlant, a systems::controllers::InverseDynamicsController, and a number of OracularStateEstimation systems 
CIiwaCommandReceiver  Handles lcmt_iiwa_command messages from a LcmSubscriberSystem 
CIiwaCommandSender  Creates and outputs lcmt_iiwa_command messages 
CIiwaContactResultsToExternalTorque  A translator class that converts the contact force field in systems::ContactResults to external joint torque for a set of specified model instances in RigidBodyTree 
CIiwaStatusReceiver  Handles lcmt_iiwa_status messages from a LcmSubscriberSystem 
CIiwaStatusSender  Creates and outputs lcmt_iiwa_status messages 
CLcmPlanInterpolator  
COracularStateEstimation  A System block that takes state vector and output a bot_core::robot_state_t message 
►Nmultibody  
►Nparticles  
CParticle  A linear 1DOF particle system 
►Npendulum  
CPendulumPlant  A model of a simple pendulum \[ ml^2 \ddot\theta + b\dot\theta + mgl\sin\theta = u \] 
►Nqp_inverse_dynamics  
CManipulatorJointSpaceController  This class implements an example of a general purpose controller for a fixed based manipulator based on qp inverse dynamics 
CManipulatorMoveJointPlanEvalSystem  This class extends PlanEvalBaseSystem 
►Nquadrotor  
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: 
►Nrod2d  
CRod2D  Dynamical system representation of a rod contacting a halfspace in two dimensions 
►Nsolar_system  
CSolarSystem  A model of an orrery – a simple mechanical model of the solar system 
►Nvalkyrie  
CValkyrieSimulationDiagram  
►Nvan_der_pol  
CVanDerPolOscillator  Van der Pol oscillator 
►Ngeometry  
►Ninternal  
CInternalAnchoredGeometry  This class represents the internal representation of registered anchored geometry 
CInternalFrame  This class represents the internal representation of a GeometryFrame 
CInternalGeometry  This class represents the internal representation of registered dynamic geometry 
CInternalGeometryBase  Base class for the internal representation of registered geometry 
CProximityEngine  The underlying engine for performing geometric proximity queries 
CBox  Definition of a box 
CCylinder  Definition of a cylinder 
CFrameKinematicsVector  A FrameKinematicsVector is used to report kinematics data for registered frames (identified by unique FrameId values) to SceneGraph 
CGeometryContext  The custom leaf context type for SceneGraph 
CGeometryFrame  This simple class carries the definition of a frame used in the 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 
CGeometrySet  The GeometrySet, as its name implies, is a convenience class for defining a set of geometries 
CGeometryState  The contextdependent state of SceneGraph 
CHalfSpace  Definition of a half space 
CIdentifier  A simple identifier class 
CMesh  Limited support for meshes 
CPenetrationAsPointPair  A characterization of the intersection of two penetrating geometries 
CQueryObject  The QueryObject serves as a mechanism to perform geometry queries on the world's geometry 
CSceneGraph  SceneGraph serves as the nexus for all geometry (and geometrybased operations) in a Diagram 
CSceneGraphInspector  The SceneGraphInspector serves as a mechanism to query the topological structure of a SceneGraph instance 
CShape  The base interface for all shape specifications 
CShapeReifier  The interface for converting shape descriptions to real shapes 
CShapeTag  Simple struct for instantiating the typespecific Shape functionality 
CSignedDistancePair  The data for reporting the signed distance between two geometries, A and B 
CSphere  Definition of sphere 
CVisualMaterial  Definition of material for simple visualization 
►Nlcm  
CDrakeLcm  A wrapper around a real LCM instance 
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 
CDrakeMockLcm  A mock LCM instance 
CLcmReceiveThread  Maintains a thread that receives LCM messages and dispatches the messages to the appropriate message handlers 
CTranslatorBase  Base API for a translator between arbitrary data of DataType and a Lcm message of MsgType 
►Nlogging  
Clogger  A stubbedout version of spdlog::logger 
►Nmaliput  
►Napi  
►Nrules  
►Ntest  
CAssertionResultCollector  AssertionResultCollector helps with the creation of concise and welltraced testing subroutines when using googletest 
CLaneSRange  Directed longitudinal range of a specific Lane, identified by a LaneId 
CLaneSRoute  A longitudinal route, possibly spanning multiple (endtoend) lanes 
►CRightOfWayRule  Rule describing rightofway, a.k.a 
CState  Semantic state of a RightOfWayRule 
►CRightOfWayStateProvider  Abstract interface for the provider of the state of a dynamic (multiple state) RightOfWayRule 
►CResult  Result returned by GetState() 
CNext  Information about a subsequent State 
►CRoadRulebook  Abstract interface for querying "rules of the road" 
CQueryResults  Results of a FindRules() query 
CSpeedLimitRule  Rule describing speed limits 
CSRange  Directed, inclusive longitudinal (s value) range from s0 to s1 
CBasicIdIndex  Basic generalpurpose concrete implementation of the RoadGeometry::IdIndex interface 
CBranchPoint  A BranchPoint is a node in the network of a RoadGeometry at which Lanes connect to one another 
CGeoPositionT  A position in 3dimensional geographical Cartesian space, i.e., in the world frame, consisting of three components x, y, and z 
CHBounds  Bounds in the elevation dimension (h component) of a Lane frame, consisting of a pair of minimum and maximum h value 
CIsoLaneVelocity  Isometric velocity vector in a Lane frame 
CJunction  A Junction is a closed set of Segments which have physically coplanar road surfaces, in the sense that RoadPositions with the same h value (height above surface) in the domains of two Segments map to the same GeoPosition 
CLane  A Lane represents a lane of travel in a road network 
►CLaneEnd  A specific endpoint of a specific Lane 
CStrictOrder  An arbitrary strict complete ordering, useful for, e.g., std::map 
CLaneEndSet  A set of LaneEnds 
CLanePositionT  A 3dimensional position in a Lane frame, consisting of three components: 
CRBounds  Bounds in the lateral dimension (r component) of a Lane frame, consisting of a pair of minimum and maximum r value 
►CRoadGeometry  Abstract API for the geometry of a road network, including both the network topology and the geometry of its embedding in 3space 
CIdIndex  Abstract interface for a collection of methods which allow accessing objects in a RoadGeometry's object graph (Lanes, Segments, Junctions, BranchPoints) by their unique id's 
CRoadPosition  A position in the road network, consisting of a pointer to a specific Lane and a Lane frame position in that Lane 
CRotation  A 3dimensional rotation 
CSegment  A Segment represents a bundle of adjacent Lanes which share a continuously traversable road surface 
CTypeSpecificIdentifier  TypeSpecificIdentifier<T> represents an identifier specifically identifying an entity of type T 
►Ndragway  
CBranchPoint  Dragway's implementation of api::BranchPoint 
CJunction  Dragway's implementation of api::Junction 
CLane  Dragway's implementation of api::Lane 
CLaneEndSet  Dragway's implementation of api::LaneEndSet 
CRoadGeometry  Dragway's implementation of api::RoadGeometry 
CSegment  Dragway's implementation of api::Segment 
►Nmonolane  
CArcLane  Specialization of Lane with a circular arc as its reference curve in the xyplane (the ground plane) of the world frame 
CArcOffset  Specification for path offset along a circular arc 
CBranchPoint  An implementation of api::BranchPoint 
CBuilder  Convenient builder class which makes it easy to construct a monolane road network 
CConnection  Representation of a reference path connecting two endpoints 
CCubicPolynomial  A cubic polynomial, f(p) = a + b*p + c*p^2 + d*p^3 
CEndpoint  Complete set of parameters for an endpoint of a connection, specified in the world frame 
CEndpointXy  XYplaneonly parameters for an endpoint of a connection, specified in the world frame 
CEndpointZ  Outofplane parameters for an endpoint of a connection, specified in the world frame 
CGroup  A group of Connections 
CJunction  An api::Junction implementation 
CLane  Base class for the monolane implementation of api::Lane 
CLaneEndSet  An implementation of LaneEndSet 
CLineLane  Specialization of Lane with a line segment as its reference curve in the xyplane (the ground plane) of the world frame 
CRoadGeometry  A simple api::RoadGeometry implementation that only supports a single lane per segment 
CRot3  An R^3 rotation parameterized by roll, pitch, yaw 
CSegment  An api::Segment implementation 
►Nmultilane  
►Ntest  
CArcOffsetMatcher  Wraps an ArcOffset comparison into a MatcherInterface 
CEndLaneSpecMatcher  Wraps a EndLane::Spec comparison into a MatcherInterface 
CEndReferenceSpecMatcher  Wraps a EndReference::Spec comparison into a MatcherInterface 
CHBoundsMatcher  Wraps api::HBounds comparison into a MatcherInterface 
CLaneLayoutMatcher  Wraps a LineOffset comparison into a MatcherInterface 
CLineOffsetMatcher  Wraps a LineOffset comparison into a MatcherInterface 
CStartLaneSpecMatcher  Wraps a StartLane::Spec comparison into a MatcherInterface 
CStartReferenceSpecMatcher  Wraps a StartReference::Spec comparison into a MatcherInterface 
CArcOffset  Specification for path offset along a circular arc 
CArcRoadCurve  RoadCurve specification for a reference curve that describes a piece of an arc 
CBranchPoint  An implementation of api::BranchPoint 
CBuilder  Convenient builder class which makes it easy to construct a multilane road network 
CBuilderBase  Defines a builder interface for multilane 
CBuilderFactory  Implements a BuilderFactoryBase to construct Builder objects 
CBuilderFactoryBase  Factory interface to construct BuilderBase instances 
CConnection  Representation of a reference path connecting two endpoints 
CCubicPolynomial  A cubic polynomial, f(p) = a + b*p + c*p^2 + d*p^3 
►CEndLane  Provides methods to build an EndLane::Spec 
CSpec  Defines how a Connection's lane curve ends 
CEndpoint  Complete set of parameters for an endpoint of a connection, specified in the world frame 
CEndpointXy  XYplaneonly parameters for an endpoint of a connection, specified in the world frame 
CEndpointZ  Outofplane parameters for an endpoint of a connection, specified in the world frame 
►CEndReference  Provides methods to build an EndReference::Spec 
CSpec  Defines how a Connection's reference curve ends 
CGroup  A group of Connections 
CJunction  An api::Junction implementation 
CLane  Base class for the multilane implementation of api::Lane 
CLaneEndSet  An implementation of LaneEndSet 
CLaneLayout  Wraps all the lanerelated specifications in a Connection 
CLineOffset  Specification for path offset along a line 
CLineRoadCurve  RoadCurve specification for a reference curve that describes a line 
CRoadCurve  Defines an interface for a path in a Segment object surface 
CRoadGeometry  A simple api::RoadGeometry implementation that only supports a single lane per segment 
CRot3  An R^3 rotation parameterized by roll, pitch, yaw 
CSegment  An api::Segment implementation 
►CStartLane  Provides methods to build an StartLane::Spec 
CSpec  Defines how a Connection's lane curve starts 
►CStartReference  Provides methods to build an StartReference::Spec 
CSpec  Defines how a Connection's reference curve starts 
►Nrndf  
CArcLengthParameterizedSpline  An extension for ignition::math::Splines that reparameterizes them by path length 
CBranchPoint  An implementation of api::BranchPoint for RNDF 
CBuilder  A class to ease the construction of a RoadGeometry from Connection and DirectedWaypoint objects 
CConnection  A container that holds the information needed by a Builder to construct one or more Lane objects 
CDirectedWaypoint  A container that holds the information needed by a Builder to construct a Lane from a sequence of ignition::rndf::Waypoint objects 
CInverseFunctionInterpolator  A linear interpolator for arbitrary inverse functions 
CJunction  An api::Junction implementation for RNDF 
CLane  Base class for the RNDF implementation of api::Lane 
CLaneEndSet  An implementation of LaneEndSet for RNDF 
CRoadCharacteristics  Holds common api::RoadGeometry characteristics needed to construct one 
CRoadGeometry  An api::RoadGeometry implementation for RNDF specification 
CSegment  An api::Segment implementation for RNDF 
CSplineLane  Specialization of drake::maliput::rndf::Lane with a spline curve as its reference path 
►Nsimplerulebook  
CSimpleRulebook  SimpleRulebook is a simple concrete implementation of the api::rules::RoadRulebook abstract interface 
►Nutility  
CObjFeatures  Multitude of parameters for generating an OBJ model of a road surface, with sensible defaults 
►Nmanipulation  
►Nperception  
COptitrackPoseExtractor  Extracts and provides an output of the pose of a desired object as an Eigen::Isometry3d from an Optitrack LCM OPTITRACK_FRAME_T message, the pose transformed to a desired coordinate frame 
CPoseSmoother  This class accepts the pose of a rigid body (composed by a Eigen::Isometry3d) and returns a smoothed pose by performing either the first or both of these processes : i 
►Nplanner  
►CConstraintRelaxingIk  A wrapper class around the IK planner 
CIkCartesianWaypoint  Cartesian waypoint 
CDifferentialInverseKinematicsParameters  Contains parameters for differential inverse kinematics 
CDifferentialInverseKinematicsResult  
CRobotPlanInterpolator  This class implements a source of joint positions for a robot 
►Nscene_generation  
CRandomClutterGenerator  Given a RigidBodyTree containing a given scene, the RandomClutterGenerator can repeatedly generate bounded random poses/configurations on selected model instances within the tree 
CSimulatePlantToRest  Given a RigidBodyPlant, this class allows the construction and execution of a simulation which enables the state of the plant to come to a rest from a specified initial condition 
►Nschunk_wsg  
CSchunkWsgController  This class implements a controller for a Schunk WSG gripper 
CSchunkWsgPlainController  This class implements a controller for a Schunk WSG gripper as a systems::Diagram 
CSchunkWsgStatusSender  Sends lcmt_schunk_wsg_status messages for a Schunk WSG 
CSchunkWsgTrajectoryGenerator  Receives lcmt_schunk_wsg_command for a Schunk WSG (input port 0) along with the current state of the simulated WSG (input port 1), and emits target position/velocity for the actuated finger to reach the commanded target 
►Nsensors  
CXtion  Attaches an Asus Xtion PRO Live camera to a given frame on a RigidBodyTree, and provides the ability to add the camera as a system in a diagram builder 
►Nutil  
CFramePoseTracker  Implements a class that maintains pose information for a set of specified RigidBodyFrames 
CModelInstanceInfo  
CMovingAverageFilter  The implementation of a Moving Average Filter 
CSimDiagramBuilder  A wrapper class around DiagramBuilder that facilitates diagram building for controlled simulation 
CWorldSimTreeBuilder  A helper class to construct robot world RigidBodyTree objects from model (URDF/SDF) files 
CPiecewiseCartesianTrajectory  A wrapper class that represents a Cartesian trajectory, whose position part is a PiecewiseCubicTrajectory, and the rotation part is a PiecewiseQuaternionSlerp 
CPiecewiseCubicTrajectory  A wrapper class that stores a PiecewisePolynomial and its first and second derivatives 
CRobotStateLcmMessageTranslator  This is a utility class for converting bot_core::robot_state_t message to and from various eigen vectors that correspond to the generalized position, velocity and actuator torque 
CSimpleTreeVisualizer  A utility to render a RigidBodyTree in a specified configuration 
►Nmath  
►Ninternal  
CInitializeAutoDiffTupleHelper  Helper for initializeAutoDiffTuple function (recursive) 
CInitializeAutoDiffTupleHelper< 0 >  Helper for initializeAutoDiffTuple function (base case) 
CResizeDerivativesToMatchScalarImpl  
CResizeDerivativesToMatchScalarImpl< Derived, Eigen::AutoDiffScalar< DerivType > >  
CTotalSizeAtCompileTime  Helper for totalSizeAtCompileTime function (recursive) 
CTotalSizeAtCompileTime< Head >  Helper for totalSizeAtCompileTime function (base case) 
CAutoDiffToGradientMatrix  
CAutoDiffToValueMatrix  
CBarycentricMesh  Represents a multilinear function (from vector inputs to vector outputs) by interpolating between points on a mesh using (triangular) barycentric interpolation 
CGetSubMatrixGradientArray  
CGetSubMatrixGradientSingleElement  
CGradient  
CGradient< Derived, Nq, 1 >  
CGrayCodesMatrix  GrayCodesMatrix::type returns an Eigen matrix of integers 
CGrayCodesMatrix< Eigen::Dynamic >  
CMatGradMult  
CMatGradMultMat  
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 Spacefixed (extrinsic) XYZ rotation by "rollpitchyaw" angles [r, p, y] , which is equivalent to a Bodyfixed (intrinsic) ZYX rotation by "yawpitchroll" 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() 
►Nkuka_iiwa_robot  
►Ninternal  
CKukaIiwaModelBuilder  
►NMG  
CMGKukaIIwaRobot  This class is Drake's interface to the MotionGenesis solution for a 7DOF KUKA LBR iiwa robot (14 kg payload) which is described at: https://www.kuka.com/ende/products/robotsystems/industrialrobots/lbriiwa Geometry, jointtypes, and mass/inertia properties are contained in: drake/multibody/benchmarks/kuka_iiwa_robot/kuka_iiwa_robot.urdf 
CDrakeKukaIIwaRobot  This class is a MultibodyTree model for a 7DOF Kuka iiwa robot arm 
CKukaRobotJointReactionForces  Utility struct to assist with returning joint torques/forces 
►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 massdamperspring system 
►Ncollision  
CBulletCollisionWorldWrapper  
CBulletModel  
CCollisionFilterGroup  The specification of a collision filter group: its name, bodies that belong to it, and the names of collision filter groups that it ignores 
CCollisionFilterGroupManager  This class provides management utilities for the definition of collision filter groups for RigidBodyTree instances 
CElement  The underyling primitive class used for collision analysis 
CFclModel  
CModel  Model is an abstract base class of a collision model 
COverlapFilterCallback  
CPointPair  Structure containing the results of a collision query 
CUnknownShapeException  
CUnusableModel  An unusable model, used when no collision detection backend is available 
►Nconstraint  
CConstraintAccelProblemData  Structure for holding constraint data for computing forces due to constraints and the resulting multibody accelerations 
►CConstraintSolver  Solves constraint problems for constraint forces 
CMlcpToLcpData  Structure used to convert a mixed linear complementarity problem to a pure linear complementarity problem (by solving for free variables) 
CConstraintVelProblemData  Structure for holding constraint data for computing constraint forces at the velocitylevel (i.e., impact problems) 
►Nimplicit_stribeck  
►Ninternal  
CDirectionChangeLimiter  This struct implements an internal (thus within internal:: ) detail of the implicit Stribeck solver 
CImplicitStribeckSolver  
CIterationStats  Struct used to store information about the iteration process performed by ImplicitStribeckSolver 
CParameters  These are the parameters controlling the iteration process of the ImplicitStribeckSolver solver 
►Ninternal  
CBodyNode  For internal use only of the MultibodyTree implementation 
CBodyNodeImpl  For internal use only of the MultibodyTree implementation 
CBodyNodeWelded  This class represents a BodyNode for nodes with zero degrees of freedom 
CModelInstance  
►Nmultibody_plant  
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 
CCoulombFriction  Parameters for Coulomb's Law of Friction, namely: 
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 
CPointPairContactInfo  A class containing information regarding contact response between two bodies including: 
►Nmultibody_tree  
►Ntest  
CAxiallySymmetricFreeBodyPlant  This plant models the free motion of a torque free body in space 
CFreeRotatingBodyPlant  This plant models the rotational motion of a torque free body in space 
►Ntest_utilities  
CSpatialKinematicsPVA  Utility class containing the transform and spatial velocity/acceleration of an arbitrary frame B in another arbitrary frame N (e.g., the world) 
►Nparsers  
►Nparsing  
CFrameCache  Keeps a set of frames and the transforms that relate them, using a root or fixed frame to conjoin them all 
CFramedIsometry3  An isometric transform along with the frame in which it is defined 
CSdfJoint  A representation of a <joint> element in an SDF file 
CSdfLink  A representation of a <link> element in an SDF file 
CSdfModel  This class provides a representation of a <model> element within a given SDF specification 
CSdfSpec  This class provides a representation for an SDF specification 
►Ntest  
CAccelerationKinematicsCache  This class is one of the cache entries in MultibodyTreeContext 
CArticulatedBodyInertia  Articulated Body Inertia is the inertia that a body appears to have when it is the base (or root) of a rigidbody system, also referred to as Articulated Body in the context of articulated body algorithms 
CArticulatedBodyInertiaCache  This class is one of the cache entries in MultibodyTreeContext 
CBody  Body provides the general abstraction of a body with an API that makes no assumption about whether a body is rigid or deformable and neither does it make any assumptions about the underlying physical model or approximation 
CBodyFrame  A BodyFrame is a material Frame that serves as the unique reference frame for a Body 
CBodyNodeTopology  Data structure to store the topological information associated with a tree node 
CBodyTopology  Data structure to store the topological information associated with a Body 
CFixedOffsetFrame  FixedOffsetFrame represents a material frame F whose pose is fixed with respect to a parent material frame P 
CForceElement  A ForceElement allows modeling state and time dependent forces in a MultibodyTree model 
CForceElementTopology  Data structure to store the topological information associated with a ForceElement 
CFrame  Frame is an abstract class representing a material frame (also called a physical frame), meaning that it is associated with a material point of a Body 
CFrameBase  FrameBase is an abstract representation of the concept of a frame in multibody dynamics 
CFrameTopology  Data structure to store the topological information associated with a Frame 
►CGlobalInverseKinematics  Solves the inverse kinematics problem as a mixed integer convex optimization problem 
COptions  
►CJoint  A Joint models the kinematical relationship which characterizes the possible relative motion between two bodies 
CBluePrint  (Advanced) Structure containing all the information needed to build the MultibodyTree implementation for a Joint 
CJointImplementation  (Advanced) A Joint is implemented in terms of MultibodyTree elements such as bodies, mobilizers, force elements and constraints 
CJointActuator  The JointActuator class is mostly a simple bookkeeping structure to represent an actuator acting on a given Joint 
CJointActuatorTopology  Data structure to store the topological information associated with a JointActuator 
CLinearSpringDamper  This ForceElement models a springdamper attached between two points on two different bodies 
CMobilizer  Mobilizer is a fundamental object within Drake's multibody engine used to specify the allowed motions between two Frame objects within a MultibodyTree 
CMobilizerImpl  Base class for specific Mobilizer implementations with the number of generalized positions and velocities resolved at compile time as template parameters 
CMobilizerTopology  Data structure to store the topological information associated with a Mobilizer object 
CMultibodyForces  A class to hold a set of forces applied to a MultibodyTree system 
CMultibodyTree  MultibodyTree provides a representation for a physical system consisting of a collection of interconnected rigid and deformable bodies 
CMultibodyTreeContext  MultibodyTreeContext is an object that contains all the information needed to uniquely determine the state of a MultibodyTree 
CMultibodyTreeElement< ElementType< T >, ElementIndexType >  A class representing an element or component of a MultibodyTree 
CMultibodyTreeTopology  Data structure to store the topological information associated with an entire MultibodyTree 
CPositionKinematicsCache  This class is one of the cache entries in MultibodyTreeContext 
CPrismaticJoint  This Joint allows two bodies to translate relative to one another along a common axis 
CPrismaticMobilizer  This Mobilizer allows two frames to translate relative to one another along an axis whose direction is constant when measured in either this mobilizer's inboard frame or its outboard frame 
CQuaternionFloatingMobilizer  This Mobilizer allows two frames to move freely relatively to one another 
CRevoluteJoint  This Joint allows two bodies to rotate relatively to one another around a common axis 
CRevoluteMobilizer  This Mobilizer allows two frames to rotate relatively to one another around an axis that is constant when measured in either this mobilizer's inboard or outboard frames, while the distance between the two frames does not vary 
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 
CRotationalInertia  This class helps describe the mass distribution (inertia properties) of a body or composite body about a particular point 
CSpaceXYZMobilizer  This mobilizer models a gimbal joint between an inboard frame F and an outboard frame M that allows frame M to rotate freely with respect to F ( though a gimbal joint provides arbitrary orientation like a ball joint but with some restrictions, discussed below) 
CSpatialAcceleration  This class is used to represent a spatial acceleration that combines rotational (angular acceleration) and translational (linear acceleration) components 
CSpatialForce  This class is used to represent a spatial force (also called a wrench) that combines both rotational (torque) and translational force components 
CSpatialInertia  This class represents the physical concept of a Spatial Inertia 
CSpatialMomentum  This class is used to represent the spatial momentum of a particle, system of particles or body (whether rigid or soft.) The linear momentum l_NS of a system of particles S in a reference frame N is defined by: 
CSpatialVector  This class is used to represent physical quantities that correspond to spatial vectors such as spatial velocities, spatial accelerations and spatial forces 
CSpatialVelocity  This class is used to represent a spatial velocity (also called a twist) that combines rotational (angular) and translational (linear) velocity components 
CUniformGravityFieldElement  This ForceElement allows modeling the effect of a uniform gravity field as felt by bodies on the surface of the Earth 
CUnitInertia  This class is used to represent rotational inertias for unit mass bodies 
CVelocityKinematicsCache  This class is one of the cache entries in MultibodyTreeContext 
CWeldJoint  This Joint fixes the relative pose between two frames as if "welding" them together 
CWeldMobilizer  This mobilizer fixes the relative pose X_FM of an outboard frame M in an inboard frame F as if "welding" them together at this fixed relative pose 
►Nparsers  
CFloatingJointConstants  Defines constants used by AddFloatingJoint() 
CPackageMap  Maps ROS package names to their full path on the local file system 
►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 
CTransformPointCloud  Transforms a point cloud to the world frame or to an arbitrary frame 
►Npydrake  
►Ndetail  
Cfunction_info  
Cfunctor_helpers  
Ctype_caster_wrapped  
Cwrap_callback  
Cwrap_callback< const std::function< Signature > & >  
Cwrap_callback< std::function< Signature > >  
►Cwrap_function_impl  
Cwrap_arg_functions  
Cwrap_arg_functions< const std::function< Return(Args...)> & >  
Cwrap_arg_functions< std::function< Signature > >  
Cwrap_type  
Cwrap_type< void, Extra >  
Cwrap_ref_ptr  
Cwrap_ref_ptr< T &, std::enable_if_t< is_generic_pybind< T >::value > >  
Cwrapper_eigen_translation  
CMirrorDef  Defines a function in object a and mirrors def calls to object b 
Coverload_cast_impl  
Cwrap_arg_default  Default case for argument wrapping, with pure passthrough 
►Nsolvers  
►Ndetail  
Cassert_if_is_constraint  Template condition to only catch when Constraints are inadvertently passed as an argument 
CFunctionTraits  FunctionTraits 
CFunctionTraits< std::reference_wrapper< F > >  
CFunctionTraits< std::shared_ptr< F > >  
CFunctionTraits< std::unique_ptr< F > >  
Cis_binding_compatible  Enables us to catch and provide a meaningful assertion if a Constraint is passed in, when we should have a Cost 
Cis_convertible_workaround  
Cis_convertible_workaround< std::unique_ptr< A >, std::shared_ptr< B > >  
Cis_cost_functor_candidate  Template condition to check if F is a candidate to be used to construct a FunctionCost object for generic costs 
►Ninternal  
CSymbolicError  
►Ntest  
CConvexCubicProgramExample  A simple convex optimization program min 12 * x + x³ s.t x >= 0 Notice the objective function is convex in the feasible region x >= 0 The optimal solution is x = 2 
CGenericTrivialConstraint1  
CGenericTrivialCost1  
CGenericTrivialCost2  
CGloptiPolyConstrainedMinimizationProblem  GloptiPolyConstrainedMinimization 
CInfeasibleLinearProgramTest0  An infeasible linear program 
CLinearFeasibilityProgram  Test a simple linear programming problem with zero cost, i.e 
CLinearMatrixEqualityExample  For a stable linear system ẋ = A x, find its Lyapunov function by solving the Lyapunov equality on the symmetric matrix X Aᵀ * X + X * A = E 
CLinearProgram0  Adapt from the linear programming example http://cvxopt.org/examples/tutorial/lp.html Solve the following linear program min 2x0 + x1 s.t inf <= x0 + x1 <= 1 2 <= x0 + x1 <=inf inf <= x0  2x1 <= 4 x1 >= 2 x0 >= 0 The optimal solution is x0 = 1, x1 = 2 
CLinearProgram1  
CLinearProgram2  
CLinearProgram3  
CLinearProgramTest  
CLinearSystemExample1  Simple example x = b 
CLinearSystemExample2  Simple linear system x = b 2 * y(0) = b(0) 2 * y(1) = b(1) 
CLinearSystemExample3  Simple linear system 3 * x = b 2 * y(0) = b(0) 2 * y(1) = b(1) 
CLowerBoundedProblem  This test comes from Section 3.4 of Handbook of Test Problems in Local and Global Optimization 
CMinDistanceFromPlaneToOrigin  An SOCP with Lorentz cone and rotated Lorentz cone constraints 
CNonConvexQPproblem1  This test comes from Section 2.2 of Handbook of Test Problems in Local and Global Optimization 
CNonConvexQPproblem2  This test comes from Section 2.3 of Handbook of Test Problems in Local and Global Optimization 
COptimizationProgram  
CQuadraticProgram0  
CQuadraticProgram1  Adapt from the simple test on the Gurobi documentation 
CQuadraticProgram2  
CQuadraticProgram3  
CQuadraticProgram4  
CQuadraticProgramTest  
CTestEllipsoidsSeparation  This test is taken from the course notes of EE127A from University of California, Berkeley The goal is to find a hyperplane, that separates two ellipsoids E₁ = x₁ + R₁ * u₁, u₁ ≤ 1 E₂ = x₂ + R₂ * u₂, u₂ ≤ 1 A hyperplane aᵀ * x = b separates these two ellipsoids, if and only if for SOCP p* = min t₁ + t₂ s.t t₁ ≥ R₁ᵀ * a t₂ ≥ R₂ᵀ * a aᵀ(x₂x₁) = 1 the optimal solution p* is no larger than 1 
CTestFindSpringEquilibrium  
CTestQPasSOCP  This example is taken from the course notes of EE127A from University of California, Berkeley For a quadratic program 0.5 * x' * Q * x + c' * x s.t b_lb <= A * x <= b_ub It can be casted as an SOCP, as follows By introducing a new variable w = Q^{1/2}*x and y, z The equivalent SOCP is min c'x + y s.t 2 * y >= w' * w w = Q^{1/2} * x b_lb <= A * x <= b_ub 
CUnboundedLinearProgramTest0  An unbounded linear program 
CUnboundedLinearProgramTest1  An unbounded linear program 
CUnitLengthProgramExample  A simple nonconvex problem with a quadratic equality constraint min 0 s.t xᵀx = 1 This test is meant to verify that we can add a quadratic constraint to a program, and solve it through nonlinear optimization 
CAddRotationMatrixBoxSphereIntersectionReturn  Some of the newly added variables in function AddRotationMatrixBoxSphereIntersectionMilpConstraints 
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 
CConstraint  A constraint is a function + lower and upper bounds 
CCost  Provides an abstract base for all costs 
CDrealSolver  
CEqualityConstrainedQPSolver  
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 
CExpressionConstraint  Impose a generic (potentially nonlinear) constraint represented as a vector of symbolic Expression 
CFunctionEvaluator  An evaluator that may be specified using a callable object 
►CGurobiSolver  
CSolveStatusInfo  Contains info returned to a user function that handles a Node or Solution callback 
CIpoptSolver  
CLinearComplementarityConstraint  Implements a constraint of the form: 
CLinearConstraint  Implements a constraint of the form lb <= Ax <= ub 
CLinearCost  Implements a cost of the form a'x + b 
CLinearEqualityConstraint  Implements a constraint of the form Ax = b 
CLinearMatrixInequalityConstraint  Impose the matrix inequality constraint on variable x \[ F_0 + x_1 F_1 + ... + x_n F_n \text{ is p.s.d} \] where p.s.d stands for positive semidefinite 
CLinearSystemSolver  
CLogarithmicSos2NewBinaryVariables  The size of the new binary variables in the compile time, for Special Ordered Set of type 2 (SOS2) constraint 
CLogarithmicSos2NewBinaryVariables< Eigen::Dynamic >  
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 
CSolverData  
CMathematicalProgramSolverInterface  Interface used by implementations of individual solvers 
CMixedIntegerBranchAndBound  Given a mixedinteger optimization problem (MIP) (or more accurately, mixed binary problem), solve this problem through branchandbound process 
CMixedIntegerBranchAndBoundNode  A node in the branchandbound (bnb) tree 
►CMixedIntegerRotationConstraintGenerator  We relax the nonconvex SO(3) constraint on rotation matrix R to mixedinteger linear constraints 
CReturnType  
CMobyLCPSolver  A class for solving Linear Complementarity Problems (LCPs) 
CMobyLcpSolverId  Nontemplate class for MobyLcpSolver<T> constants 
CMosekSolver  
CNewSymmetricVariableNames  
CNewVariableNames  
CNewVariableNames< Eigen::Dynamic >  
CNewVariableNames< Rows, Cols >  
CNewVariableNames< Size >  The type of the names for the newly added variables 
CNloptSolver  
COsqpSolver  
CPolynomialConstraint  Lb[i] <= Pi <= ub[i], where each P[i] is a multivariate polynomial in x, y.. 
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 \[\text{ S is p.s.d }\] namely, all eigen values of S are nonnegative 
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 .5 x'Qx + b'x + c 
CRotatedLorentzConeConstraint  Constraining that the linear expression \( z=Ax+b \) lies within rotated Lorentz cone 
CScsSolver  
CSnoptSolver  
CSolverId  Identifies a MathematicalProgramSolverInterface implementation 
CSolverResult  This class is used by implementations of the class MathematicalProgramSolverInterface to report their results to the mathematical program 
CSolverTypeConverter  Converts between SolverType and SolverId 
►CSystemIdentification  Utility functions for system identification 
CSystemIdentificationResult  A helper struct to hold System ID results 
CUnrevisedLemkeSolver  A class for the Unrevised Implementation of Lemke Algorithm's for solving Linear Complementarity Problems (LCPs) 
CUnrevisedLemkeSolverId  Nontemplate class for UnrevisedLemkeSolver<T> constants 
CVisualizationCallback  Defines a simple evaluator with no outputs that takes a callback function pointer 
►Nsymbolic  
►Ndetail  
CRelationalOpTraits  Provides a return type of relational operations (=, ≠, ≤, <, ≥, >) between Eigen::Array s 
CBinaryExpressionCell  Represents the base class for binary expressions 
CEnvironment  Represents a symbolic environment (mapping from a variable to a value) 
CExpression  Represents a symbolic form of an expression 
CExpressionAbs  Symbolic expression representing absolute value function 
CExpressionAcos  Symbolic expression representing arccosine function 
CExpressionAdd  Symbolic expression representing an addition which is a sum of products 
CExpressionAddFactory  Factory class to help build ExpressionAdd expressions 
CExpressionAsin  Symbolic expression representing arcsine function 
CExpressionAtan  Symbolic expression representing arctangent function 
CExpressionAtan2  Symbolic expression representing atan2 function (arctangent function with two arguments) 
CExpressionCeiling  Symbolic expression representing ceil function 
CExpressionCell  Represents an abstract class which is the base of concrete symbolicexpression classes 
CExpressionConstant  Symbolic expression representing a constant 
CExpressionCos  Symbolic expression representing cosine function 
CExpressionCosh  Symbolic expression representing hyperbolic cosine function 
CExpressionDiv  Symbolic expression representing division 
CExpressionExp  Symbolic expression representing exponentiation using the base of natural logarithms 
CExpressionFloor  Symbolic expression representing floor function 
CExpressionIfThenElse  Symbolic expression representing ifthenelse expression 
CExpressionLog  Symbolic expression representing logarithms 
CExpressionMax  Symbolic expression representing max function 
CExpressionMin  Symbolic expression representing min function 
CExpressionMul  Symbolic expression representing a multiplication of powers 
CExpressionMulFactory  Factory class to help build ExpressionMul expressions 
CExpressionNaN  Symbolic expression representing NaN (notanumber) 
CExpressionPow  Symbolic expression representing power function 
CExpressionSin  Symbolic expression representing sine function 
CExpressionSinh  Symbolic expression representing hyperbolic sine function 
CExpressionSqrt  Symbolic expression representing squareroot 
CExpressionTan  Symbolic expression representing tangent function 
CExpressionTanh  Symbolic expression representing hyperbolic tangent function 
CExpressionUninterpretedFunction  Symbolic expression representing an uninterpreted function 
CExpressionVar  Symbolic expression representing a variable 
CFormula  Represents a symbolic form of a firstorder logic formula 
CFormulaAnd  Symbolic formula representing conjunctions (f1 ∧ .. 
CFormulaCell  Represents an abstract class which is the base of concrete symbolicformula classes (i.e 
CFormulaEq  Symbolic formula representing equality (e1 = e2) 
CFormulaFalse  Symbolic formula representing false 
CFormulaForall  Symbolic formula representing universal quantifications (∀ x₁, ..., * xn 
CFormulaGeq  Symbolic formula representing 'greaterthanorequalto' (e1 ≥ e2) 
CFormulaGt  Symbolic formula representing 'greaterthan' (e1 > e2) 
CFormulaIsnan  Symbolic formula representing isnan predicate 
CFormulaLeq  Symbolic formula representing 'lessthanorequalto' (e1 ≤ e2) 
CFormulaLt  Symbolic formula representing 'lessthan' (e1 < e2) 
CFormulaNeq  Symbolic formula representing disequality (e1 ≠ e2) 
CFormulaNot  Symbolic formula representing negations (¬f) 
CFormulaOr  Symbolic formula representing disjunctions (f1 ∨ .. 
CFormulaPositiveSemidefinite  Symbolic formula representing positivesemidefinite (PSD) constraint 
CFormulaTrue  Symbolic formula representing true 
CFormulaVar  Symbolic formula representing a Boolean variable 
CGradedReverseLexOrder  Implements Graded reverse lexicographic order 
CMonomial  Represents a monomial, a product of powers of variables with nonnegative integer exponents 
CNaryFormulaCell  Represents the base class for Nary logic operators (∧ and ∨) 
CPolynomial  Represents symbolic polynomials 
CRelationalFormulaCell  Represents the base class for relational operators (==, !=, <, <=, >, >=) 
CRewritingRule  A RewritingRule , lhs => rhs , consists of two Patterns lhs and rhs 
CUnaryExpressionCell  Represents the base class for unary expressions 
CVariable  Represents a symbolic variable 
CVariables  Represents a set of variables 
►Nsystems  
►Nanalysis  
►Ntest  
CRobertsonSystem  Robertson's stiff chemical reaction problem 
CStiffDoubleMassSpringSystem  A coupled, mass spring system taken from the SD/FAST user's manual 
►Nanalysis_test  
CExplicitErrorControlledIntegratorTest  
CLogisticSystem  System with state evolution yielding a logistic function, for purposes of witness function testing using the differential equation dx/dt = α⋅(1  (x/k)^ν)⋅t, where ν > 0 (affects the shape of the curve), α > 0 (growth rate), and k is the upper asymptote 
CMySpringMassSystem  
CStatelessSystem  System with no state for testing a simplistic witness function 
►Ncontrollers  
►Nplan_eval  
CGenericPlan  This class represents a plan interpretor, which conceptually serves as a bridge between a high level planner (e.g 
CGenericPlanTest  
CManipulatorMoveEndEffectorPlan  A concrete plan that sets up a Cartesian tracking objective for the end effector assuming no contacts 
CPlanEvalBaseSystem  A base class that outputs QpInput for the qp inverse dynamics controller 
►Nqp_inverse_dynamics  
CBodyAcceleration  This class holds spatial acceleration for a rigid body 
CConstrainedValues  Base class for specifying various desired objectives 
CContactInformation  This class describes contact related information for each body in contact with other bodies in the world 
CContactParam  A struct for holding contactrelated parameters such as local offsets of the contact points, friction coefficient, etc 
CDesiredBodyMotion  A wrapper class specifying desired body motion (acceleration) for a rigid body and their corresponding weights for the QP 
CDesiredCentroidalMomentumDot  A wrapper class specifying desired centroidal momentum change and their corresponding weights for the QP 
CDesiredDofMotions  A wrapper class specifying desired DoF (degree of freedom) motions (acceleration) and their corresponding weights for the QP 
CDesiredMotionParam  Struct for storing parameters for generating a desired acceleration objective \( \dot{v}_d \) for the QP inverse dynamics controller 
CParamSet  A class for parsing and storing parameters that are used to generate QpInput for the inverse dynamics controller 
CQpInput  Input to the QP inverse dynamics controller 
CQpInverseDynamics  
CQpInverseDynamicsSystem  A discrete time system block for an inverse dynamics controller 
CQpOutput  Output of the QP inverse dynamics controller 
CQpOutputTranslatorSystem  An abstract base class that translates a QpOutput to a vector of torque commands in the actuator order within the RigidBodyTree 
CResolvedContact  This class holds contact force related information, and works closely with ContactInformation 
CRobotKinematicState  A wrapper class around KinematicsCache and several useful matrices such as the inertia matrix, etc 
CRobotKinematicStateTranslatorSystem  Provides transformation from a state vector to RobotKinematicState 
CCartesianSetpoint  This is used to compute target spatial acceleration, which is the input to the inverse dynamics controller 
►CDynamicProgrammingOptions  Consolidates the many possible options to be passed to the dynamic programming algorithms 
CPeriodicBoundaryCondition  For algorithms that rely on approximations of the statedynamics (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) 
CInverseDynamics  Solves inverse dynamics with no consideration for external wrenches, under actuation, joint torque limits or closed kinematic chains 
CInverseDynamicsController  A state feedback controller that uses a PidController to generate desired accelerations, which are then converted into torques using InverseDynamics 
CLinearModelPredictiveController  Implements a basic Model Predictive Controller that linearizes the system about an equilibrium condition and regulates to the same point by solving an optimal control problem over a finite time horizon 
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 
CVectorSetpoint  
CZMPPlanner  Given a desired two dimensional (X and Y) zeromoment point (ZMP) trajectory parameterized as a piecewise polynomial, an optimal center of mass (CoM) trajectory is planned using a linear inverted pendulum model (LIPM) 
CZMPTestTraj  A structure for storing trajectories from simulating a linear inverted pendulum model (LIPM) using the policy from a ZMPPlanner 
►Ndetail  
CModelValues  Represents models for a sequence of AbstractValues (usually a sequence of either input or output ports) 
CODESystem  A LeafSystem subclass used to describe parameterized ODE systems i.e 
►Nestimators  
CLuenbergerObserver  A simple state observer for a dynamical system of the form: \[\dot{x} = f(x,u) \] \[y = g(x,u) \] the observer dynamics takes the form \[\dot{\hat{x}} = f(\hat{x},u) + L(y  g(\hat{x},u)) \] where \(\hat{x}\) is the estimated state of the original system 
►Nimplicit_integrator_test  
CDiscontinuousSpringMassDamperSystem  
CSpringMassDamperSystem  
►Ninternal  
CRandomSource  A source block which generates random numbers at a fixed sampling interval, with a zeroorder hold between samples 
CRandomState  State for a given random distribution and generator 
►Nlcm  
CDataTypeTraits< DataType, false >  
CLcmAndVectorBaseTranslator  Defines an abstract parent class of all translators that convert between LCM message bytes and drake::systems::VectorBase objects 
CLcmDrivenLoop  This class implements a loop that's driven by a Lcm message 
CLcmLogPlaybackSystem  Advances the cursor of a drake::lcm::DrakeLcmLog based on the timestamps seen the Context that is used to simulate this System 
CLcmMessageToTimeInterface  A generic translator interface that extracts time in seconds from an abstract type 
CLcmPublisherSystem  Publishes an LCM message containing information from its input port 
CLcmSubscriberSystem  Receives LCM messages from a given channel and outputs them to a System<double>'s port 
CLcmtDrakeSignalTranslator  Specializes LcmAndVectorBaseTranslator to handle LCM messages of type drake::lcmt_drake_signal 
CLcmTranslatorDictionary  A dictionary that maps between LCM channel names and translators that convert between LCM message objects and VectorBase objects 
CSerializer  Serializer is specific to a single LcmMessage type, and translates between LCM message bytes and drake::systems::Value<LcmMessage> objects 
CSerializerInterface  SerializerInterface translates between LCM message bytes and drake::systems::AbstractValue objects that contain LCM messages, e.g., a Value<lcmt_drake_signal> 
CUtimeMessageToSeconds  A translator class for Lcm message types that have a "utime" field, which is in micro seconds 
►Nplants  
►Nrigid_body_plant  
►Ntest  
CContactResultTestCommon  
►Ntest  
CIKTrajectoryHelper  This class is a helper for backend implementations of inverse kinematics trajectory planning 
CKinematicsCacheHelper  Helper class to avoid recalculating a kinematics cache which is going to be used repeatedly by multiple other classes 
CKinematicsCacheWithVHelper  Stores and updates the kinematics cache for the rigid body tree 
CQuasiStaticConstraintWrapper  
CSingleTimeKinematicConstraintWrapper  
►Nrendering  
CFrameVelocity  A 6vector representing the derivatives of the position transform of frame A in the world frame, Xdot_WA, in the form {R_WA, p_WA} , where p is the derivatives of xyz translation, and R is the derivatives of xyz rotation 
CPoseAggregator  PoseAggregator is a multiplexer for heterogeneous sources of poses and the velocities of those poses 
CPoseBundle  PoseBundle is a container for a set of poses, represented by an Isometry3, and corresponding velocities, represented by a FrameVelocity 
CPoseBundleToDrawMessage  PoseBundleToDrawMessage converts a PoseBundle on its single abstractvalued input port to a Drake Visualizer Interface LCM draw message, lcmt_viewer_draw, on its single abstractvalued output port 
CPoseStampedTPoseVectorTranslator  The translator that converts from/to rendering::PoseVector<double> to/from lcm message bytes which encodes robotlocomotion::pose_stamped_t 
CPoseVector  A 7vector representing the transform of frame A in the world frame, X_WA, in the form {p_WA, R_WA} , where p is represented as an xyz translation, and R is represented as a quaternion 
CPoseVelocityInputPorts  A container with references to the input port for the pose input, and a reference to the input port for the velocity input 
►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<T> can be converted into an S<U> ; the default value is true for all values of S , T , and U 
CTraits< automotive::IdmController >  
CTraits< automotive::PurePursuitController >  
CTraits< automotive::TrajectoryCar >  
CTraits< drake::multibody::multibody_plant::MultibodyPlant >  
CTraits< examples::quadrotor::QuadrotorPlant >  
CTraits< examples::rimless_wheel::RimlessWheel >  
CTraits< geometry::SceneGraph >  
CTraits< PiecewisePolynomialAffineSystem >  
CTraits< PiecewisePolynomialLinearSystem >  
CTraits< RigidBodyPlant >  
►Nsensors  
►Ntest  
CRgbdRendererTest  
CScreenCoord  
CAccelerometer  A simulated ideal accelerometer that measures the linear acceleration of a frame associated with a RigidBodyPlant 
CAccelerometerExampleDiagram  Implements the Diagram shown below, which demonstrates how an accelerometer can be used 
CAccelerometerOutput  Specializes BasicVector with accessors and setters that are useful for consumers of Accelerometer's output 
CAccelerometerOutputConstants  
CBeamModel  Implements the "Beam Models of Range Finders" from section 6.3 of Probabilistic Robotics (2006), by Thrun, Burgard, and Fox 
CCameraInfo  Simple data structure for camera information that includes the image size and camera intrinsic parameters 
CColor  Holds r, g, b values to represent a color pixel 
CColorPalette  Creates and holds a palette of colors for visualizing different objects in a scene (the intent is for a different color to be applied to each identified object) 
CDepthSensor  A simple model of an ideal depth sensor 
CDepthSensorOutput  Specializes BasicVector with specific getters and setters that are useful for consumers of DepthSensor's output 
CDepthSensorSpecification  Holds a DepthSensor's specification 
CDepthSensorToLcmPointCloudMessage  A DepthSensorToLcmPointCloudMessage takes as input a DepthSensorOutput and the pose of the depth sensor in the world (X_WS ) 
CGyroscope  A simulated ideal gyroscope 
CGyroscopeOutput  Specializes BasicVector with accessors and setters that are useful for consumers of Gyroscope's output 
CGyroscopeOutputConstants  Defines the semantics of each index in GyroscopeOutput's vector 
CImage  Simple data format for Image 
CImageToLcmImageArrayT  An ImageToLcmImageArrayT takes as input an ImageRgba8U, ImageDepth32F and ImageLabel16I 
CImageTraits  Traits class for Image 
CImageTraits< PixelType::kBgr8U >  
CImageTraits< PixelType::kBgra8U >  
CImageTraits< PixelType::kDepth16U >  
CImageTraits< PixelType::kDepth32F >  
CImageTraits< PixelType::kExpr >  
CImageTraits< PixelType::kGrey8U >  
CImageTraits< PixelType::kLabel16I >  
CImageTraits< PixelType::kRgb8U >  
CImageTraits< PixelType::kRgba8U >  
CInvalidDepth  Set of constants used to represent invalid depth values 
CLabel  Set of labels used for label image 
COptitrackLcmFrameSender  The system has one abstractvalued input port and one abstractvalued output port 
CRenderingConfig  Common configurations of rendering systems 
CRgbdCamera  An RGBD camera system that provides RGB, depth and label images using visual elements of RigidBodyTree 
CRgbdCameraDiscrete  Wraps a continuous RgbdCamera with zero order holds to have it function as a discrete sensor 
CRgbdRenderer  Abstract interface of RGBD renderers, which render RGB, depth and label images using VisualElement 
CRgbdRendererOSPRay  An RgbdRenderer implementation using OSPRay via VTK 
CRgbdRendererVTK  An RgbdRenderer implementation using VTK 
CRotaryEncoders  Simple model to capture the quantization and calibration offset effects of a rotary encoder 
►Ntest  
CMatrixData  
►Ntrajectory_optimization  
CDirectCollocation  DirectCollocation implements the approach to trajectory optimization as described in C 
CDirectCollocationConstraint  Implements the direct collocation constraints for a firstorder 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 onestep of numerical integration provides the dynamic constraints between those decision variables 
CGeneralizedConstraintForceEvaluator  This evaluator computes the generalized constraint force Jᵀλ ∈ ℝ ᴺᵛ, where Nᵥ is the size of the generalized velocities 
CJointLimitConstraintForceEvaluator  Evaluates the joint limit constraint force 
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 
CPositionConstraintForceEvaluator  Evaluates the generalized constraint force from RigidBodyTree::positionConstraint 
CAbstractValue  A fully typeerased container class 
CAbstractValues  AbstractValues is a container for nonnumerical state and parameters 
CAccelerometerTestLogger  A sink block that logs the most recent plant state and the accelerometer reading 
CActuatorEffortToRigidBodyPlantInputConverter  
CAdder  An adder for arbitrarily many inputs of equal size 
CAffineLinearSystemTest  
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 
CSpecifiedValues  The set of values that, along with the function being integrated, partially specify the definite integral i.e 
CBarycentricMeshSystem  A (stateless) vector system implemented as a multilinear (barycentric) interpolation on a mesh over the inputs 
CBasicVector  BasicVector is a semanticsfree wrapper around an Eigen vector that satisfies VectorBase 
CCache  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  This is the representation in the Context for the value of one of a System's CacheEntry objects 
CCompliantContactModel  This class encapsulates the compliant contact model force computations as described in detail in Compliant Contact in Drake 
CCompliantContactModelParameters  The set of parameters for the compliant contact model 
CCompliantMaterial  The set of perobject compliant material parameters with one material applied to each collision object 
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 
CContactDetail  The base class for defining a contact detail 
CContactForce  The data for a single contact force applied to one body of a contacting pair 
CContactInfo  A class containing information regarding contact response between two bodies including: 
CContactResultantForceCalculator  This is a utility class for replacing a set of force/torques by an equivalent force/torque (defined by the ContactForce class) 
CContactResults  A class containing the contact results (contact points and response spatial forces for each colliding pair of collision elements) as well as the sum of all JᵀF for all contact, where J is the contact point Jacobian, and F is the contact force 
CContactResultsToLcmSystem  A System that encodes ContactResults into a lcmt_contact_results_for_viz message 
CContext  Context is an abstract class template that represents all the typed values that are used in a System's computations: time, numericvalued input ports, numerical state, and numerical parameters 
CContextBase  Provides nontemplatized 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  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 
CDiscreteUpdateEvent  This class represents a discrete update event 
CDiscreteValues  DiscreteValues is a container for numerical but noncontinuous state and parameters 
CDrakeVisualizer  This is a Drake System block that takes a RigidBodyTree and publishes LCM messages that are intended for drakevisualizer 
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) 
CEventData  Base class for storing triggerspecific data to be passed to event handlers 
CExplicitEulerIntegrator  A firstorder, explicit Euler integrator 
CFirstOrderLowPassFilter  An elementwise first order low pass filter system that filters the ith input uᵢ into the ith 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 
CFrameVisualizer  This is a Drake System block that takes in a state vector, and outputs a drake::lcmt_viewer_draw message that contains information about the frames for visualization 
CGain  An elementwise 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 firstorder, fully implicit integrator with second order error estimation 
►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₀; 𝐤) = 𝐱₀ 
CSpecifiedValues  A collection of values i.e 
CInputPort  This extends InputPortBase with some scalar typedependent methods 
CInputPortBase  An InputPort is a System resource that describes the kind of input a System accepts, on a given port 
CIntegrator  An integrator for a continuous vector input 
CIntegratorBase  An abstract class for an integrator for ODEs and DAEs as represented by a Drake System 
CKinematicsResults  A class containing the kinematics results from a RigidBodyPlant system 
CLcmDecoderSystem  A decoding system that converts a Lcm message of MsgTypedata to data of DataType 
CLcmEncoderSystem  An encoding system that converts data of DataType to a Lcm message of MsgType 
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  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 
CLinearTimeVaryingData  Stores matrix data necessary to construct a linear time varying system as a piecewise polynomial trajectory 
CMatrixGain  A system that specializes LinearSystem by setting coefficient matrices A , B , and C to all be zero 
CMultiplexer  This system combines multiple vectorvalued inputs into a vectorvalued output 
CMyVector  A simple subclass of BasicVector<T> for testing, particularly for cases where BasicVector subtyping must be preserved through the framework 
COutputPort  An OutputPort belongs to a System and represents the properties of one of that System's output ports 
COutputPortBase  OutputPortBase handles the scalar typeindependent 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  A token describing an event that recurs on a fixed period 
CPeriodicEventDataComparator  Structure for comparing two PeriodicEventData objects for use in a map container, using an arbitrary comparison method 
CPidControlledSpringMassSystem  A model of a onedimensional springmass system controlled to achieve a given target position using a PID controller 
CPiecewisePolynomialAffineSystem  A continuous or discretetime Affine TimeVarying system described by a piecewise polynomial trajectory of system matrices 
CPiecewisePolynomialLinearSystem  A continuous or discretetime Linear TimeVarying system described by a piecewise polynomial trajectory of system matrices 
CPointContactDetail  An implementation of the ContactDetail where the contact details consist of a single ContactForce 
CPublishEvent  This class represents a publish event 
CRigidBodyPlant  This class provides a System interface around a multibody dynamics model of the world represented by a RigidBodyTree 
CRigidBodyPlantBridge  This class provides backwards compatibility between the old RigidBodyPlant and the new SceneGraph 
CRobotCommandToDesiredEffortConverter  Converts an atlas_command_t message into desired efforts, presented on one output port per actuator 
CRobotStateDecoder  Converts a robot_state_t LCM message into a KinematicsCache object 
CRobotStateEncoder  Assembles information from various input ports into a robot_state_t LCM message, presented on an output port 
CRungeKutta2Integrator  A secondorder, explicit Runge Kutta integrator 
CRungeKutta3Integrator  A thirdorder Runge Kutta integrator with a third order error estimate 
CSaturation  An elementwise 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 
CSpecifiedValues  A collection of values i.e 
CScalarViewDenseOutput  A ScalarDenseOutput class implementation that wraps a DenseOutput class instance and behaves as a view to one of its elements 
CSemiExplicitEulerIntegrator  A firstorder, semiexplicit Euler integrator 
CSignalLog  This class serves as an inmemory cache of timedependent vector values 
CSignalLogger  A sink block which logs its input to memory 
CSimulator  A forward dynamics solver for hybrid dynamic systems represented by System<T> objects 
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 
CSpringMassStateVector  The state of a onedimensional springmass system, consisting of the position and velocity of the mass, in meters and meters/s 
CSpringMassSystem  A model of a onedimensional springmass system 
CState  State is a container for all the data comprising the complete state of a particular System at a particular moment 
CStepInfo  Contains information about the independent variable including time and step number 
CStepwiseDenseOutput  A DenseOutput class interface extension, geared towards stepwise 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 
CSystem  Base class for all System functionality that is dependent on the templatized scalar type T for input, state, parameters, and outputs 
CSystemBase  Provides nontemplatized functionality shared by the templatized System classes 
CSystemConstraint  A SystemConstraint is a generic baseclass for constraints on Systems 
CSystemOutput  Conveniently stores a snapshot of the values of every output port of a System 
CSystemScalarConverter  Helper class to convert a System<U> 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 inputtooutput sparsity, along with many others 
CSystemTypeTag  A tag object that denotes a System subclass S in function signatures 
CTimeVaryingAffineSystem  Base class for a discrete or continuoustime, timevarying affine system, with potentially timevarying coefficients 
CTimeVaryingData  Stores matrix data necessary to construct an affine time varying system as a piecewise polynomial trajectory 
CTimeVaryingLinearSystem  Base class for a discrete or continuous linear timevarying (LTV) system 
CTrajectorySource  A source block that generates the value of a Trajectory for a given time 
CUnrestrictedUpdateEvent  This class represents an unrestricted update event 
CValkyriePDAndFeedForwardController  
CValue  A container class for an arbitrary type T 
CVectorBase  VectorBase is an abstract base class that realvalued signals between Systems and realvalued System state vectors must implement 
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 
CViewerDrawTranslator  Specializes LcmAndVectorBaseTranslator to handle LCM messages of type drake::lcmt_viewer_draw 
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  Class for storing data from a witness function triggering to be passed to event handlers 
CWrapToSystem  An elementwise wrapping block that transforms the specified indices of the input signal u into the interval [low, high) 
CZeroOrderHold  A ZeroOrderHold block with input u , which may be vectorvalued (discrete or continuous) or abstract, and discrete output y , where the y is sampled from u with a fixed period 
►Ntest  
CAutoDiffXdTest  
►Ntools  
►Ntest  
CSample  Specializes BasicVector with specific getters and setters 
CSampleIndices  Describes the row indices of a Sample 
CSampleTranslator  Translates between LCM message objects and VectorBase objects for the Sample type 
►Ntrajectories  
CExponentialPlusPiecewisePolynomial  Y(t) = K * exp(A * (t  t_j)) * alpha.col(j) + piecewise_polynomial_part(t) 
CPiecewisePolynomial  A scalar multivariate piecewise polynomial 
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" 
CTrajectory  A Trajectory represents a timevarying matrix, indexed by a single scalar double time 
CBool  Class representing a Boolean value independent of the underlying scalar type T: 
Ccopyable_unique_ptr  A smart pointer with deep copy semantics 
CDelegatingHasher  An adapter that forwards the HashAlgorithm::operator(data, length) function concept into a runtimeprovided 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 purposefullycomputed value, useful for initializing a value before the true result is available 
Cdummy_value< Eigen::AutoDiffScalar< DerType > >  Specializes common/dummy_value.h 
Cdummy_value< int >  
Cdummy_value< symbolic::Expression >  Specializes common/dummy_value.h 
CEigenPtr  This wrapper class provides a way to write nontemplate functions taking raw pointers to Eigen objects as parameters while limiting the number of copies, similar to Eigen::Ref 
CEigenSizeMinPreferDynamic  EigenSizeMinPreferDynamic<a, b>::value gives the min between compiletime sizes a and b 
CEigenSizeMinPreferFixed  EigenSizeMinPreferFixed is a variant of EigenSizeMinPreferDynamic 
CFindResourceResult  Models the outcome of drake::FindResource 
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  
Cis_numeric  Is_numeric is true for types that are on the real line 
Cis_numeric< symbolic::Expression >  Specializes is_numeric to be false for symbolic::Expression type 
CMultiplyEigenSizes  MultiplyEigenSizes<a, b> gives a * b if both of a and b are fixed sizes 
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, platformindependent, humanreadable names for arbitrarilycomplicated C++ types 
Creset_after_move  Type wrapper that performs valueinitialization on the wrapped type, and guarantees that when moving from this type that the donor object is reset to its valueinitialized value 
Creset_on_copy  Type wrapper that performs valueinitialization on copy construction or assignment 
CSortedPair  This class is similar to the std::pair class 
Ctemplate_single_tag  Provides a tag for singleparameter templates 
Ctype_at  Extracts the Ith type from a sequence of types 
Ctype_check_different_from  Provides a check which returns whether T is different than U 
Ctype_pack  Provides a tag to pass a parameter packs for ease of inference 
Ctype_tag  Provides a tag to pass a type for ease of inference 
Ctype_visit_with_default  Visit a type by constructing its default value 
Ctype_visit_with_tag  Visits a type by construct a template tag's default value 
CTypeSafeIndex  A typesafe nonnegative index class 
Cuhash  A hashing functor, somewhat like std::hash 
►NDrakeShapes  
CBox  
CCapsule  
CCylinder  
CElement  
CGeometry  
CMesh  
CMeshPoints  
CSphere  
CVisualElement  
►Ninternal  
►Nmanipulation  
►Nplanner  
►NMotionGenesis  
►NMGChaoticBabyboot_  
CMGChaoticBabyboot  
CMGIntegrator  
CMGKukaIIwaRobotAutoGenerated  
►Npybind11  
►Ndetail  
Ctype_caster< Eigen::Translation< T, Dim > >  
►Nstd  STL namespace 
Cequal_to< drake::symbolic::Expression >  
Cequal_to< drake::symbolic::Formula >  
Cequal_to< drake::symbolic::Variable >  
Chash< drake::geometry::Identifier< Tag > >  Enables use of the identifier to serve as a key in STL containers 
Chash< drake::maliput::api::TypeSpecificIdentifier< T > >  Specialization of std::hash for TypeSpecificIdentifier<T> 
Chash< drake::SortedPair< T > >  Provides std::hash<SortedPair<T>> 
Chash< drake::symbolic::Expression >  
Chash< drake::symbolic::Formula >  
Chash< drake::symbolic::Monomial >  
Chash< drake::symbolic::Polynomial >  
Chash< drake::symbolic::Variable >  
Chash< drake::symbolic::Variables >  
Chash< drake::systems::sensors::Color< T > >  
Chash< drake::TypeSafeIndex< Tag > >  Specialization of std::hash for drake::TypeSafeIndex<Tag> 
Cless< drake::maliput::api::TypeSpecificIdentifier< T > >  Specialization of std::less for TypeSpecificIdentifier<T> providing a strict weak ordering over TypeSpecificIdentifier<T> suitable for use with ordered containers 
Cless< drake::solvers::SolverId >  
Cless< drake::symbolic::Expression >  
Cless< drake::symbolic::Formula >  
Cless< drake::symbolic::Variable >  
Cnumeric_limits< Eigen::AutoDiffScalar< T > >  
CAllBodiesClosestDistanceConstraint  
CAttachment  
CBodyMotionData  
CBodyMotionParams  
CBounds  
CbtOverlapFilterCallback  
CDesiredBodyAcceleration  
CDHomogTrans  
CDrakeJoint  A joint defines a spatial relationship between two rigid bodies 
CDrakeRobotState  
CEulerConstraint  
CFixedAxisOneDoFJoint  
CFixedJoint  
CForceTorqueMeasurement  
CGazeConstraint  
CGazeDirConstraint  
CGazeOrientConstraint  
CGazeTargetConstraint  
CGravityCompensationTorqueConstraint  
CHardwareGains  
CHardwareParams  
CHelicalJoint  
CIKoptions  
CIKResults  Return type for simplified versions of IK functions 
CInstantaneousQPController  
CIntegratorParams  
CJointNames  
CJointSoftLimitParams  
CKinematicModifications  
CKinematicPath  
►CKinematicsCache  
CDataInCalcFrameSpatialVelocityJacobianInWorldFrame  Preallocated variables used in CalcFrameSpatialVelocityJacobianInWorldFrame 
CDataInGeometricJacobian  Preallocated scratch pad variables 
CKinematicsCacheElement  
CKneeSettings  
CMatcherInterface  
CMinDistanceConstraint  
CMultipleTimeKinematicConstraint  
CMultipleTimeLinearPostureConstraint  
CPIDOutput  
CPoint  
CPoint2LineSegDistConstraint  
CPoint2PointDistanceConstraint  
►CPolynomial  A scalar multivariate polynomial, modeled after the msspoly in spotless 
CMonomial  An additive atom of a Polynomial: The product of any number of Terms and a coefficient 
CProduct  
CTerm  An individual variable raised to an integer power; e.g. x**2 
CPositionConstraint  
CPositionIndices  
CPostureChangeConstraint  
CPostureConstraint  
CPrismaticJoint  A prismatic joint moves linearly along one axis 
CQPControllerDebugData  
CQPControllerOutput  
CQPControllerParams  
CQPControllerState  
CQPLocomotionPlan  
CQPLocomotionPlanSettings  
CQuadraticLyapunovFunction  
CQuasiStaticConstraint  Center of Mass (CoM) is within the support polygon 
CQuatConstraint  
CQuaternionBallJoint  Defines a 3 dof tree joint (mobilizer) that uses a unit quaternion as the generalized orientation coordinates 
CQuaternionFloatingJoint  Defines a 6 dof tree joint (mobilizer) that uses a unit quaternion as the generalized orientation coordinates 
CRelativeGazeDirConstraint  
CRelativeGazeTargetConstraint  
CRelativePositionConstraint  
CRelativeQuatConstraint  
CRevoluteJoint  
CRigidBody  
CRigidBodyActuator  Defines a physical actuator (i.e., an electric motor and stepdown transmission) that operates on a joint 
CRigidBodyConstraint  Base class 
CRigidBodyDistanceConstraint  Defines a "relative distance constraint" that models a constraint between points on two different rigid bodies 
CRigidBodyFrame  Multibody systems typically have distinguished frames of interest that need to be monitored 
CRigidBodyLoop  Defines a "loop joint" that models a kinematic loop formed by a chain of rigid bodies and their regular joints 
CRigidBodySupportStateElement  
CRigidBodyTree  Maintains a vector of RigidBody objects that are arranged into a kinematic tree via DrakeJoint objects 
CRigidBodyTreeAliasGroups  This class provides a way to create aliases to groups of RigidBody or DrakeJoint objects 
CRigidBodyTreeConstants  Defines RigidBodyTree constants 
CRobotJointIndexMap  
CRobotPropertyCache  
CRollPitchYawFloatingJoint  
CSide  
CSingleTimeKinematicConstraint  
CSingleTimeLinearPostureConstraint  
CSupportStateElement  
►CTrigPoly  A scalar multivariate polynomial containing sines and cosines 
CProduct  
CSinCosVars  
CTVLQRData  
CVRefIntegratorParams  
CWholeBodyParams  
CWorldCoMConstraint  
CWorldEulerConstraint  
CWorldFixedBodyPoseConstraint  
CWorldFixedOrientConstraint  
CWorldFixedPositionConstraint  
CWorldGazeDirConstraint  
CWorldGazeOrientConstraint  
CWorldGazeTargetConstraint  
CWorldPositionConstraint  
CWorldPositionInFrameConstraint  Constrains the points Q on a body to be within a bounding box specified in a fixed frame F 
CWorldQuatConstraint 