Primitives

Detailed Description

General-purpose Systems such as Gain, Multiplexer, Integrator, and LinearSystem.

Classes
class	Adder< T >
	An adder for arbitrarily many inputs of equal size. More...
class	TimeVaryingAffineSystem< T >
	Base class for a discrete- or continuous-time, time-varying affine system, with potentially time-varying coefficients. More...
class	AffineSystem< T >
	A discrete OR continuous affine system (with constant coefficients). More...
class	ConstantValueSource< T >
	A source block that always outputs a constant value. More...
class	ConstantVectorSource< T >
	A source block with a constant output port at all times. More...
class	Demultiplexer< T >
	This system splits a vector valued signal on its input into multiple outputs. More...
class	DiscreteDerivative< T >
	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. More...
class	StateInterpolatorWithDiscreteDerivative< T >
	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. More...
class	DiscreteTimeDelay< T >
	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. More...
class	DiscreteTimeIntegrator< T >
	A discrete-time integrator for a vector input, using explicit Euler integration. More...
class	FirstOrderLowPassFilter< T >
	An element-wise first order low pass filter system that filters the i-th input uᵢ into the i-th output zᵢ. More...
class	Gain< T >
	An element-wise gain block with input u and output y = k * u with k a constant vector. More...
class	Integrator< T >
	A continuous-time integrator for a vector input. More...
class	LinearSystem< T >
	A discrete OR continuous linear system. More...
class	TimeVaryingLinearSystem< T >
	Base class for a discrete or continuous linear time-varying (LTV) system. More...
class	LinearTransformDensity< T >
	Performs linear transformation on the random signal w_in as w_out = A*w_in + b. More...
class	MatrixGain< T >
	A system that specializes LinearSystem by setting coefficient matrices A, B, and C to all be zero. More...
class	MultilayerPerceptron< T >
	The MultilayerPerceptron (MLP) is one of the most common forms of neural networks used in reinforcement learning (RL) today. More...
class	Multiplexer< T >
	This system combines multiple vector-valued inputs into a vector-valued output. More...
class	PassThrough< T >
	A pass through system with input u and output y = u. More...
class	PortSwitch< T >
	A simple system that passes through the value from just one of its input ports to the output. More...
class	RandomSource< T >
	A source block which generates random numbers at a fixed sampling interval, with a zero-order hold between samples. More...
class	Saturation< T >
	An element-wise hard saturation block with inputs signal u, saturation values \( u_{min} \) and/or \( u_{max} \), and output y respectively as in: More...
class	Sine< T >
	A sine system which outputs y = a * sin(f * t + p) and first and second derivatives w.r.t. More...
class	TrajectoryAffineSystem< T >
	A continuous- or discrete-time Affine Time-Varying system with system matrices described by trajectories. More...
class	TrajectoryLinearSystem< T >
	A continuous- or discrete-time Linear Time-Varying system with system matrices described by trajectories. More...
class	TrajectorySource< T >
	Given a Trajectory, this System provides an output port with the value of the trajectory evaluated at the current time. More...
class	VectorLogSink< T >
	A discrete sink block which logs its vector-valued input to per-context memory. More...
class	WrapToSystem< T >
	An element-wise wrapping block that transforms the specified indices of the input signal u into the interval [low, high). More...
class	ZeroOrderHold< T >
	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). More...

Functions
std::unique_ptr< LinearSystem< double > >	Linearize (const System< double > &system, const Context< double > &context, std::variant< InputPortSelection, InputPortIndex > input_port_index=InputPortSelection::kUseFirstInputIfItExists, std::variant< OutputPortSelection, OutputPortIndex > output_port_index=OutputPortSelection::kUseFirstOutputIfItExists, double equilibrium_check_tolerance=1e-6)
	Takes the first-order Taylor expansion of a System around a nominal operating point (defined by the Context). More...
std::unique_ptr< AffineSystem< double > >	FirstOrderTaylorApproximation (const System< double > &system, const Context< double > &context, std::variant< InputPortSelection, InputPortIndex > input_port_index=InputPortSelection::kUseFirstInputIfItExists, std::variant< OutputPortSelection, OutputPortIndex > output_port_index=OutputPortSelection::kUseFirstOutputIfItExists)
	A first-order Taylor series approximation to a system in the neighborhood of an arbitrary point. More...

Function Documentation

FirstOrderTaylorApproximation()

std::unique_ptr<AffineSystem<double> > drake::systems::FirstOrderTaylorApproximation	(	const System< double > &	system,
		const Context< double > &	context,
		std::variant< InputPortSelection, InputPortIndex >	input_port_index = InputPortSelection::kUseFirstInputIfItExists,
		std::variant< OutputPortSelection, OutputPortIndex >	output_port_index = OutputPortSelection::kUseFirstOutputIfItExists
	)

A first-order Taylor series approximation to a system in the neighborhood of an arbitrary point.

When Taylor-expanding a system at a non-equilibrium point, it may be represented either of the form:

\[ \dot{x} - \dot{x}_0 = A (x - x_0) + B (u - u_0), \]

for continuous time, or

\[ x[n+1] - x_0[n+1] = A (x[n] - x_0[n]) + B (u[n] - u_0[n]), \]

for discrete time. As above, we denote \( x_0, u_0 \) to be the nominal state and input at the provided context. The system description is affine when the terms \( \dot{x}_0 - A x_0 - B u_0 \) and \( x_0[n+1] - A x_0[n] - B u_0[n] \) are nonzero.

More precisely, let x be a state and u be an input. This function returns an AffineSystem of the form:

\[ \dot{x} = A x + B u + f_0, \]

(CT)

\[ x[n+1] = A x[n] + B u[n] + f_0, \]

(DT) where \( f_0 = \dot{x}_0 - A x_0 - B u_0 \) (CT) and \( f_0 = x_0[n+1] - A x[n] - B u[n] \) (DT).

This method currently supports approximating around at most a single vector input port and at most a single vector output port. For systems with more ports, use input_port_index and output_port_index to select the input for the newly constructed system. Any additional input ports will be treated as constants (fixed at the value specified in context).

Parameters

system	The system or subsystem to linearize.
context	Defines the nominal operating point about which the system should be linearized.
input_port_index	A valid input port index for system or InputPortSelection. Default: kUseFirstInputIfItExists.
output_port_index	A valid output port index for system or OutputPortSelection. Default: kUseFirstOutputIfItExists.

Returns

An AffineSystem at this linearization point.

Exceptions

if	any abstract inputs are connected, if any vector-valued inputs are unconnected, if the system is not (only) continuous or not (only) discrete time with a single periodic update.

Note

x, u and y are in the same coordinate system as the original system, since the terms involving \( x_0, u_0 \) reside in \( f_0 \).

This method does not (yet) set the initial conditions (default nor random) of the AffineSystem based on system.

Linearize()

std::unique_ptr<LinearSystem<double> > drake::systems::Linearize	(	const System< double > &	system,
		const Context< double > &	context,
		std::variant< InputPortSelection, InputPortIndex >	input_port_index = InputPortSelection::kUseFirstInputIfItExists,
		std::variant< OutputPortSelection, OutputPortIndex >	output_port_index = OutputPortSelection::kUseFirstOutputIfItExists,
		double	equilibrium_check_tolerance = 1e-6
	)

Takes the first-order Taylor expansion of a System around a nominal operating point (defined by the Context).

This method currently supports linearizing around at most a single vector input port and at most a single vector output port. For systems with more ports, use input_port_index and output_port_index to select the input for the newly constructed system. Any additional vector input ports will be treated as constants (fixed at the value specified in context). Abstract-valued input ports must be unconnected (i.e., the system must treat the port as optional and it must be unused).

Parameters

system	The system or subsystem to linearize.
context	Defines the nominal operating point about which the system should be linearized. See note below.
input_port_index	A valid input port index for system or InputPortSelection. All other inputs are assumed to be fixed to the value described by the context. Default: kUseFirstInputIfItExists.
output_port_index	A valid output port index for system or an OutputPortSelection. Default: kUseFirstOutputIfItExists.
equilibrium_check_tolerance	Specifies the tolerance on ensuring that the derivative vector isZero at the nominal operating point. Default: 1e-6.

Returns

A LinearSystem that approximates the original system in the vicinity of the operating point. See note below.

Exceptions

std::exception	if the operating point is not an equilibrium point of the system (within the specified tolerance)
std::exception	if the system is not (only) continuous or (only) discrete time with a single periodic update.

Note

All vector inputs in the system must be connected, either to the output of some upstream System within a Diagram (e.g., if system is a reference to a subsystem in a Diagram), or to a constant value using, e.g. port.FixValue(context, default_input). Any abstract inputs in the system must be unconnected (the port must be both optional and unused).

The inputs, states, and outputs of the returned system are NOT the same as the original system. Denote x0,u0 as the nominal state and input defined by the Context, and y0 as the value of the output at (x0,u0), then the created systems inputs are (u-u0), states are (x-x0), and outputs are (y-y0).

This method does not (yet) set the initial conditions (default nor random) of the LinearSystem based on system.