Drake

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  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 >
 An integrator for a continuous 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  MatrixGain< T >
 A system that specializes LinearSystem by setting coefficient matrices A, B, and C to all be zero. 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  PiecewisePolynomialAffineSystem< T >
 A continuous- or discrete-time Affine Time-Varying system described by a piecewise polynomial trajectory of system matrices. More...
 
class  PiecewisePolynomialLinearSystem< T >
 A continuous- or discrete-time Linear Time-Varying system described by a piecewise polynomial trajectory of system matrices. More...
 
class  RandomSource< Distribution, Generator >
 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  SignalLogger< T >
 A sink block which logs its input to memory. 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  TrajectorySource< T >
 A source block that generates the value of a Trajectory for a given time. 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 ZeroOrderHold 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. More...
 

Typedefs

typedef internal::RandomSource< std::uniform_real_distribution< double > > UniformRandomSource
 Generates uniformly distributed random numbers in the interval [0,1]. More...
 
typedef internal::RandomSource< std::normal_distribution< double > > GaussianRandomSource
 Generates normally distributed random numbers with mean zero and unit covariance. More...
 
typedef internal::RandomSource< std::exponential_distribution< double > > ExponentialRandomSource
 Generates exponentially distributed random numbers with mean, standard deviation, and scale parameter (aka 1/λ) set to one. More...
 

Functions

std::unique_ptr< LinearSystem< double > > Linearize (const System< double > &system, const Context< double > &context, int input_port_index=kUseFirstInputIfItExists, int output_port_index=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, int input_port_index=kUseFirstInputIfItExists, int output_port_index=kUseFirstOutputIfItExists)
 A first-order Taylor series approximation to a system in the neighborhood of an arbitrary point. More...
 

Detailed Description

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

Typedef Documentation

◆ ExponentialRandomSource

typedef internal::RandomSource<std::exponential_distribution<double> > ExponentialRandomSource

Generates exponentially distributed random numbers with mean, standard deviation, and scale parameter (aka 1/λ) set to one.

See also
internal::RandomSource

◆ GaussianRandomSource

typedef internal::RandomSource<std::normal_distribution<double> > GaussianRandomSource

Generates normally distributed random numbers with mean zero and unit covariance.

See also
internal::RandomSource

◆ UniformRandomSource

typedef internal::RandomSource<std::uniform_real_distribution<double> > UniformRandomSource

Generates uniformly distributed random numbers in the interval [0,1].

See also
internal::RandomSource

Function Documentation

◆ FirstOrderTaylorApproximation()

std::unique_ptr< AffineSystem< double > > FirstOrderTaylorApproximation ( const System< double > &  system,
const Context< double > &  context,
int  input_port_index = kUseFirstInputIfItExists,
int  output_port_index = 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
systemThe system or subsystem to linearize.
contextDefines the nominal operating point about which the system should be linearized.
input_port_indexA valid input port index for system or kNoInput or (default) kUseFirstInputIfItExists.
output_port_indexA valid output port index for system or kNoOutput or (default) kUseFirstOutputIfItExists.
Returns
An AffineSystem at this linearization point.
Exceptions
std::runtime_errorif the system if the system is not (only) continuous or (only) discrete time with a single periodic update.

Note that 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 \).

◆ Linearize()

std::unique_ptr< LinearSystem< double > > Linearize ( const System< double > &  system,
const Context< double > &  context,
int  input_port_index = kUseFirstInputIfItExists,
int  output_port_index = 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 input ports will be treated as constants (fixed at the value specified in context).

Parameters
systemThe system or subsystem to linearize.
contextDefines the nominal operating point about which the system should be linearized. See note below.
input_port_indexA valid input port index for system or kNoInput or (default) kUseFirstInputIfItExists.
output_port_indexA valid output port index for system or kNoOutput or (default) kUseFirstOutputIfItExists.
equilibrium_check_toleranceSpecifies 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::runtime_errorif the system the operating point is not an equilibrium point of the system (within the specified tolerance)
std::runtime_errorif the system if the system is not (only) continuous or (only) discrete time with a single periodic update.
Note
All inputs in the Context 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. context->FixInputPort(0,default_input);
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).