| AbstractValue | Abstract base class representing an arbitrary value of self-describing type |
| AnalyticBrick | This is a rectangular solid |
| AnalyticCircle | An analytic circle has only a radius |
| AnalyticCurve | |
| AnalyticCylinder | The coordinate frame of the central cross section is the same as for a circle; that is, x and z are radial and y points along the cylinder's axis |
| AnalyticGeometry | This abstract class represents a piece of high-quality geometry that can be used for valid physical simulation |
| AnalyticLine | An analytic line has only a length |
| AnalyticSphere | |
| AnalyticSurface | |
| AnalyticVolume | |
| APIArgcheckFailed | |
| Array | Container class like std::vector<T> but with hidden implementation |
| ArrayBase | |
| ArrayHelper | Non-templatized helper class for ArrayBase<T> |
| ArrayView | This class is a duplicate of Array and can be cast to an Array with no harm |
| Assert | |
| Base | |
| CacheEntry | |
| Cant | |
| CNT | Specialized information about Composite Numerical Types which allows us to define appropriate templatized classes using them |
| CNT::Result | |
| CNT::Substitute | |
| CNT< complex< R > > | Specializations of CNT for numeric types |
| CNT< conjugate< R > > | |
| CNT< double > | |
| CNT< float > | |
| CNT< long double > | |
| Concretize | Wrap a pointer to an abstract base class in a way that makes it behave like a concrete class (sometimes called a "ClonePtr") |
| conjugate | SimTK::conjugate<R> should be instantiated only for float, double, long double |
| conjugate< double > | |
| conjugate< float > | |
| conjugate< long double > | |
| CoordinateAxis | |
| CoordinateAxis::XCoordinateAxis | |
| CoordinateAxis::XTypeAxis | |
| CoordinateAxis::YCoordinateAxis | |
| CoordinateAxis::YTypeAxis | |
| CoordinateAxis::ZCoordinateAxis | |
| CoordinateAxis::ZTypeAxis | |
| DecorativeBrick | This defines a rectangular solid centered at the origin and aligned with the local frame axes |
| DecorativeCircle | This defines a circle in the x-y plane, centered at the origin |
| DecorativeCylinder | This defines a cylinder centered on the origin and aligned in the y direction |
| DecorativeEllipsoid | This defines an ellipsoidal solid centered at the origin and aligned with the local frame axes |
| DecorativeFrame | This defines geometry to represent a coordinate frame |
| DecorativeGeometry | This is an abstract handle class using the PIMPL design pattern to hide the private implementation |
| DecorativeGeometryImplementation | Use this abstract class to connect your implementation of decorative geometry to the implementation-independent classes above |
| DecorativeLine | A line between two points |
| DecorativeSphere | This defines a sphere centered at the origin |
| DecorativeText | This defines a text label with its base at the origin |
| DefaultSystemSubsystem | This is a concrete Subsystem that is part of every System |
| Enumeration | This class defines an enumerated type |
| Enumeration::iterator | This class provides an interface for iterating over the set of all possible enumerated values |
| EnumerationSet | This class provides an efficient implementation of a set for storing values of an enumerated type defined with Enumeration |
| EnumerationSet::EnumerationSetRep | This class is the internal implementation of EnumerationSet |
| EnumerationSet::iterator | This class provides an interface for iterating over the content of an EnumerationSet |
| EventHandler | An EventHandler is an object that defines an event that can occur within a system |
| EventReporter | An EventReporter is an object that defines an event that can occur within a system |
| EventStatus | |
| IncompatibleValues | |
| IndexOutOfRange | |
| Inertia | The physical meaning of an inertia is the distribution of a rigid body's mass about a *particular* point |
| InverseRotation | ----------------------------------------------------------------------------- This InverseRotation class is the inverse of a Rotation See the Rotation class for information |
| InverseTransform | Transform from frame B to frame F, but with the internal representation inverted |
| Lapack | |
| List | Container class with hidden implementation |
| ListBase | |
| ListBase< T * > | |
| ListView | ListView is a 'dummy' class which is completely interchangeable with List |
| MassProperties | This class contains the mass, center of mass, and inertia of a rigid body B |
| Mat | CS is total spacing between columns in memory (default M) RS is total spacing between rows in memory (default 1) |
| Mat::EltResult | |
| Mat::Result | |
| Mat::SubMat | |
| Mat::Substitute | |
| Matrix_ | This is the class intended to appear in user code |
| MatrixBase | Variable-size 2d matrix of Composite Numerical Type (ELT) elements |
| MatrixBase::EltResult | |
| MatrixCondition | |
| MatrixConditions | |
| MatrixHelper | |
| MatrixHelper::DeepCopy | |
| MatrixHelper::DiagonalView | |
| MatrixHelper::ShallowCopy | |
| MatrixHelper::TransposeView | |
| MatrixShape | |
| MatrixShapes | |
| MatrixSize | |
| MatrixSparseFormats | |
| MatrixSparsity | |
| MatrixStorage | |
| MatrixStorageFormats | |
| MatrixStructure | |
| MatrixStructures | Class of enums used to communicate various attributes of matrices that affect which alogrithms are used for factoring, solving etc |
| MatrixView_ | This class is identical to a Matrix_; it is used only to manage the C++ rules for when copy constructors are called by introducing a separate type to prevent certain allowed optimizations from occuring when we don't want them |
| negator | Negator<N>, where N is a number type (real, complex, conjugate), is represented in memory identically to N, but behaves as though multiplied by -1, though at zero cost |
| negator::Result | |
| negator::Substitute | |
| NTraits | |
| NTraits< complex< R > > | Partial specialization for complex numbers -- underlying real R is still a template parameter |
| NTraits< complex< R > >::Result | |
| NTraits< complex< R > >::Substitute | |
| NTraits< conjugate< R > > | |
| NTraits< conjugate< R > >::Result | |
| NTraits< conjugate< R > >::Substitute | |
| OperationNotAllowedOnNonconstReadOnlyView | |
| OperationNotAllowedOnOwner | |
| OperationNotAllowedOnView | |
| PeriodicEventHandler | PeriodicEventHandler is a subclass of ScheduledEventHandler which generates a series of uniformly spaced events at regular intervals |
| PeriodicEventReporter | PeriodicEventReporter is a subclass of ScheduledEventReporter which generates a series of uniformly spaced events at regular intervals |
| PhiMatrix | |
| PhiMatrixTranspose | |
| PIMPLDerivedHandle | This class is the parent of derived handle classes |
| PIMPLHandle | This class provides some infrastructure useful in making SimTK Private Implementation (PIMPL) classes |
| PIMPLImplementation | This class provides some infrastructure useful in creating PIMPL Implementation classes (the ones referred to by Handles) |
| PolynomialRootFinder | This class provides static methods for finding the roots of polynomials |
| PolynomialRootFinder::ZeroLeadingCoefficient | This is an exception which is thrown by all of the PolynomialRootFinder::findRoots() methods |
| Quaternion | A Quaternion is a Vec4 with the following behavior:
- its length is always 1 (or else it is all NaN)
- it is equivalent to an angle/axis rotation for angle a, axis unit vector v, as: q = [ cos(a/2) sin(a/2)*v ] A quaternion is in "canonical form" when its first element is nonnegative
|
| Random | This class defines the interface for pseudo-random number generators |
| Random::Gaussian | This is a subclass of Random that generates numbers according to a Gaussian distribution with a specified mean and standard deviation |
| Random::Uniform | This is a subclass of Random that generates numbers uniformly distributed within a specified range |
| RealizeCheckFailed | |
| RealizeTopologyMustBeCalledFirst | |
| Rotation | Mat33 that guarantees that the matrix is a legitimate 3x3 array associated with the relative orientation of two right-handed, orthogonal, unit vector bases |
| Row | Generic Row |
| Row::EltResult | |
| Row::Result | |
| Row::Substitute | |
| RowVector_ | |
| RowVectorBase | This is a dataless rehash of the MatrixBase class to specialize it for RowVectors |
| RowVectorBase::EltResult | |
| RowVectorView_ | |
| ScheduledEventHandler | ScheduledEventHandler is a subclass of EventHandler for events that occur at a particular time that is known in advance |
| ScheduledEventReporter | ScheduledEventReporter is a subclass of EventReporter for events that occur at a particular time that is known in advance |
| SizeOutOfRange | |
| SizeWasNegative | |
| StableArray | StableArray<T> is like std::vector<T> but more stable in two ways:
- the addresses of the inserted items never change, even if the array has to be resized, and
- the index of an inserted item never changes either
|
| Stage | This class is basically a glorified enumerated type, type-safe and range checked but permitting convenient (if limited) arithmetic |
| StageIsWrong | |
| StageOutOfRange | |
| StageTooHigh | |
| StageTooLow | |
| State | This is the handle class for the hidden State implementation |
| String | SimTK::String is just an std::string with some additional methods defined |
| Study | The handle class which serves as the abstract parent of all Studies |
| Study::Guts | This is the declaration for the Study::Guts class, the abstract object to which a Study handle points |
| Subsystem | The abstract parent of all Subsystems |
| Subsystem::Guts | The abstract parent of all Subsystems |
| SymMat | RS is total spacing between rows in memory (default 1) |
| SymMat::EltResult | |
| SymMat::Result | |
| SymMat::Substitute | |
| System::EventTriggerInfo | This class is used to communicate between the System and an Integrator regarding the properties of a particular event trigger function |
| System::Guts | This is the declaration for the System::Guts class, the abstract object to which a System handle points |
| TmpMatrixView_ | XXX not ready for prime time |
| TmpRowVectorView_ | XXX not ready for prime time |
| TmpVectorViewT | XXX not ready for prime time |
| Transform | This class represents the rotate-and-shift transform which gives the location and orientation of a new frame F in a base (reference) frame B |
| TriggeredEventHandler | TriggeredEventHandler is a subclass of EventHandler for events that occur when some condition is satisfied within the system |
| TriggeredEventReporter | TriggeredEventReporter is a subclass of EventReporter for events that occur when some condition is satisfied within the system |
| UnimplementedVirtualMethod | |
| UnitRow | This type is used for the transpose of UnitVec, and as the returned row type of a Rotation |
| UnitVec | This class is a Vec3 plus an ironclad guarantee either that:
- the length is one (to within a very small tolerance), or
- all components are NaN
|
| UserFunction | |
| Value | A particular kind of AbstractValue, with automatic converstion to the underlying type |
| ValueHelper | Templatized version of the abstract class, providing generic type-specific functionality that does not require specialization |
| ValueOutOfRange | |
| ValueWasNegative | |
| Vec | Generic Vec |
| Vec::EltResult | |
| Vec::Result | |
| Vec::Substitute | |
| Vector_ | |
| VectorBase | This is a dataless rehash of the MatrixBase class to specialize it for Vectors |
| VectorBase::EltResult | |
| VectorIterator | This is an iterator for iterating over the elements of a matrix |
| VectorView_ | |
| Wider | |
| Wider< double, double > | |
| Wider< double, float > | |
| Wider< double, long double > | |
| Wider< float, double > | |
| Wider< float, float > | |
| Wider< float, long double > | |
| Wider< long double, double > | |
| Wider< long double, float > | |
| Wider< long double, long double > | |
| Widest | |
| Widest< complex< R1 >, complex< R2 > > | |
| Widest< complex< R1 >, R2 > | |
| Widest< double, double > | |
| Widest< double, float > | |
| Widest< double, long double > | |
| Widest< float, double > | |
| Widest< float, float > | |
| Widest< float, long double > | |
| Widest< long double, double > | |
| Widest< long double, float > | |
| Widest< long double, long double > | |
| Widest< R1, complex< R2 > > | |
