SimTK Namespace Reference

This is the top-level SimTK namespace into which all SimTK names are placed to avoid collision with other symbols. More...

Namespaces
	Exception
	This sub-namespace of SimTK is used for the exception types that are thrown by our error handing code.
	Impl
	Xml
	This namespace contains Xml::Document and all the related XML classes.

Classes
class	Assembler
	This Study attempts to find a configuration (set of joint coordinates q) of a Simbody MultibodySystem that satisfies the System's position Constraints plus optional additional assembly conditions. More...
class	AssemblyCondition
	Define an assembly condition consisting of a scalar goal and/or a related set of assembly error equations (that is, an objective and/or some constraints). More...
class	Markers
	This AssemblyCondition specifies a correspondence between stations on mobilized bodies ("markers") and fixed ground-frame locations ("observations"). More...
class	OrientationSensors
	This AssemblyCondition specifies a correspondence between orientation sensors fixed on mobilized bodies ("osensors") and Ground-relative orientation sensor readings ("observations"). More...
class	QValue
	This AssemblyCondition requests that a particular generalized coordinate end up with a specified value. More...
class	Body
	The Body class represents a reference frame that can be used to describe mass properties and geometry. More...
class	CablePath
	This class represents the path of a frictionless cable from an origin point fixed to a body, through via points and over geometric obstacles fixed to other bodies, to a final termination point. More...
class	CableObstacle
	An obstacle is any significant object along the cable path – one of the end points, a via point, or a surface. More...
class	CableSpan
	This class represents the path of a frictionless cable from an origin point fixed to a body, over geometric obstacles fixed to other bodies, to a final termination point. More...
class	CableSubsystem
	This subsystem manages cables spanning between two points in a system. More...
class	CableSpring
	This force element implements a passive elastic element (like a rubber band) that follows a frictionless CablePath across a set of "obstacles". More...
class	CableTrackerSubsystem
	This subsystem tracks the paths of massless, frictionless cables that take the shortest route between two distant points of a multibody system, passing smoothly over geometric obstacles that are attached to intermediate bodies. More...
class	CompliantContactSubsystem
	This is a force subsystem that implements a compliant contact model to respond to Contact objects as detected by a ContactTrackerSubsystem. More...
class	ContactForce
	This is a simple class containing the basic force information for a single contact between deformable surfaces S1 and S2 mounted on rigid bodies B1 and B2. More...
class	ContactDetail
	This provides deformed geometry and force details for one element of a contact patch that may be composed of many elements. More...
class	ContactPatch
	A ContactPatch is the description of the forces and the deformed shape of the contact surfaces that result from compliant contact interactions. More...
class	ContactForceGenerator
	A ContactForceGenerator implements an algorithm for responding to overlaps or potential overlaps between pairs of ContactSurface objects, as detected by a ContactTrackerSubsystem. More...
class	ConditionalConstraint
	TODO: Simbody model element representing a conditionally-enforced constraint. More...
class	UnilateralContact
	(Experimental – API will change – use at your own risk) A unilateral contact constraint uses a single holonomic (position) constraint equation to prevent motion in one direction while leaving it unrestricted in the other direction. More...
class	UnilateralSpeedConstraint
	TODO: not implemented yet. More...
class	BoundedSpeedConstraint
	TODO: not implemented yet. More...
class	StateLimitedFriction
	TODO: not implemented yet. More...
class	HardStopUpper
	(Experimental – API will change – use at your own risk) Set a hard limit on the maximum value of a generalized coordinate q. More...
class	HardStopLower
	(Experimental – API will change – use at your own risk) Set a hard limit on the minimum value of a generalized coordinate q. More...
class	Rope
	(Experimental – API will change – use at your own risk) Set a hard upper limit on the separation between a point P on one body and a point Q on another. More...
class	PointPlaneFrictionlessContact
	(Experimental – API will change – use at your own risk) Define a point on one body that cannot penetrate a plane attached to another body. More...
class	PointPlaneContact
	(Experimental – API will change – use at your own risk) Define a point on one body that cannot penetrate a plane attached to another body. More...
class	SpherePlaneContact
	(Experimental – API will change – use at your own risk) Define a sphere on one body that cannot penetrate a plane attached to another body. More...
class	SphereSphereContact
	(Experimental – API will change – use at your own risk) Define a sphere on each of two bodies. More...
class	EdgeEdgeContact
	(Experimental – API will change – use at your own risk) Define an edge on each of two bodies, by providing an "edge frame" where the origin is the edge center, x axis is aligned with the edge, and z axis points in the "outward" direction away from the solid whose edge it is. More...
class	Constraint
	This is the base class for all Constraint classes, which is just a handle for the underlying hidden implementation. More...
class	ContactMaterial
	Define the physical properties of the material from which a contact surface is made, including properties needed by a variety of contact response techniques that might be applied during contact. More...
class	ContactSurface
	This class combines a piece of ContactGeometry with a ContactMaterial to make an object suitable for attaching to a body which can then engage in contact behavior with other contact surfaces. More...
class	ContactTrackerSubsystem
	This subsystem identifies and tracks potential contacts between the mobilized bodies of a multibody system. More...
class	ContactSnapshot
	Objects of this class represent collections of surface-pair interactions that are being tracked at a particular instant during a simulation. More...
class	DecorationSubsystem
	This is the client-side handle class encapsulating the hidden implementation of the DecorationSubsystem. More...
class	ElasticFoundationForce
	This class implements an elastic foundation or "bed of springs" contact model. More...
class	ExponentialSpringForce
	Class ExponentialSpringForce uses an "exponential spring" as a means of modeling contact of a specified point on a MobilizedBody with a contact plane that is fixed to Ground. More...
class	ExponentialSpringParameters
	ExponentialSpringParameters is a helper class used to customize the force-producing characteristics of an ExponentialSpringForce instance. More...
class	Force
	This is the base class from which all Force element handle classes derive. More...
class	ForceSubsystem
	This is logically an abstract class, more specialized than "Subsystem" but not yet concrete. More...
class	GeneralContactSubsystem
	This class performs collision detection for use in contact modeling. More...
class	GeneralForceSubsystem
	This is a concrete subsystem which can apply arbitrary forces to a MultibodySystem. More...
class	HuntCrossleyContact
	This is a concrete subsystem that handles simple, frictionless contact situations with a model due to Hunt & Crossley. More...
class	HuntCrossleyForce
	This class models the forces generated by simple point contacts, such as between two spheres, or a sphere and a half space. More...
class	ImpulseSolver
	This is the abstract base class for impulse solvers, which solve an important subproblem of the contact and impact equations. More...
class	LocalEnergyMinimizer
	This class performs local potential energy minimization of a MultibodySystem. More...
class	MobilizedBody
	A MobilizedBody is Simbody's fundamental body-and-joint object used to parameterize a system's motion by constructing a multibody tree containing each body and its unique mobilizer (internal coordinate joint). More...
class	Motion
	A Motion object belongs to a particular MobilizedBody and prescribes how the associated motion is to be calculated. More...
class	MultibodySystem
	The job of the MultibodySystem class is to coordinate the activities of various subsystems which can be part of a multibody system. More...
class	ObservedPointFitter
	This class attempts to find the configuration of an internal coordinate model which best fits a set of observed data. More...
class	PGSImpulseSolver
	Projected Gauss Seidel impulse solver. More...
class	PLUSImpulseSolver
	TODO: PLUS (Poisson-Lankarani-Uchida-Sherman) impulse solver. More...
class	SemiExplicitEulerTimeStepper
	A low-accuracy, high performance, velocity-level time stepper for models containing unilateral rigid contacts or other conditional constraints. More...
class	SimbodyMatterSubsystem
	This subsystem contains the bodies ("matter") in the multibody system, the mobilizers (joints) that define the generalized coordinates used to represent the motion of those bodies, and constraints that must be satisfied by the values of those coordinates. More...
class	SimbodyMatterSubtree
	A SimbodyMatterSubtree is a view of a connected subgraph of the tree of mobilized bodies in a SimbodyMatterSubsystem. More...
class	SimbodyMatterSubtreeResults
class	SmoothSphereHalfSpaceForce
	This class models the forces generated by simple point contacts between a sphere and a half space. More...
class	TextDataEventReporter
	This is an EventReporter which prints out numeric data at regular intervals in tabular form. More...
class	Visualizer
	Provide simple visualization of and interaction with a Simbody simulation, with real time control of the frame rate. There are several operating modes available, including real time operation permitting responsive user interaction with the simulation. More...
class	MatrixBase
	This is the common base class for Simbody's Vector_ and Matrix_ classes for handling large, variable-sized vectors and matrices. More...
class	VectorBase
	This is a dataless rehash of the MatrixBase class to specialize it for Vectors. More...
class	RowVectorBase
	This is a dataless rehash of the MatrixBase class to specialize it for RowVectors. More...
class	MatrixView_
	(Advanced) This class is identical to Matrix_ except that it has shallow (reference) copy and assignment semantics. More...
class	Matrix_
	This is the matrix class intended to appear in user code for large, variable size matrices. More...
class	VectorView_
	(Advanced) This class is identical to Vector_ except that it has shallow (reference) copy and assignment semantics. More...
class	Vector_
	This is the vector class intended to appear in user code for large, variable size column vectors. More...
class	RowVectorView_
	(Advanced) This class is identical to RowVector_ except that it has shallow (reference) copy and assignment semantics. More...
class	RowVector_
	Represents a variable size row vector; much less common than the column vector type Vector_. More...
class	VectorIterator
	This is an iterator for iterating over the elements of a Vector_ or Vec object. More...
class	MatrixStructure
	Matrix "structure" refers to an inherent mathematical (or at least algorithmic) characteristic of the matrix rather than a storage strategy. More...
class	MatrixStorage
	Matrix "storage" refers to the physical layout of data in the computer's memory. More...
class	MatrixOutline
	Matrix "outline" refers to the characteristic relationship between the number of rows and columns of a matrix, without necessarily specifying the absolute dimensions. More...
class	MatrixCondition
	Matrix "condition" is a statement about the numerical characteristics of a Matrix. More...
class	MatrixCharacter
	A MatrixCharacter is a set containing a value for each of the matrix characteristics except element type, which is part of the templatized declaration of a Matrix_, Vector_, or RowVector_ handle. More...
class	MatrixCommitment
	A MatrixCommitment provides a set of acceptable matrix characteristics. More...
class	MatrixHelperRep
class	MatrixHelper
	Here we define class MatrixHelper, the scalar-type templatized helper class for the more general, composite numerical type-templatized class MatrixBase<ELT>. More...
class	DecorationGenerator
	A DecorationGenerator is used to define geometry that may change over the course of a simulation. More...
class	DecorativeGeometry
	This is the client-side interface to an implementation-independent representation of "Decorations" suitable for visualization, annotation, logging, or debugging but which cannot have any effect on the behavior of a System or the evolution of a Study. More...
class	DecorativePoint
	A point of interest. More...
class	DecorativeLine
	A line between two points. More...
class	DecorativeCircle
	This defines a circle in the x-y plane, centered at the origin. More...
class	DecorativeSphere
	This defines a sphere centered at the origin. More...
class	DecorativeEllipsoid
	This defines an ellipsoidal solid centered at the origin and aligned with the local frame axes. More...
class	DecorativeBrick
	This defines a rectangular solid centered at the origin and aligned with the local frame axes. More...
class	DecorativeCylinder
	This defines a cylinder centered on the origin and aligned in the y direction. More...
class	DecorativeFrame
	This defines geometry to represent a coordinate frame. More...
class	DecorativeText
	This defines a text label with its base at the origin. More...
class	DecorativeMesh
	This defines a displayable mesh by referencing an already-existing PolygonalMesh object. More...
class	DecorativeMeshFile
	This defines a displayable mesh by referencing a file name containing the mesh. More...
class	DecorativeTorus
	This defines a displayable torus, the torus is centered at the origin with the axial direction aligned to the z-axis. More...
class	DecorativeArrow
	An arrow with start point, end point and tip-length. More...
class	DecorativeCone
	A cone with origin point, direction, height and base radius. More...
class	Decorations
	This defines a single DecorativeGeometry object that is composed of a collection of other DecorativeGeometry objects. More...
class	DecorativeGeometryImplementation
	Use this abstract class to connect your implementation of decorative geometry to the implementation-independent classes above. More...
class	PolygonalMesh
	This class provides a description of a mesh made of polygonal faces (not limited to triangles). More...
struct	ArrayIndexTraits
	This templatized type is used by the Array_<T,X> classes to obtain the information they need to use the class X as an index class for the array. More...
class	ArrayViewConst_
	This Array_ helper class is the base class for ArrayView_ which is the base class for Array_; here we provide only the minimal read-only "const" functionality required by any Array_ object, and shallow copy semantics. More...
class	ArrayView_
	This Array_ helper class is the base class for Array_, extending ArrayViewConst_ to add the ability to modify elements, but not the ability to change size or reallocate. More...
class	Array_
	The Array_<T> container class is a plug-compatible replacement for the C++ standard template library (STL) std::vector<T> class, but with some important advantages in performance, and functionality, and binary compatibility. More...
struct	ArrayIndexTraits< unsigned >
	Specialization of ArrayIndexTraits for unsigned (that is, unsigned int) used as an index. More...
struct	ArrayIndexTraits< int >
	Specialization of ArrayIndexTraits for (signed) int used as an index. More...
struct	ArrayIndexTraits< unsigned long >
	Specialization of ArrayIndexTraits for unsigned long used as an index. More...
struct	ArrayIndexTraits< long >
	Specialization of ArrayIndexTraits for (signed) long used as an index. More...
struct	ArrayIndexTraits< unsigned short >
	Specialization of ArrayIndexTraits for unsigned short used as an index. More...
struct	ArrayIndexTraits< short >
	Specialization of ArrayIndexTraits for (signed) short used as an index. More...
struct	ArrayIndexTraits< unsigned char >
	Specialization of ArrayIndexTraits for unsigned char used as an index. More...
struct	ArrayIndexTraits< signed char >
	Specialization of ArrayIndexTraits for signed char used as an index. More...
struct	ArrayIndexTraits< char >
	Specialization of ArrayIndexTraits for char used as an index. More...
struct	ArrayIndexTraits< bool >
	Specialization of ArrayIndexTraits for bool used as an index. More...
struct	ArrayIndexTraits< unsigned long long >
	Specialization of ArrayIndexTraits for unsigned long long used as an index. More...
struct	ArrayIndexTraits< long long >
	Specialization of ArrayIndexTraits for long long used as an index. More...
class	CloneOnWritePtr
	Smart pointer with deep copy semantics but with the copying delayed until an attempt is made to write on the contained object. More...
class	ClonePtr
	Smart pointer with deep copy semantics. More...
class	Vec
	This is a fixed-length column vector designed for no-overhead inline computation. More...
class	Row
	This is a fixed-length row vector designed for no-overhead inline computation. More...
class	Mat
	This class represents a small matrix whose size is known at compile time, containing elements of any Composite Numerical Type (CNT) and engineered to have no runtime overhead whatsoever. More...
class	SymMat
	This is a small, fixed-size symmetric or Hermitian matrix designed for no-overhead inline computation. More...
struct	Segment
	A convenient struct for anything requiring an offset and length to specify a segment of some larger sequence. More...
struct	DontCopy
	This is a special type used for causing invocation of a particular constructor or method overload that will avoid making a copy of the source (that is, perform a "shallow" copy rather than a "deep" copy). More...
struct	TrustMe
	This is a special type used for forcing invocation of a particularly dangerous constructor or method overload; don't use this unless you are an advanced user and know exactly what you're getting into. More...
struct	FalseType
	This is a compile-time equivalent of "false", used in compile-time condition checking in templatized implementations. More...
struct	TrueType
	This is a compile-time equivalent of "true", used in compile-time condition checking in templatized implementations. More...
struct	AndOpType
	This is an operator for and-ing compile-time truth types. More...
struct	AndOpType< FalseType, FalseType >
struct	AndOpType< FalseType, TrueType >
struct	AndOpType< TrueType, FalseType >
struct	AndOpType< TrueType, TrueType >
struct	OrOpType
	This is an operator for or-ing compile-time truth types. More...
struct	OrOpType< FalseType, FalseType >
struct	OrOpType< FalseType, TrueType >
struct	OrOpType< TrueType, FalseType >
struct	OrOpType< TrueType, TrueType >
struct	XorOpType
	This is an operator for exclusive or-ing compile-time truth types. More...
struct	XorOpType< FalseType, FalseType >
struct	XorOpType< FalseType, TrueType >
struct	XorOpType< TrueType, FalseType >
struct	XorOpType< TrueType, TrueType >
struct	IsIntegralType
	Compile-time type test: is this one of the built-in integral types?. More...
struct	IsFloatingType
	Compile-time type test: is this one of the built-in floating point types?. More...
struct	IsVoidType
	Compile-time type test: is this the void type?. More...
struct	IsVoidType< void >
struct	IsArithmeticType
	Compile-time test: is this one of the built-in "arithmetic" types, meaning an integral or floating type? More...
struct	Is64BitHelper
struct	Is64BitHelper< true >
struct	Is64BitHelper< false >
struct	NiceTypeName
	Obtain human-readable and XML-usable names for arbitrarily-complicated C++ types. More...
class	Function_
	This abstract class represents a mathematical function that calculates a value of arbitrary type based on M real arguments. More...
class	IteratorRange
	Helper class to use range-based for loops with a pair of iterators. More...
class	Parallel2DExecutor
	This class is used for performing multithreaded computations over two dimensional ranges. More...
class	ParallelExecutor
	This class is used for performing multithreaded computations. More...
class	ParallelWorkQueue
	This class is used for performing multithreaded computations. It maintains a queue of tasks to be executed, and a pool of threads for executing them. More...
class	Pathname
	This class encapsulates the handling of file and directory pathnames in a platform-independent manner. More...
class	Plugin
	This is the base class for representing a runtime-linked dynamic library, also known as a "plugin", in a platform-independent manner. More...
class	PIMPLHandle
	This class provides some infrastructure useful in making SimTK Private Implementation (PIMPL) classes. More...
class	PIMPLImplementation
	This class provides some infrastructure useful in creating PIMPL Implementation classes (the ones referred to by Handles). More...
class	ReferencePtr
	This is a smart pointer that implements "cross reference" semantics where a pointer data member of some object is intended to refer to some target object in a larger data structure. More...
class	ReinitOnCopyHelper
	This helper class is used only by ReinitOnCopy and is specialized as necessary to support a variety of template types T. More...
class	ReinitOnCopy
	Ensures that a data member of type T is automatically reinitialized to a given initial value upon copy construction or copy assignment. This allows the compiler-generated default copy methods to be used. More...
class	ResetOnCopyHelper
	This helper class is used only by ResetOnCopy and is specialized as necessary to support a variety of template types T. More...
class	ResetOnCopy
	Ensures that a data member of type T is automatically reset to its default value upon copy construction or copy assignment. This allows the compiler-generated default copy methods to be used. More...
class	StableArray
	StableArray<T> is like std::vector<T> (or SimTK::Array_<T>) but more stable in two ways: More...
class	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. More...
class	conjugate
	SimTK::conjugate<R> should be instantiated only for float, double. More...
class	String
	SimTK::String is a plug-compatible std::string replacement (plus some additional functionality) intended to be suitable for passing through the SimTK API without introducing binary compatibility problems the way std::string does, especially on Windows. More...
class	Value
	Concrete templatized class derived from AbstractValue, adding generic value type-specific functionality, with implicit conversion to the underlying type T. More...
class	AbstractValue
	Abstract base class representing an arbitrary value of unknown type. More...
class	Lapack
class	Test
	This is the main class to support testing. More...
class	CoordinateAxis
	This class, along with its sister class CoordinateDirection, provides convenient manipulation of the three coordinate axes via the definition of three constants XAxis, YAxis, and ZAxis each with a unique subtype and implicit conversion to the integers 0, 1, and 2 whenever necessary. Methods are provided to allow code to be written once that can be used to work with the axes in any order. More...
class	CoordinateDirection
	A CoordinateDirection is a CoordinateAxis plus a direction indicating the positive or negative direction along that axis. More...
class	UnitInertia_
	A UnitInertia matrix is a unit-mass inertia matrix; you can convert it to an Inertia by multiplying it by the actual body mass. More...
class	Inertia_
	The physical meaning of an inertia is the distribution of a rigid body's mass about a particular point. More...
class	SpatialInertia_
	A spatial inertia contains the mass, center of mass point, and inertia matrix for a rigid body. More...
class	ArticulatedInertia_
	An articulated body inertia (ABI) matrix P(q) contains the spatial inertia properties that a body appears to have when it is the free base body of an articulated multibody tree in a given configuration q. More...
class	MassProperties_
	This class contains the mass, center of mass, and unit inertia matrix of a rigid body B. More...
class	Rotation_
	The Rotation class is a Mat33 that guarantees that the matrix can be interpreted as a legitimate 3x3 rotation matrix giving the relative orientation of two right-handed, orthogonal, unit vector bases. More...
class	Quaternion_
	A Quaternion is a Vec4 with the following behavior: More...
class	InverseRotation_
	(Advanced) This InverseRotation class is the inverse of a Rotation. More...
class	PhiMatrix
class	PhiMatrixTranspose
class	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. More...
class	InverseTransform_
	Transform from frame B to frame F, but with the internal representation inverted. More...
class	UnitVec
	This class is a Vec3 plus an ironclad guarantee either that: More...
class	UnitRow
	This type is used for the transpose of UnitVec, and as the returned row type of a Rotation. More...
class	PolynomialRootFinder
	This class provides static methods for finding the roots of polynomials. More...
class	Random
	This class defines the interface for pseudo-random number generators. More...
class	CNT
	Specialized information about Composite Numerical Types which allows us to define appropriate templatized classes using them. More...
struct	Wider
struct	Wider< float, float >
struct	Wider< float, double >
struct	Wider< double, float >
struct	Wider< double, double >
class	conjugate< float >
class	conjugate< double >
class	NTraits
struct	Widest
	This class is specialized for all 16 combinations of standard types (that is, real and complex types in each of two precisions) and has typedefs "Type" which is the appropriate "widened" type for use when R1 & R2 appear in an operation together, and "Precision" which is the wider precision (float,double). More...
struct	Widest< float, float >
struct	Widest< float, double >
struct	Widest< double, float >
struct	Widest< double, double >
struct	Widest< complex< R1 >, complex< R2 > >
struct	Widest< complex< R1 >, R2 >
struct	Widest< R1, complex< R2 > >
struct	Narrowest
	This class is specialized for all 16 combinations of standard types (that is, real and complex types in each of two precisions) and has typedefs "Type" which is the appropriate "narrowed" type for use when R1 & R2 appear in an operation together where the result must be of the narrower precision, and "Precision" which is the expected precision of the result (float, double). More...
struct	Narrowest< float, float >
struct	Narrowest< float, double >
struct	Narrowest< double, float >
struct	Narrowest< double, double >
struct	Narrowest< complex< R1 >, complex< R2 > >
struct	Narrowest< complex< R1 >, R2 >
struct	Narrowest< R1, complex< R2 > >
class	RTraits
	RTraits is a helper class for NTraits. More...
class	RTraits< float >
class	RTraits< double >
class	NTraits< complex< R > >
	Partial specialization for complex numbers – underlying real R is still a template parameter. More...
class	NTraits< conjugate< R > >
class	CNT< complex< R > >
	Specializations of CNT for numeric types. More...
class	CNT< conjugate< R > >
class	CNT< float >
class	CNT< double >
class	Event
	An Event is "something that happens" during a Study that is advancing through time. More...
class	EventTriggerInfo
	This class is used to communicate between the System and an Integrator regarding the properties of a particular event trigger function. More...
class	HandleEventsOptions
	Options for the handleEvent() method. More...
class	HandleEventsResults
	Results returned by the handleEvent() method. More...
class	EventHandler
	An EventHandler is an object that defines an event that can occur within a system. More...
class	ScheduledEventHandler
	ScheduledEventHandler is a subclass of EventHandler for events that occur at a particular time that is known in advance. More...
class	TriggeredEventHandler
	TriggeredEventHandler is a subclass of EventHandler for events that occur when some condition is satisfied within the system. More...
class	PeriodicEventHandler
	PeriodicEventHandler is a subclass of ScheduledEventHandler which generates a series of uniformly spaced events at regular intervals. More...
class	EventReporter
	An EventReporter is an object that defines an event that can occur within a system. More...
class	ScheduledEventReporter
	ScheduledEventReporter is a subclass of EventReporter for events that occur at a particular time that is known in advance. More...
class	TriggeredEventReporter
	TriggeredEventReporter is a subclass of EventReporter for events that occur when some condition is satisfied within the system. More...
class	PeriodicEventReporter
	PeriodicEventReporter is a subclass of ScheduledEventReporter which generates a series of uniformly spaced events at regular intervals. More...
class	AbstractMeasure
	This is the base class for all Measure handle classes. More...
class	Measure_
	This is the base handle class for all Measures whose value type is known, including all the Simbody built-in Measure types. More...
class	Stage
	This class is basically a glorified enumerated type, type-safe and range checked but permitting convenient (if limited) arithmetic. More...
class	State
	This object is intended to contain all state information for a SimTK::System, except topological information which is stored in the System itself. More...
class	Study
class	Subsystem
	A Subsystem is expected to be part of a larger System and to have interdependencies with other subsystems of that same System. More...
class	System
	This is the base class that serves as the parent of all SimTK System objects; most commonly Simbody's MultibodySystem class. More...
class	DefaultSystemSubsystem
	This is a concrete Subsystem that is part of every System. It provides a variety of services for the System, such as maintaining lists of event handlers and reporters, and acting as a source of globally unique event IDs. More...
class	ProjectOptions
	Options for the advanced project() methods. More...
class	ProjectResults
	Results for advanced users of project() methods. More...
class	RealizeOptions
	(NOT USED YET) Options for the advanced realize() methods. More...
class	RealizeResults
	(NOT USED YET) Results for advanced users of realize() methods. More...
class	BicubicSurface
	This class will create a smooth surface that approximates a two-argument function F(X,Y) from a given set of samples of that function on a rectangular grid with regular or irregular spacing. More...
class	BicubicFunction
	This is a two-argument Function built using a shared BicubicSurface and managing current state to optimize for localized access. More...
class	CollisionDetectionAlgorithm
	A CollisionDetectionAlgorithm implements an algorithm for detecting overlaps between pairs of ContactGeometry objects, and creating Contact objects based on them. More...
class	Contact
	A Contact contains information about the spatial relationship between two surfaces that are near, or in contact with, each other. More...
class	UntrackedContact
	This subclass of Contact represents a pair of contact surfaces that are not yet being tracked; there is no ContactId for them. More...
class	BrokenContact
	This subclass of Contact represents a pair of contact surfaces that were in contact (meaning within cutoff range) but have now gone out of range. More...
class	CircularPointContact
	This subclass of Contact represents a contact between two non-conforming surfaces 1 and 2 that initially meet at a point where each surface has a uniform radius of curvature in all directions (R1 and R2), like a sphere (inside or outside) or a halfspace, resulting in a contact region with circular symmetry. More...
class	EllipticalPointContact
	This subclass of Contact represents a contact between two non-conforming surfaces 1 and 2 that initially meet at a point and where each surface has two principal curvatures (maximum and minimum) in perpendicular directions. More...
class	BrickHalfSpaceContact
	This subclass of Contact is used when one ContactGeometry object is a half plane and the other is a Brick. More...
class	TriangleMeshContact
	This subclass of Contact is used when one or both of the ContactGeometry objects is a TriangleMesh. More...
class	PointContact
	OBSOLETE – use CircularPointContact or EllipticalPointContact. More...
class	ContactGeometry
	A ContactGeometry object describes the shape of all or part of the boundary of a solid object, for the purpose of modeling with Simbody physical effects that occur at the surface of that object, such as contact and wrapping forces. More...
class	Plane
	A simple plane class. More...
class	GeodHitPlaneEvent
	A event handler to terminate integration when geodesic hits the plane. More...
class	PathDecorator
	This class generates decoration for contact points and straight line path segments. More...
class	PlaneDecorator
	This class generates decoration for a plane. More...
class	ContactTracker
	A ContactTracker implements an algorithm for detecting overlaps or potential overlaps between pairs of ContactGeometry objects, and managing Contact objects that track individual contacts as they evolve through time. More...
class	GCVSPLUtil
	This class provides entry points for using the GCVSPL algorithm in terms of SimTK data types. More...
class	Geo
	The Geo class collects geometric primitives intended to deal with raw, fixed-size geometric shapes occupying minimal memory and providing maximum performance through small inline methods and larger high performance algorithms. More...
class	Geodesic
	This class stores a geodesic curve after it has been determined. More...
class	GeodesicDecorator
	This class generates decoration (line segments) for a geodesic curve. More...
class	GeodesicOptions
	This class stores options for calculating geodesics. More...
class	GeodesicIntegrator
	This is a stripped-down numerical integrator for small ODE or DAE problems whose size is known at compile time, with no provision for discrete variables, event detection, or interpolation. More...
class	OBBLeaf
	TODO. More...
class	OBBNode
	TODO. More...
class	OBBTree
	TODO. More...
class	OrientedBoundingBox
	This class represents a rectangular box with arbitrary position and orientation. More...
class	ParticleConSurfaceSystemGuts
class	ParticleConSurfaceSystem
class	Spline_
	This class implements a non-uniform Bezier curve. More...
class	SplineFitter
	Given a set of data points, this class creates a Spline_ which interpolates or approximates them. More...
class	Differentiator
	Given a function f(y), where f, y or both can be vectors, calculate the derivative (gradient, Jacobian) df/dy. More...
class	SysObjectiveFunc
class	SysConstraintFunc
class	DefaultOptimizer
class	Factor
	Base class for the various matrix factorizations. More...
class	FactorLU
	Class for performing LU matrix factorizations. More...
class	FactorQTZ
	Class to perform a QTZ (linear least squares) factorization. More...
class	Eigen
	Class to compute Eigen values and Eigen vectors of a matrix. More...
class	FactorSVD
	Class to compute a singular value decomposition of a matrix. More...
class	MultibodyGraphMaker
	Construct a reasonably good spanning-tree-plus-constraints structure for modeling a given set of bodies and joints with a generalized coordinate multibody system like Simbody. More...
class	OptimizerSystem
	Abstract class which defines an objective/cost function which is optimized by and Optimizer object. More...
class	Optimizer
	API for SimTK Simmath's optimizers. More...
class	CPodesIntegrator
	This is an Integrator based on the CPODES library. More...
class	ExplicitEulerIntegrator
	This is an Integrator based on the explicit Euler algorithm. More...
class	Integrator
	An Integrator is an object that can advance the State of a System through time. More...
class	CPodesSystem
	This abstract class defines the system to be integrated with SimTK CPodes. More...
class	CPodes
	This is a straightforward translation of the Sundials CPODES C interface into C++. More...
class	RungeKutta2Integrator
	This is a 2nd order Runge-Kutta Integrator using coefficients that are also known as the explicit trapezoid rule. More...
class	RungeKutta3Integrator
	This is a 3rd order Runge-Kutta Integrator using coefficients from J.C. More...
class	RungeKuttaFeldbergIntegrator
class	RungeKuttaMersonIntegrator
class	SemiExplicitEuler2Integrator
	This is an implementation of a variable-step, first-order semi-explicit Euler method, also known as semi-implicit Euler or symplectic Euler. More...
class	SemiExplicitEulerIntegrator
	This is an implementation of the fixed-step Semi-Explicit Euler method, also known as Semi-Implicit Euler or Symplectic Euler. More...
class	TimeStepper
	This class uses an Integrator to advance a System through time. More...
class	VerletIntegrator
	This is an Integrator based on the velocity Verlet algorithm. More...

Typedefs
typedef MobilizedBodyIndex	MobodIndex
	This is the approved abbeviation for MobilizedBodyIndex. Feel free to use it if you get tired of typing or seeing the full name. More...
typedef ForceSubsystem::Guts	ForceSubsystemRep
typedef Visualizer	VTKVisualizer
	OBSOLETE: This provides limited backwards compatibility with the old VTK Visualizer that is no longer supported. Switch to Visualizer instead. More...
typedef Visualizer::Reporter	VTKEventReporter
	OBSOLETE: This provides limited backwards compatibility with the old VTK Visualizer that is no longer supported. Switch to Visualizer::Reporter instead. More...
typedef SimTK_Real	Real
	This is the default compiled-in floating point type for SimTK, either float or double. More...
typedef std::complex< Real >	Complex
	This is the default complex type for SimTK, with precision for the real and imaginary parts set to the compiled-in Real type. More...
typedef std::complex< float >	fComplex
	An abbreviation for std::complex<float> for consistency with others. More...
typedef std::complex< double >	dComplex
	An abbreviation for std::complex<double> for consistency with others. More...
typedef Is64BitHelper< Is64BitPlatform >::Result	Is64BitPlatformType
typedef Function_< Real >	Function
	This typedef is used for the very common case that the return type of the Function object is Real. More...
typedef Vec< 2, Vec3 >	SpatialVec
	Spatial vectors are used for (rotation,translation) quantities and consist of a pair of Vec3 objects, arranged as a 2-vector of 3-vectors. More...
typedef Vec< 2, Vec< 3, float > >	fSpatialVec
	A SpatialVec that is always single (float) precision regardless of the compiled-in precision of Real. More...
typedef Vec< 2, Vec< 3, double > >	dSpatialVec
	A SpatialVec that is always double precision regardless of the compiled-in precision of Real. More...
typedef Row< 2, Row3 >	SpatialRow
	This is the type of a transposed SpatialVec; it does not usually appear explicitly in user programs. More...
typedef Row< 2, Row< 3, float > >	fSpatialRow
	A SpatialRow that is always single (float) precision regardless of the compiled-in precision of Real. More...
typedef Row< 2, Row< 3, double > >	dSpatialRow
	A SpatialRow that is always double precision regardless of the compiled-in precision of Real. More...
typedef Mat< 2, 2, Mat33 >	SpatialMat
	Spatial matrices are used to hold 6x6 matrices that are best viewed as 2x2 matrices of 3x3 matrices; most commonly for spatial and articulated body inertias and spatial shift matrices. More...
typedef Mat< 2, 2, Mat< 3, 3, float > >	fSpatialMat
	A SpatialMat that is always single (float) precision regardless of the compiled-in precision of Real. More...
typedef Mat< 2, 2, Mat< 3, 3, double > >	dSpatialMat
	A SpatialMat that is always double precision regardless of the compiled-in precision of Real. More...
typedef UnitInertia_< Real >	UnitInertia
	A unit inertia (gyration) tensor at default precision. More...
typedef UnitInertia_< float >	fUnitInertia
	A unit inertia (gyration) tensor at float precision. More...
typedef UnitInertia_< double >	dUnitInertia
	A unit inertia (gyration) tensor at double precision. More...
typedef Inertia_< Real >	Inertia
	An inertia tensor at default precision. More...
typedef Inertia_< float >	fInertia
	An inertia tensor at float precision. More...
typedef Inertia_< double >	dInertia
	An inertia tensor at double precision. More...
typedef MassProperties_< Real >	MassProperties
	Rigid body mass properties at default precision. More...
typedef MassProperties_< float >	fMassProperties
	Rigid body mass properties at float precision. More...
typedef MassProperties_< double >	dMassProperties
	Rigid body mass properties at double precision. More...
typedef SpatialInertia_< Real >	SpatialInertia
	A spatial (rigid body) inertia matrix at default precision. More...
typedef SpatialInertia_< float >	fSpatialInertia
	A spatial (rigid body) inertia matrix at float precision. More...
typedef SpatialInertia_< double >	dSpatialInertia
	A spatial (rigid body) inertia matrix at double precision. More...
typedef ArticulatedInertia_< Real >	ArticulatedInertia
	An articulated body inertia matrix at default precision. More...
typedef ArticulatedInertia_< float >	fArticulatedInertia
	An articulated body inertia matrix at float precision. More...
typedef ArticulatedInertia_< double >	dArticulatedInertia
	An articulated body inertia matrix at double precision. More...
typedef UnitInertia	Gyration
	For backwards compatibility only; use UnitInertia instead. More...
typedef Quaternion_< Real >	Quaternion
typedef Quaternion_< float >	fQuaternion
typedef Quaternion_< double >	dQuaternion
typedef Rotation_< Real >	Rotation
typedef Rotation_< float >	fRotation
typedef Rotation_< double >	dRotation
typedef InverseRotation_< Real >	InverseRotation
typedef InverseRotation_< float >	fInverseRotation
typedef InverseRotation_< double >	dInverseRotation
typedef Transform_< Real >	Transform
typedef Transform_< float >	fTransform
typedef Transform_< double >	dTransform
typedef UnitVec< Real, 1 >	UnitVec3
typedef UnitVec< float, 1 >	fUnitVec3
typedef UnitVec< double, 1 >	dUnitVec3
typedef conjugate< Real >	Conjugate
typedef Measure_< Real >	Measure
	This typedef is a convenient abbreviation for the most common kind of Measure – one that returns a single Real result; the underlying class is Measure_; look there for documentation. More...
typedef long long	StageVersion
	This is the type to use for Stage version numbers that get incremented whenever a state variable change invalidates a Stage. More...
typedef long long	ValueVersion
	This is the type to use for state variable version numbers that get incremented whenever a state value changes. More...
using	CacheEntryKey = std::pair< SubsystemIndex, CacheEntryIndex >
using	DiscreteVarKey = std::pair< SubsystemIndex, DiscreteVariableIndex >
typedef Vec< 2 >	Vec2
	This is the most common 2D vector type: a column of 2 Real values stored consecutively in memory (packed). More...
typedef Vec< 3 >	Vec3
	This is the most common 3D vector type: a column of 3 Real values stored consecutively in memory (packed). More...
typedef Vec< 4 >	Vec4
	This is the most common 4D vector type: a column of 4 Real values stored consecutively in memory (packed). More...
typedef Mat< 2, 2 >	Mat22
	This is the most common 2x2 matrix type: two packed columns of 2 Real values each. More...
typedef Mat< 3, 3 >	Mat33
	This is the most common 3x3 matrix type: three packed columns of 3 Real values each. More...
typedef Mat< 4, 4 >	Mat44
	This is the most common 4x4 matrix type: four packed columns of 4 Real values each. More...
typedef SymMat< 2 >	SymMat22
	A compact, 2x2 Real symmetric matrix; only 3 elements are stored. More...
typedef SymMat< 3 >	SymMat33
	A compact, 3x3 Real symmetric matrix; only 6 elements are stored. More...
typedef SymMat< 4 >	SymMat44
	A compact, 2x2 Real symmetric matrix; only 10 elements are stored. More...
typedef Row< 2 >	Row2
	Packed, 2-element row of Real values. More...
typedef Row< 3 >	Row3
	Packed, 3-element row of Real values. More...
typedef Row< 4 >	Row4
	Packed, 4-element row of Real values. More...
typedef Vec< 1 >	Vec1
	A vector of just one Real element (not too useful). More...
typedef Vec< 5 >	Vec5
	Packed, 5-element vector of Real values. More...
typedef Vec< 6 >	Vec6
	Packed, 6-element vector of Real values. More...
typedef Vec< 7 >	Vec7
	Packed, 7-element vector of Real values. More...
typedef Vec< 8 >	Vec8
	Packed, 8-element vector of Real values. More...
typedef Vec< 9 >	Vec9
	Packed, 9-element vector of Real values. More...
typedef Mat< 1, 1 >	Mat11
	1x1 Real matrix, that is, a scalar. More...
typedef Mat< 1, 2 >	Mat12
	1x2 Real row matrix. More...
typedef Mat< 1, 3 >	Mat13
	1x3 Real row matrix. More...
typedef Mat< 1, 4 >	Mat14
	1x4 Real row matrix. More...
typedef Mat< 1, 5 >	Mat15
	1x5 Real row matrix. More...
typedef Mat< 1, 6 >	Mat16
	1x6 Real row matrix. More...
typedef Mat< 1, 7 >	Mat17
	1x7 Real row matrix. More...
typedef Mat< 1, 8 >	Mat18
	1x8 Real row matrix. More...
typedef Mat< 1, 9 >	Mat19
	1x9 Real row matrix. More...
typedef Mat< 2, 1 >	Mat21
	2x1 Real column matrix. More...
typedef Mat< 2, 3 >	Mat23
	2x3 Real matrix, packed by columns. More...
typedef Mat< 2, 4 >	Mat24
	2x4 Real matrix, packed by columns. More...
typedef Mat< 2, 5 >	Mat25
	2x5 Real matrix, packed by columns. More...
typedef Mat< 2, 6 >	Mat26
	2x6 Real matrix, packed by columns. More...
typedef Mat< 2, 7 >	Mat27
	2x7 Real matrix, packed by columns. More...
typedef Mat< 2, 8 >	Mat28
	2x8 Real matrix, packed by columns. More...
typedef Mat< 2, 9 >	Mat29
	2x9 Real matrix, packed by columns. More...
typedef Mat< 3, 1 >	Mat31
	3x1 Real column matrix. More...
typedef Mat< 3, 2 >	Mat32
	3x2 Real matrix, packed by columns. More...
typedef Mat< 3, 4 >	Mat34
	3x4 Real matrix, packed by columns. More...
typedef Mat< 3, 5 >	Mat35
	3x5 Real matrix, packed by columns. More...
typedef Mat< 3, 6 >	Mat36
	3x6 Real matrix, packed by columns. More...
typedef Mat< 3, 7 >	Mat37
	3x7 Real matrix, packed by columns. More...
typedef Mat< 3, 8 >	Mat38
	3x8 Real matrix, packed by columns. More...
typedef Mat< 3, 9 >	Mat39
	3x9 Real matrix, packed by columns. More...
typedef Mat< 4, 1 >	Mat41
	4x1 Real column matrix. More...
typedef Mat< 4, 2 >	Mat42
	4x2 Real matrix, packed by columns. More...
typedef Mat< 4, 3 >	Mat43
	4x3 Real matrix, packed by columns. More...
typedef Mat< 4, 5 >	Mat45
	4x5 Real matrix, packed by columns. More...
typedef Mat< 4, 6 >	Mat46
	4x6 Real matrix, packed by columns. More...
typedef Mat< 4, 7 >	Mat47
	4x7 Real matrix, packed by columns. More...
typedef Mat< 4, 8 >	Mat48
	4x8 Real matrix, packed by columns. More...
typedef Mat< 4, 9 >	Mat49
	4x9 Real matrix, packed by columns. More...
typedef Mat< 5, 1 >	Mat51
	5x1 Real column matrix. More...
typedef Mat< 5, 2 >	Mat52
	5x2 Real matrix, packed by columns. More...
typedef Mat< 5, 3 >	Mat53
	5x3 Real matrix, packed by columns. More...
typedef Mat< 5, 4 >	Mat54
	5x4 Real matrix, packed by columns. More...
typedef Mat< 5, 5 >	Mat55
	5x5 Real matrix, packed by columns. More...
typedef Mat< 5, 6 >	Mat56
	5x6 Real matrix, packed by columns. More...
typedef Mat< 5, 7 >	Mat57
	5x7 Real matrix, packed by columns. More...
typedef Mat< 5, 8 >	Mat58
	5x8 Real matrix, packed by columns. More...
typedef Mat< 5, 9 >	Mat59
	5x9 Real matrix, packed by columns. More...
typedef Mat< 6, 1 >	Mat61
	6x1 Real column matrix. More...
typedef Mat< 6, 2 >	Mat62
	6x2 Real matrix, packed by columns. More...
typedef Mat< 6, 3 >	Mat63
	6x3 Real matrix, packed by columns. More...
typedef Mat< 6, 4 >	Mat64
	6x4 Real matrix, packed by columns. More...
typedef Mat< 6, 5 >	Mat65
	6x5 Real matrix, packed by columns. More...
typedef Mat< 6, 6 >	Mat66
	6x6 Real matrix, packed by columns. More...
typedef Mat< 6, 7 >	Mat67
	6x7 Real matrix, packed by columns. More...
typedef Mat< 6, 8 >	Mat68
	6x8 Real matrix, packed by columns. More...
typedef Mat< 6, 9 >	Mat69
	6x9 Real matrix, packed by columns. More...
typedef Mat< 7, 1 >	Mat71
	7x1 Real column matrix. More...
typedef Mat< 7, 2 >	Mat72
	7x2 Real matrix, packed by columns. More...
typedef Mat< 7, 3 >	Mat73
	7x3 Real matrix, packed by columns. More...
typedef Mat< 7, 4 >	Mat74
	7x4 Real matrix, packed by columns. More...
typedef Mat< 7, 5 >	Mat75
	7x5 Real matrix, packed by columns. More...
typedef Mat< 7, 6 >	Mat76
	7x6 Real matrix, packed by columns. More...
typedef Mat< 7, 7 >	Mat77
	7x7 Real matrix, packed by columns. More...
typedef Mat< 7, 8 >	Mat78
	7x8 Real matrix, packed by columns. More...
typedef Mat< 7, 9 >	Mat79
	7x9 Real matrix, packed by columns. More...
typedef Mat< 8, 1 >	Mat81
	8x1 Real column matrix. More...
typedef Mat< 8, 2 >	Mat82
	8x2 Real matrix, packed by columns. More...
typedef Mat< 8, 3 >	Mat83
	8x3 Real matrix, packed by columns. More...
typedef Mat< 8, 4 >	Mat84
	8x4 Real matrix, packed by columns. More...
typedef Mat< 8, 5 >	Mat85
	8x5 Real matrix, packed by columns. More...
typedef Mat< 8, 6 >	Mat86
	8x6 Real matrix, packed by columns. More...
typedef Mat< 8, 7 >	Mat87
	8x7 Real matrix, packed by columns. More...
typedef Mat< 8, 8 >	Mat88
	8x8 Real matrix, packed by columns. More...
typedef Mat< 8, 9 >	Mat89
	8x9 Real matrix, packed by columns. More...
typedef Mat< 9, 1 >	Mat91
	9x1 Real column matrix. More...
typedef Mat< 9, 2 >	Mat92
	9x2 Real matrix, packed by columns. More...
typedef Mat< 9, 3 >	Mat93
	9x3 Real matrix, packed by columns. More...
typedef Mat< 9, 4 >	Mat94
	9x4 Real matrix, packed by columns. More...
typedef Mat< 9, 5 >	Mat95
	9x5 Real matrix, packed by columns. More...
typedef Mat< 9, 6 >	Mat96
	9x6 Real matrix, packed by columns. More...
typedef Mat< 9, 7 >	Mat97
	9x7 Real matrix, packed by columns. More...
typedef Mat< 9, 8 >	Mat98
	9x8 Real matrix, packed by columns. More...
typedef Mat< 9, 9 >	Mat99
	9x9 Real matrix, packed by columns. More...
typedef SymMat< 1 >	SymMat11
	1x1 Real symmetric matrix, that is, a scalar. More...
typedef SymMat< 5 >	SymMat55
	5x5 compact Real symmetric matrix. More...
typedef SymMat< 6 >	SymMat66
	6x6 compact Real symmetric matrix. More...
typedef SymMat< 7 >	SymMat77
	7x7 compact Real symmetric matrix. More...
typedef SymMat< 8 >	SymMat88
	8x8 compact Real symmetric matrix. More...
typedef SymMat< 9 >	SymMat99
	9x9 compact Real symmetric matrix. More...
typedef Row< 1 >	Row1
	A row vector of one Real element (not too useful). More...
typedef Row< 5 >	Row5
	Packed, 5-element row of Real values. More...
typedef Row< 6 >	Row6
	Packed, 6-element row of Real values. More...
typedef Row< 7 >	Row7
	Packed, 7-element row of Real values. More...
typedef Row< 8 >	Row8
	Packed, 8-element row of Real values. More...
typedef Row< 9 >	Row9
	Packed, 9-element row of Real values. More...
typedef Vec< 1, float >	fVec1
	A vector of one float element (not too useful). More...
typedef Vec< 2, float >	fVec2
	Packed, 2-element vector of float values. More...
typedef Vec< 3, float >	fVec3
	Packed, 3-element vector of float values. More...
typedef Vec< 4, float >	fVec4
	Packed, 4-element vector of float values. More...
typedef Vec< 5, float >	fVec5
	Packed, 5-element vector of float values. More...
typedef Vec< 6, float >	fVec6
	Packed, 6-element vector of float values. More...
typedef Vec< 7, float >	fVec7
	Packed, 7-element vector of float values. More...
typedef Vec< 8, float >	fVec8
	Packed, 8-element vector of float values. More...
typedef Vec< 9, float >	fVec9
	Packed, 9-element vector of float values. More...
typedef Mat< 1, 1, float >	fMat11
	1x1 float matrix, that is, a scalar. More...
typedef Mat< 2, 2, float >	fMat22
	2x2 float matrix, packed by columns. More...
typedef Mat< 3, 3, float >	fMat33
	3x3 float matrix, packed by columns. More...
typedef Mat< 3, 4, float >	fMat34
	3x4 float matrix, packed by columns. More...
typedef Mat< 4, 3, float >	fMat43
	4x3 float matrix, packed by columns. More...
typedef Mat< 4, 4, float >	fMat44
	4x4 float matrix, packed by columns. More...
typedef Mat< 5, 5, float >	fMat55
	5x5 float matrix, packed by columns. More...
typedef Mat< 6, 6, float >	fMat66
	6x6 float matrix, packed by columns. More...
typedef Mat< 7, 7, float >	fMat77
	7x7 float matrix, packed by columns. More...
typedef Mat< 8, 8, float >	fMat88
	8x8 float matrix, packed by columns. More...
typedef Mat< 9, 9, float >	fMat99
	9x9 float matrix, packed by columns. More...
typedef SymMat< 1, float >	fSymMat11
	A 1x1 float symmetric matrix, that is, a scalar. More...
typedef SymMat< 2, float >	fSymMat22
	2x2 compact float symmetric matrix. More...
typedef SymMat< 3, float >	fSymMat33
	3x3 compact float symmetric matrix. More...
typedef SymMat< 4, float >	fSymMat44
	4x4 compact float symmetric matrix. More...
typedef SymMat< 5, float >	fSymMat55
	5x5 compact float symmetric matrix. More...
typedef SymMat< 6, float >	fSymMat66
	6x6 compact float symmetric matrix. More...
typedef SymMat< 7, float >	fSymMat77
	7x7 compact float symmetric matrix. More...
typedef SymMat< 8, float >	fSymMat88
	8x8 compact float symmetric matrix. More...
typedef SymMat< 9, float >	fSymMat99
	9x9 compact float symmetric matrix. More...
typedef Row< 1, float >	fRow1
	A row vector of one float element (not too useful). More...
typedef Row< 2, float >	fRow2
	Packed, 2-element row vector of float values. More...
typedef Row< 3, float >	fRow3
	Packed, 3-element row vector of float values. More...
typedef Row< 4, float >	fRow4
	Packed, 4-element row vector of float values. More...
typedef Row< 5, float >	fRow5
	Packed, 5-element row vector of float values. More...
typedef Row< 6, float >	fRow6
	Packed, 6-element row vector of float values. More...
typedef Row< 7, float >	fRow7
	Packed, 7-element row vector of float values. More...
typedef Row< 8, float >	fRow8
	Packed, 8-element row vector of float values. More...
typedef Row< 9, float >	fRow9
	Packed, 9-element row vector of float values. More...
typedef Spline_< Real >	Spline
	Provide a convenient name for a scalar-valued Spline_. More...
typedef Vector_< Real >	Vector
	Variable-size column vector of Real elements; abbreviation for Vector_<Real>. More...
typedef Matrix_< Real >	Matrix
	Variable-size 2D matrix of Real elements; abbreviation for Matrix_<Real>. More...
typedef RowVector_< Real >	RowVector
	Variable-size row vector of Real elements; abbreviation for RowVector_<Real>. More...
typedef Vector_< Complex >	ComplexVector
	Variable-size column vector of Complex (std::complex<Real>) elements. More...
typedef Matrix_< Complex >	ComplexMatrix
	Variable-size 2D matrix of Complex (std::complex<Real>) elements. More...
typedef RowVector_< Complex >	ComplexRowVector
	Variable-size row vector of Complex (std::complex<Real>) elements. More...
typedef VectorView_< Real >	VectorView
	Non-owner column vector sharing Real elements. More...
typedef MatrixView_< Real >	MatrixView
	Non-owner matrix sharing Real elements. More...
typedef RowVectorView_< Real >	RowVectorView
	Non-owner row vector sharing Real elements. More...
typedef VectorView_< Complex >	ComplexVectorView
	Non-owner column vector sharing Complex (std::complex<Real>) elements. More...
typedef MatrixView_< Complex >	ComplexMatrixView
	Non-owner matrix sharing Complex (std::complex<Real>) elements. More...
typedef RowVectorView_< Complex >	ComplexRowVectorView
	Non-owner row vector sharing Complex (std::complex<Real>) elements. More...
typedef Vector_< float >	fVector
	Abbreviation for Vector_<float>. More...
typedef Vector_< double >	dVector
	Abbreviation for Vector_<double>. More...
typedef Vector_< fComplex >	fComplexVector
	Abbreviation for Vector_<std::complex<float>>. More...
typedef Vector_< dComplex >	dComplexVector
	Abbreviation for Vector_<std::complex<double>>. More...
typedef VectorView_< float >	fVectorView
	Abbreviation for VectorView_<float>. More...
typedef VectorView_< double >	dVectorView
	Abbreviation for VectorView_<double>. More...
typedef VectorView_< fComplex >	fComplexVectorView
	Abbreviation for VectorView_<std::complex<float>>. More...
typedef VectorView_< dComplex >	dComplexVectorView
	Abbreviation for VectorView_<std::complex<double>>. More...
typedef RowVector_< float >	fRowVector
	Abbreviation for RowVector_<float>. More...
typedef RowVector_< double >	dRowVector
	Abbreviation for RowVector_<double>. More...
typedef RowVector_< fComplex >	fComplexRowVector
	Abbreviation for RowVector_<std::complex<float>>. More...
typedef RowVector_< dComplex >	dComplexRowVector
	Abbreviation for RowVector_<std::complex<double>>. More...
typedef RowVectorView_< float >	fRowVectorView
	Abbreviation for RowVectorView_<float>. More...
typedef RowVectorView_< double >	dRowVectorView
	Abbreviation for RowVectorView_<double>. More...
typedef RowVectorView_< fComplex >	fComplexRowVectorView
	Abbreviation for RowVectorView_<std::complex<float>>. More...
typedef RowVectorView_< dComplex >	dComplexRowVectorView
	Abbreviation for RowVectorView_<std::complex<double>>. More...
typedef Matrix_< float >	fMatrix
	Abbreviation for Matrix_<float>. More...
typedef Matrix_< double >	dMatrix
	Abbreviation for Matrix_<double>. More...
typedef Matrix_< fComplex >	fComplexMatrix
	Abbreviation for Matrix_<std::complex<float>>. More...
typedef Matrix_< dComplex >	dComplexMatrix
	Abbreviation for Matrix_<std::complex<double>>. More...
typedef MatrixView_< float >	fMatrixView
	Abbreviation for MatrixView_<float>. More...
typedef MatrixView_< double >	dMatrixView
	Abbreviation for MatrixView_<double>. More...
typedef MatrixView_< fComplex >	fComplexMatrixView
	Abbreviation for MatrixView_<std::complex<float>>. More...
typedef MatrixView_< dComplex >	dComplexMatrixView
	Abbreviation for MatrixView_<std::complex<double>>. More...

Enumerations
enum class	CableSpanAlgorithm {   Scholz2015 ,   MinimumLength }
enum	BodyOrSpaceType {   BodyRotationSequence =0 ,   SpaceRotationSequence =1 }
enum	{   SCALAR_DEPTH = 0 ,   SCALAR_COMPOSITE_DEPTH = 1 ,   COMPOSITE_COMPOSITE_DEPTH = 2 ,   COMPOSITE_3_DEPTH = 3 ,   MAX_RESOLVED_DEPTH = COMPOSITE_3_DEPTH }
enum	OptimizerAlgorithm {   BestAvailable = 0 ,   InteriorPoint = 1 ,   LBFGS = 2 ,   LBFGSB = 3 ,   CFSQP = 4 ,   CMAES = 5 ,   UnknownOptimizerAlgorithm = 6 ,   UserSuppliedOptimizerAlgorithm = 7 }
	The available Optimizer algorithms. More...

Functions
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (AssemblyConditionIndex)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (CableObstacleIndex)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (CableSpanObstacleIndex)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (CableSpanIndex)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (CablePathIndex)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (MobilizedBodyIndex)
static const MobilizedBodyIndex	GroundIndex (0)
	This is the MobilizedBodyIndex corresponding to the unique Ground body; its index is always zero. More...
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (ConstraintIndex)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (UnilateralContactIndex)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (UnilateralSpeedConstraintIndex)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (BoundedSpeedConstraintIndex)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (ConstraintLimitedFrictionIndex)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (StateLimitedFrictionIndex)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (ParticleIndex)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (AncestorConstrainedBodyPoolIndex)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (USquaredIndex)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (QuaternionPoolIndex)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (MobodQPoolIndex)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (PresQPoolIndex)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (PresUPoolIndex)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (PresUDotPoolIndex)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (PresForcePoolIndex)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (MobilizerQIndex)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (MobilizerUIndex)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (ConstrainedBodyIndex)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (ConstrainedMobilizerIndex)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (ConstrainedQIndex)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (ConstrainedUIndex)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (ParticipatingQIndex)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (ParticipatingUIndex)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (SubtreeBodyIndex)
static const SubtreeBodyIndex	SubtreeAncestorIndex (0)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (SubtreeQIndex)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (SubtreeUIndex)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (ForceIndex)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (ContactSetIndex)
std::ostream &	operator<< (std::ostream &o, const ContactForce &f)
std::ostream &	operator<< (std::ostream &o, const ContactDetail &d)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (ContactCliqueId)
std::ostream &	operator<< (std::ostream &o, const ContactSnapshot &cs)
std::ostream &	operator<< (std::ostream &, const SimbodyMatterSubtree &)
std::ostream &	operator<< (std::ostream &, const SimbodyMatterSubtreeResults &)
template<class T >
static std::istream &	readVectorFromStreamHelper (std::istream &in, bool isFixedSize, Vector_< T > &out)
template<class T , class X >
static std::istream &	readArrayFromStreamHelper (std::istream &in, bool isFixedSize, Array_< T, X > &out)
bool	canStoreInInt (bool)
bool	canStoreInInt (char)
bool	canStoreInInt (unsigned char)
bool	canStoreInInt (signed char)
bool	canStoreInInt (short)
bool	canStoreInInt (unsigned short)
bool	canStoreInInt (int)
bool	canStoreInInt (unsigned int u)
bool	canStoreInInt (long i)
bool	canStoreInInt (unsigned long u)
bool	canStoreInInt (long long i)
bool	canStoreInInt (unsigned long long u)
bool	canStoreInNonnegativeInt (bool)
bool	canStoreInNonnegativeInt (char c)
bool	canStoreInNonnegativeInt (unsigned char)
bool	canStoreInNonnegativeInt (signed char c)
bool	canStoreInNonnegativeInt (short s)
bool	canStoreInNonnegativeInt (unsigned short)
bool	canStoreInNonnegativeInt (int i)
bool	canStoreInNonnegativeInt (long l)
bool	canStoreInNonnegativeInt (long long l)
bool	canStoreInNonnegativeInt (unsigned int u)
bool	canStoreInNonnegativeInt (unsigned long u)
bool	canStoreInNonnegativeInt (unsigned long long u)
bool	isSizeInRange (char sz, char mx)
bool	isSizeInRange (signed char sz, signed char mx)
bool	isSizeInRange (short sz, short mx)
bool	isSizeInRange (int sz, int mx)
bool	isSizeInRange (long sz, long mx)
bool	isSizeInRange (long long sz, long long mx)
bool	isSizeInRange (unsigned char sz, unsigned char mx)
bool	isSizeInRange (unsigned short sz, unsigned short mx)
bool	isSizeInRange (unsigned int sz, unsigned int mx)
bool	isSizeInRange (unsigned long sz, unsigned long mx)
bool	isSizeInRange (unsigned long long sz, unsigned long long mx)
bool	isIndexInRange (char ix, char sz)
bool	isIndexInRange (signed char ix, signed char sz)
bool	isIndexInRange (short ix, short sz)
bool	isIndexInRange (int ix, int sz)
bool	isIndexInRange (long ix, long sz)
bool	isIndexInRange (long long ix, long long sz)
bool	isIndexInRange (unsigned char ix, unsigned char sz)
bool	isIndexInRange (unsigned short ix, unsigned short sz)
bool	isIndexInRange (unsigned int ix, unsigned int sz)
bool	isIndexInRange (unsigned long ix, unsigned long sz)
bool	isIndexInRange (unsigned long long ix, unsigned long long sz)
bool	isNonnegative (bool)
bool	isNonnegative (char n)
bool	isNonnegative (signed char n)
bool	isNonnegative (short n)
bool	isNonnegative (int n)
bool	isNonnegative (long n)
bool	isNonnegative (long long n)
bool	isNonnegative (unsigned char)
bool	isNonnegative (unsigned short)
bool	isNonnegative (unsigned int)
bool	isNonnegative (unsigned long)
bool	isNonnegative (unsigned long long)
template<class L , class R >
bool	operator!= (const L &left, const R &right)
template<class L , class R >
bool	operator> (const L &left, const R &right)
template<class L , class R >
bool	operator<= (const L &left, const R &right)
template<class L , class R >
bool	operator>= (const L &left, const R &right)
	SimTK_SPECIALIZE_INTEGRAL_TYPE (bool)
	SimTK_SPECIALIZE_INTEGRAL_TYPE (char)
	SimTK_SPECIALIZE_INTEGRAL_TYPE (signed char)
	SimTK_SPECIALIZE_INTEGRAL_TYPE (unsigned char)
	SimTK_SPECIALIZE_INTEGRAL_TYPE (short)
	SimTK_SPECIALIZE_INTEGRAL_TYPE (unsigned short)
	SimTK_SPECIALIZE_INTEGRAL_TYPE (int)
	SimTK_SPECIALIZE_INTEGRAL_TYPE (unsigned int)
	SimTK_SPECIALIZE_INTEGRAL_TYPE (long)
	SimTK_SPECIALIZE_INTEGRAL_TYPE (unsigned long)
	SimTK_SPECIALIZE_INTEGRAL_TYPE (long long)
	SimTK_SPECIALIZE_INTEGRAL_TYPE (unsigned long long)
	SimTK_SPECIALIZE_FLOATING_TYPE (float)
	SimTK_SPECIALIZE_FLOATING_TYPE (double)
constexpr bool	detect64BitPlatform ()
	Compile-time test: this typedef will be TrueType if this is a 64-bit platform, meaning that the size of a pointer is the same as the size of a long long; otherwise it will be FalseType and we have a 32-bit platform meaning that the size of a pointer is the same as an int. More...
template<class H , class IMPL , bool PTR>
std::ostream &	operator<< (std::ostream &o, const PIMPLHandle< H, IMPL, PTR > &h)
template<class HANDLE , class IMPL , bool PTR>
std::ostream &	operator<< (std::ostream &o, const PIMPLHandle< HANDLE, IMPL, PTR > &h)
template<class T >
void	writeUnformatted (std::ostream &o, const T &v)
	The default implementation of writeUnformatted<T> converts the object to a String using the templatized String constructor, and then writes that string to the stream using String::operator<<(). More...
template<class T >
void	writeUnformatted (std::ostream &o, const negator< T > &v)
	Partial specialization for SimTK::negator<T>: convert to T and write. More...
template<class T >
void	writeUnformatted (std::ostream &o, const std::complex< T > &v)
	Partial specialization for std::complex<T>: just write two T's separated by a space; no parentheses or comma. More...
template<class T >
void	writeUnformatted (std::ostream &o, const conjugate< T > &v)
	Partial specialization for SimTK::conjugate<T>: same as std::complex<T>. More...
bool	readOneTokenUnformatted (std::istream &in, String &token)
	Read in the next whitespace-delimited token as a String, ignoring leading whitespace. More...
template<class T >
bool	readUnformatted (std::istream &in, T &v)
	The default implementation of readUnformatted<T> reads in the next whitespace-separated token and then attempts to convert the whole thing into one value of type T. More...
template<class T >
bool	readUnformatted (std::istream &in, negator< T > &v)
	Specialization for negator<T>: read as type T and convert. More...
template<class T >
bool	readUnformatted (std::istream &in, std::complex< T > &v)
	Specialization for std::complex<T> (two space-separated T's). More...
template<class T >
bool	readUnformatted (std::istream &in, conjugate< T > &v)
	Specialization for SimTK::conjugate<T> (same as std::complex<T>). More...
template<>
bool	readUnformatted< String > (std::istream &in, String &v)
	Specialization for SimTK::String (just read token). More...
template<class T >
void	writeFormatted (std::ostream &o, const T &v)
	The default implementation of writeFormatted<T> converts the object to a String using the templatized String constructor, and then writes that string to the stream using String::operator<<(). More...
template<class T >
bool	readFormatted (std::istream &in, T &v)
	The default implementation of readFormatted<T>() uses readUnformatted<T>(). More...
template<class T >
static bool	tryConvertStringTo (const String &value, T &out)
template<>
bool	tryConvertStringTo (const String &value, bool &out)
template<>
bool	tryConvertStringTo (const String &value, float &out)
template<>
bool	tryConvertStringTo (const String &value, double &out)
template<>
bool	tryConvertStringTo (const String &value, String &out)
template<>
bool	tryConvertStringTo (const String &value, std::string &out)
template<class T >
bool	tryConvertStringTo (const String &value, negator< T > &out)
	Partial specialization to read negator<T> as a T. More...
template<class T >
bool	tryConvertStringTo (const String &value, conjugate< T > &out)
	Partial specialization to read conjugate<T> as a std::complex<T>. More...
template<class T >
static bool	tryConvertStringTo (const String &value, T *&out)
long long	timespecToNs (const timespec &ts)
	Convert a time stored in a timespec struct to the equivalent number of nanoseconds (as a signed quantity). More...
void	nsToTimespec (const long long &ns, timespec &ts)
	Given a signed number of nanoseconds, convert that into seconds and leftover nanoseconds in a timespec struct. More...
double	nsToSec (const long long &ns)
	Given a count of nanosecond ticks as a signed 64 bit integer, return the same time interval as a double precision floating point number of seconds. More...
long long	secToNs (const double &s)
	Given a signed time interval as a double precision floating point number of seconds, return the same time interval as a count of nanosecond ticks in a signed 64 bit integer. More...
double	cpuTime ()
	Return the cumulative CPU time in seconds (both kernel and user time) that has been used so far by any of the threads in the currently executing process. More...
double	threadCpuTime ()
	Return the total CPU time in seconds (both kernel and user time) that has been used so far by the currently executing thread. More...
long long	realTimeInNs ()
	Return current time on the high-resolution interval timer in nanoseconds, as a 64-bit integer count. More...
double	realTime ()
	Return current time on the high-resolution interval timer in seconds. More...
void	sleepInNs (const long long &ns)
	Sleep for the indicated number of nanoseconds, with the actual precision system dependent but intended to be the best achievable, hopefully less than 5ms in all cases. More...
void	sleepInSec (const double &seconds)
	Sleep for the indicated number of seconds, with the actual precision system dependent but intended to be the best achievable, hopefully less than 5ms in all cases. More...
	SimTK_ELEMENTWISE_FUNCTION (exp) SimTK_ELEMENTWISE_FUNCTION(log) SimTK_ELEMENTWISE_FUNCTION(sqrt) SimTK_ELEMENTWISE_FUNCTION(sin) SimTK_ELEMENTWISE_FUNCTION(cos) SimTK_ELEMENTWISE_FUNCTION(tan) SimTK_ELEMENTWISE_FUNCTION(asin) SimTK_ELEMENTWISE_FUNCTION(acos) SimTK_ELEMENTWISE_FUNCTION(atan) SimTK_ELEMENTWISE_FUNCTION(sinh) SimTK_ELEMENTWISE_FUNCTION(cosh) SimTK_ELEMENTWISE_FUNCTION(tanh) template< class ELEM > VectorBase< typename CNT< ELEM >
template<class ELEM >
RowVectorBase< typename CNT< ELEM >::TAbs >	abs (const RowVectorBase< ELEM > &v)
template<class ELEM >
MatrixBase< typename CNT< ELEM >::TAbs >	abs (const MatrixBase< ELEM > &v)
template<int N, class ELEM >
Vec< N, typename CNT< ELEM >::TAbs >	abs (const Vec< N, ELEM > &v)
template<int N, class ELEM >
Row< N, typename CNT< ELEM >::TAbs >	abs (const Row< N, ELEM > &v)
template<int M, int N, class ELEM >
Mat< M, N, typename CNT< ELEM >::TAbs >	abs (const Mat< M, N, ELEM > &v)
template<int N, class ELEM >
SymMat< N, typename CNT< ELEM >::TAbs >	abs (const SymMat< N, ELEM > &v)
template<class ELEM >
ELEM	sum (const VectorBase< ELEM > &v)
template<class ELEM >
ELEM	sum (const RowVectorBase< ELEM > &v)
template<class ELEM >
RowVectorBase< ELEM >	sum (const MatrixBase< ELEM > &v)
template<int N, class ELEM >
ELEM	sum (const Vec< N, ELEM > &v)
template<int N, class ELEM >
ELEM	sum (const Row< N, ELEM > &v)
template<int M, int N, class ELEM >
Row< N, ELEM >	sum (const Mat< M, N, ELEM > &v)
template<int N, class ELEM >
Row< N, ELEM >	sum (const SymMat< N, ELEM > &v)
template<class ELEM >
ELEM	min (const VectorBase< ELEM > &v)
template<class ELEM >
ELEM	min (const RowVectorBase< ELEM > &v)
template<class ELEM >
RowVectorBase< ELEM >	min (const MatrixBase< ELEM > &v)
template<int N, class ELEM >
ELEM	min (const Vec< N, ELEM > &v)
template<int N, class ELEM >
ELEM	min (const Row< N, ELEM > &v)
template<int M, int N, class ELEM >
Row< N, ELEM >	min (const Mat< M, N, ELEM > &v)
template<int N, class ELEM >
Row< N, ELEM >	min (const SymMat< N, ELEM > &v)
template<class ELEM >
ELEM	max (const VectorBase< ELEM > &v)
template<class ELEM >
ELEM	max (const RowVectorBase< ELEM > &v)
template<class ELEM >
RowVectorBase< ELEM >	max (const MatrixBase< ELEM > &v)
template<int N, class ELEM >
ELEM	max (const Vec< N, ELEM > &v)
template<int N, class ELEM >
ELEM	max (const Row< N, ELEM > &v)
template<int M, int N, class ELEM >
Row< N, ELEM >	max (const Mat< M, N, ELEM > &v)
template<int N, class ELEM >
Row< N, ELEM >	max (const SymMat< N, ELEM > &v)
template<class ELEM >
ELEM	mean (const VectorBase< ELEM > &v)
template<class ELEM >
ELEM	mean (const RowVectorBase< ELEM > &v)
template<class ELEM >
RowVectorBase< ELEM >	mean (const MatrixBase< ELEM > &v)
template<int N, class ELEM >
ELEM	mean (const Vec< N, ELEM > &v)
template<int N, class ELEM >
ELEM	mean (const Row< N, ELEM > &v)
template<int M, int N, class ELEM >
Row< N, ELEM >	mean (const Mat< M, N, ELEM > &v)
template<int N, class ELEM >
Row< N, ELEM >	mean (const SymMat< N, ELEM > &v)
template<class ELEM >
VectorBase< ELEM >	sort (const VectorBase< ELEM > &v)
template<class ELEM >
RowVectorBase< ELEM >	sort (const RowVectorBase< ELEM > &v)
template<class ELEM >
MatrixBase< ELEM >	sort (const MatrixBase< ELEM > &v)
template<int N, class ELEM >
Vec< N, ELEM >	sort (Vec< N, ELEM > v)
template<int N, class ELEM >
Row< N, ELEM >	sort (Row< N, ELEM > v)
template<int M, int N, class ELEM >
Mat< M, N, ELEM >	sort (Mat< M, N, ELEM > v)
template<int N, class ELEM >
Mat< N, N, ELEM >	sort (const SymMat< N, ELEM > &v)
template<class ELEM , class RandomAccessIterator >
ELEM	median (RandomAccessIterator start, RandomAccessIterator end)
template<class ELEM >
ELEM	median (const VectorBase< ELEM > &v)
template<class ELEM >
ELEM	median (const RowVectorBase< ELEM > &v)
template<class ELEM >
RowVectorBase< ELEM >	median (const MatrixBase< ELEM > &v)
template<int N, class ELEM >
ELEM	median (Vec< N, ELEM > v)
template<int N, class ELEM >
ELEM	median (Row< N, ELEM > v)
template<int M, int N, class ELEM >
Row< N, ELEM >	median (const Mat< M, N, ELEM > &v)
template<int N, class ELEM >
Row< N, ELEM >	median (const SymMat< N, ELEM > &v)
template<class P >
std::ostream &	operator<< (std::ostream &, const Rotation_< P > &)
	Write a Rotation matrix to an output stream by writing out its underlying Mat33. More...
template<class P >
std::ostream &	operator<< (std::ostream &, const InverseRotation_< P > &)
	Write an InverseRotation matrix to an output stream by writing out its underlying Mat33. More...
template<class P , int S>
UnitVec< P, 1 >	operator* (const Rotation_< P > &R, const UnitVec< P, S > &v)
	Rotating a unit vector leaves it unit length, saving us from having to perform an expensive normalization. More...
template<class P , int S>
UnitRow< P, 1 >	operator* (const UnitRow< P, S > &r, const Rotation_< P > &R)
template<class P , int S>
UnitVec< P, 1 >	operator* (const InverseRotation_< P > &R, const UnitVec< P, S > &v)
template<class P , int S>
UnitRow< P, 1 >	operator* (const UnitRow< P, S > &r, const InverseRotation_< P > &R)
template<class P >
Rotation_< P >	operator* (const Rotation_< P > &R1, const Rotation_< P > &R2)
	Composition of Rotation matrices via operator*. More...
template<class P >
Rotation_< P >	operator* (const Rotation_< P > &R1, const InverseRotation_< P > &R2)
template<class P >
Rotation_< P >	operator* (const InverseRotation_< P > &R1, const Rotation_< P > &R2)
template<class P >
Rotation_< P >	operator* (const InverseRotation_< P > &R1, const InverseRotation_< P > &R2)
template<class P >
Rotation_< P >	operator/ (const Rotation_< P > &R1, const Rotation_< P > &R2)
	Composition of a Rotation matrix and the inverse of another Rotation via operator/, that is R1/R2 == R1*(~R2). More...
template<class P >
Rotation_< P >	operator/ (const Rotation_< P > &R1, const InverseRotation &R2)
template<class P >
Rotation_< P >	operator/ (const InverseRotation_< P > &R1, const Rotation_< P > &R2)
template<class P >
Rotation_< P >	operator/ (const InverseRotation_< P > &R1, const InverseRotation_< P > &R2)
SpatialVec	findRelativeVelocity (const Transform &X_FA, const SpatialVec &V_FA, const Transform &X_FB, const SpatialVec &V_FB)
	Find the relative spatial velocity between two frames A and B whose individual spatial velocities are known with respect to a third frame F, with the result returned in A. More...
SpatialVec	findRelativeVelocityInF (const Vec3 &p_AB_F, const SpatialVec &V_FA, const SpatialVec &V_FB)
	Find the relative spatial velocity between two frames A and B whose individual spatial velocities are known in a third frame F, but leave the result in F. More...
SpatialVec	findRelativeAcceleration (const Transform &X_FA, const SpatialVec &V_FA, const SpatialVec &A_FA, const Transform &X_FB, const SpatialVec &V_FB, const SpatialVec &A_FB)
	Find the relative spatial acceleration between two frames A and B whose individual spatial accelerations are known with respect to a third frame F, with the result returned in A. More...
SpatialVec	findRelativeAccelerationInF (const Vec3 &p_AB_F, const SpatialVec &V_FA, const SpatialVec &A_FA, const SpatialVec &V_FB, const SpatialVec &A_FB)
	Find the relative spatial acceleration between two frames A and B whose individual spatial acceleration are known in a third frame F, but leave the result in F. More...
SpatialVec	reverseRelativeVelocity (const Transform &X_AB, const SpatialVec &V_AB)
	Given the relative velocity of frame B in frame A, reverse that to give the relative velocity of frame A in B. More...
SpatialVec	reverseRelativeVelocityInA (const Transform &X_AB, const SpatialVec &V_AB)
	Given the relative velocity of frame B in frame A, reverse that to give the relative velocity of frame A in B, but leave the result expressed in frame A. More...
SpatialVec	shiftVelocityBy (const SpatialVec &V_AB, const Vec3 &r_A)
	Shift a relative spatial velocity measured at some point to that same relative spatial quantity but measured at a new point given by an offset from the old one. More...
SpatialVec	shiftVelocityFromTo (const SpatialVec &V_A_BP, const Vec3 &fromP_A, const Vec3 &toQ_A)
	Shift a relative spatial velocity measured at some point P to that same relative spatial quantity but measured at a new point Q given the points P and Q. More...
SpatialVec	shiftForceBy (const SpatialVec &F_AP, const Vec3 &r_A)
	Shift a spatial force applied at some point of a body to that same spatial force applied at a new point given by an offset from the old one. More...
SpatialVec	shiftForceFromTo (const SpatialVec &F_AP, const Vec3 &fromP_A, const Vec3 &toQ_A)
	Shift a spatial force applied at some point P of a body to that same spatial force applied at a new point Q, given P and Q. More...
SpatialVec	shiftAccelerationBy (const SpatialVec &A_AB, const Vec3 &w_AB, const Vec3 &r_A)
	Shift a relative spatial acceleration measured at some point to that same relative spatial quantity but measured at a new point given by an offset from the old one. More...
SpatialVec	shiftAccelerationFromTo (const SpatialVec &A_A_BP, const Vec3 &w_AB, const Vec3 &fromP_A, const Vec3 &toQ_A)
	Shift a relative spatial acceleration measured at some point P to that same relative spatial quantity but measured at a new point Q given the points P and Q. More...
PhiMatrixTranspose	transpose (const PhiMatrix &phi)
PhiMatrixTranspose	operator~ (const PhiMatrix &phi)
SpatialVec	operator* (const PhiMatrix &phi, const SpatialVec &v)
SpatialMat	operator* (const PhiMatrix &phi, const SpatialMat &m)
SpatialMat	operator* (const SpatialMat &m, const PhiMatrix &phi)
SpatialVec	operator* (const PhiMatrixTranspose &phiT, const SpatialVec &v)
SpatialMat	operator* (const PhiMatrixTranspose &phiT, const SpatialMat &m)
SpatialMat	operator* (const SpatialMat::THerm &m, const PhiMatrixTranspose &phiT)
SpatialMat	operator* (const SpatialMat &m, const PhiMatrixTranspose &phiT)
bool	operator== (const PhiMatrix &p1, const PhiMatrix &p2)
bool	operator== (const PhiMatrixTranspose &p1, const PhiMatrixTranspose &p2)
template<class P , int S>
Vec< 3, P >	operator* (const InverseTransform_< P > &X_BF, const Vec< 3, P, S > &s_F)
template<class P , int S>
Vec< 3, P >	operator* (const Transform_< P > &X_BF, const Vec< 3, negator< P >, S > &s_F)
template<class P , int S>
Vec< 3, P >	operator* (const InverseTransform_< P > &X_BF, const Vec< 3, negator< P >, S > &s_F)
template<class P , int S>
Vec< 4, P >	operator* (const InverseTransform_< P > &X_BF, const Vec< 4, P, S > &a_F)
template<class P , int S>
Vec< 4, P >	operator* (const Transform_< P > &X_BF, const Vec< 4, negator< P >, S > &s_F)
template<class P , int S>
Vec< 4, P >	operator* (const InverseTransform_< P > &X_BF, const Vec< 4, negator< P >, S > &s_F)
template<class P , class E >
Vector_< E >	operator* (const VectorBase< E > &v, const Transform_< P > &X)
template<class P , class E >
RowVector_< E >	operator* (const Transform_< P > &X, const RowVectorBase< E > &v)
template<class P , class E >
RowVector_< E >	operator* (const RowVectorBase< E > &v, const Transform_< P > &X)
template<class P , class E >
Matrix_< E >	operator* (const Transform_< P > &X, const MatrixBase< E > &v)
template<class P , class E >
Matrix_< E >	operator* (const MatrixBase< E > &v, const Transform_< P > &X)
template<class P , int N, class E , int S>
Vec< N, E >	operator* (const Transform_< P > &X, const Vec< N, E, S > &v)
template<class P , int N, class E , int S>
Vec< N, E >	operator* (const Vec< N, E, S > &v, const Transform_< P > &X)
template<class P , int N, class E , int S>
Row< N, E >	operator* (const Transform_< P > &X, const Row< N, E, S > &v)
template<class P , int N, class E , int S>
Row< N, E >	operator* (const Row< N, E, S > &v, const Transform_< P > &X)
template<class P , int M, int N, class E , int CS, int RS>
Mat< M, N, E >	operator* (const Transform_< P > &X, const Mat< M, N, E, CS, RS > &v)
template<class P , int M, int N, class E , int CS, int RS>
Mat< M, N, E >	operator* (const Mat< M, N, E, CS, RS > &v, const Transform_< P > &X)
template<class P >
Transform_< P >	operator* (const Transform_< P > &X1, const InverseTransform_< P > &X2)
template<class P >
Transform_< P >	operator* (const InverseTransform_< P > &X1, const Transform_< P > &X2)
template<class P >
Transform_< P >	operator* (const InverseTransform_< P > &X1, const InverseTransform_< P > &X2)
template<class P >
bool	operator== (const InverseTransform_< P > &X1, const InverseTransform_< P > &X2)
template<class P >
bool	operator== (const Transform_< P > &X1, const InverseTransform_< P > &X2)
template<class P >
bool	operator== (const InverseTransform_< P > &X1, const Transform_< P > &X2)
static Real	convertRadiansToDegrees (const Real rad)
static Real	convertDegreesToRadians (const Real deg)
complex< float >	operator* (const complex< float > &c, int r)
complex< float >	operator* (int r, const complex< float > &c)
complex< double >	operator* (const complex< float > &c, const double &r)
complex< double >	operator* (const double &r, const complex< float > &c)
complex< float >	operator/ (const complex< float > &c, int r)
complex< float >	operator/ (int r, const complex< float > &c)
complex< double >	operator/ (const complex< float > &c, const double &r)
complex< double >	operator/ (const double &r, const complex< float > &c)
complex< float >	operator+ (const complex< float > &c, int r)
complex< float >	operator+ (int r, const complex< float > &c)
complex< double >	operator+ (const complex< float > &c, const double &r)
complex< double >	operator+ (const double &r, const complex< float > &c)
complex< float >	operator- (const complex< float > &c, int r)
complex< float >	operator- (int r, const complex< float > &c)
complex< double >	operator- (const complex< float > &c, const double &r)
complex< double >	operator- (const double &r, const complex< float > &c)
complex< double >	operator* (const complex< double > &c, int r)
complex< double >	operator* (int r, const complex< double > &c)
complex< double >	operator* (const complex< double > &c, const float &r)
complex< double >	operator* (const float &r, const complex< double > &c)
complex< double >	operator/ (const complex< double > &c, int r)
complex< double >	operator/ (int r, const complex< double > &c)
complex< double >	operator/ (const complex< double > &c, const float &r)
complex< double >	operator/ (const float &r, const complex< double > &c)
complex< double >	operator+ (const complex< double > &c, int r)
complex< double >	operator+ (int r, const complex< double > &c)
complex< double >	operator+ (const complex< double > &c, const float &r)
complex< double >	operator+ (const float &r, const complex< double > &c)
complex< double >	operator- (const complex< double > &c, int r)
complex< double >	operator- (int r, const complex< double > &c)
complex< double >	operator- (const complex< double > &c, const float &r)
complex< double >	operator- (const float &r, const complex< double > &c)
const float &	real (const conjugate< float > &c)
const negator< float > &	imag (const conjugate< float > &c)
const complex< float > &	conj (const conjugate< float > &c)
float	abs (const conjugate< float > &c)
float	norm (const conjugate< float > &c)
const double &	real (const conjugate< double > &c)
const negator< double > &	imag (const conjugate< double > &c)
const complex< double > &	conj (const conjugate< double > &c)
double	abs (const conjugate< double > &c)
double	norm (const conjugate< double > &c)
template<class R , class CHAR , class TRAITS >
std::basic_istream< CHAR, TRAITS > &	operator>> (std::basic_istream< CHAR, TRAITS > &is, conjugate< R > &c)
template<class R , class CHAR , class TRAITS >
std::basic_ostream< CHAR, TRAITS > &	operator<< (std::basic_ostream< CHAR, TRAITS > &os, const conjugate< R > &c)
template<class R >
conjugate< R >	operator+ (const conjugate< R > &a, const float &b)
template<class R >
Wider< R, double >::WConj	operator+ (const conjugate< R > &a, const double &b)
template<class R >
conjugate< R >	operator+ (const float &a, const conjugate< R > &b)
template<class R >
Wider< R, double >::WConj	operator+ (const double &a, const conjugate< R > &b)
template<class R >
conjugate< R >	operator* (const conjugate< R > &a, const float &b)
template<class R >
Wider< R, double >::WConj	operator* (const conjugate< R > &a, const double &b)
template<class R >
conjugate< R >	operator* (const float &a, const conjugate< R > &b)
template<class R >
Wider< R, double >::WConj	operator* (const double &a, const conjugate< R > &b)
template<class R >
bool	operator== (const conjugate< R > &a, const float &b)
template<class R >
bool	operator== (const conjugate< R > &a, const double &b)
template<class R >
bool	operator== (const float &a, const conjugate< R > &b)
template<class R >
bool	operator== (const double &a, const conjugate< R > &b)
template<class R >
bool	operator!= (const conjugate< R > &a, const float &b)
template<class R >
bool	operator!= (const conjugate< R > &a, const double &b)
template<class R >
bool	operator!= (const float &a, const conjugate< R > &b)
template<class R >
bool	operator!= (const double &a, const conjugate< R > &b)
template<class R >
conjugate< R >	operator- (const conjugate< R > &a, const float &b)
template<class R >
Wider< R, double >::WConj	operator- (const conjugate< R > &a, const double &b)
template<class R >
complex< R >	operator- (const float &a, const conjugate< R > &b)
template<class R >
Wider< R, double >::WCplx	operator- (const double &a, const conjugate< R > &b)
template<class R >
conjugate< R >	operator/ (const conjugate< R > &a, const float &b)
template<class R >
Wider< R, double >::WConj	operator/ (const conjugate< R > &a, const double &b)
template<class R >
complex< R >	operator/ (const float &a, const conjugate< R > &b)
template<class R >
Wider< R, double >::WCplx	operator/ (const double &a, const conjugate< R > &b)
template<class R , class S >
Wider< R, S >::WConj	operator+ (const conjugate< R > &a, const conjugate< S > &r)
template<class R , class S >
Wider< R, S >::WCplx	operator+ (const conjugate< R > &a, const complex< S > &r)
template<class R , class S >
Wider< R, S >::WCplx	operator+ (const complex< R > &a, const conjugate< S > &r)
template<class R , class S >
Wider< R, S >::WCplx	operator- (const conjugate< R > &a, const conjugate< S > &r)
template<class R , class S >
negator< typename Wider< R, S >::WCplx >	operator- (const conjugate< R > &a, const complex< S > &r)
template<class R , class S >
Wider< R, S >::WCplx	operator- (const complex< R > &a, const conjugate< S > &r)
template<class R , class S >
negator< typename Wider< R, S >::WCplx >	operator* (const conjugate< R > &a, const conjugate< S > &r)
template<class R , class S >
Wider< R, S >::WCplx	operator* (const conjugate< R > &a, const complex< S > &r)
template<class R , class S >
Wider< R, S >::WCplx	operator* (const complex< R > &a, const conjugate< S > &r)
template<class R , class S >
Wider< R, S >::WCplx	operator* (const negator< complex< R > > &a, const conjugate< S > &r)
template<class R , class S >
Wider< R, S >::WCplx	operator* (const conjugate< R > &a, const negator< complex< S > > &r)
template<class R , class S >
Wider< R, S >::WCplx	operator/ (const conjugate< R > &a, const conjugate< S > &r)
template<class R , class S >
Wider< R, S >::WCplx	operator/ (const conjugate< R > &a, const complex< S > &r)
template<class R , class S >
Wider< R, S >::WCplx	operator/ (const complex< R > &a, const conjugate< S > &r)
template<class R , class S >
bool	operator== (const conjugate< R > &a, const conjugate< S > &r)
template<class R , class S >
bool	operator== (const conjugate< R > &a, const complex< S > &r)
template<class R , class S >
bool	operator== (const complex< R > &a, const conjugate< S > &r)
template<class R , class S >
bool	operator!= (const conjugate< R > &a, const conjugate< S > &r)
template<class R , class S >
bool	operator!= (const conjugate< R > &a, const complex< S > &r)
template<class R , class S >
bool	operator!= (const complex< R > &a, const conjugate< S > &r)
bool	isNaN (const negator< float > &x)
bool	isNaN (const negator< double > &x)
template<class P >
bool	isNaN (const negator< std::complex< P > > &x)
template<class P >
bool	isNaN (const negator< conjugate< P > > &x)
bool	isFinite (const negator< float > &x)
bool	isFinite (const negator< double > &x)
template<class P >
bool	isFinite (const negator< std::complex< P > > &x)
template<class P >
bool	isFinite (const negator< conjugate< P > > &x)
bool	isInf (const negator< float > &x)
bool	isInf (const negator< double > &x)
template<class P >
bool	isInf (const negator< std::complex< P > > &x)
template<class P >
bool	isInf (const negator< conjugate< P > > &x)
template<class DEST , class SRC >
static const DEST &	negRecast (const SRC &s)
template<class A , class B >
negator< A >::template Result< B >::Add	operator+ (const negator< A > &l, const B &r)
template<class A , class B >
CNT< A >::template Result< negator< B > >::Add	operator+ (const A &l, const negator< B > &r)
template<class A , class B >
negator< A >::template Result< negator< B > >::Add	operator+ (const negator< A > &l, const negator< B > &r)
template<class A , class B >
negator< A >::template Result< B >::Sub	operator- (const negator< A > &l, const B &r)
template<class A , class B >
CNT< A >::template Result< negator< B > >::Sub	operator- (const A &l, const negator< B > &r)
template<class A , class B >
negator< A >::template Result< negator< B > >::Sub	operator- (const negator< A > &l, const negator< B > &r)
template<class A , class B >
negator< A >::template Result< B >::Mul	operator* (const negator< A > &l, const B &r)
template<class A , class B >
CNT< A >::template Result< negator< B > >::Mul	operator* (const A &l, const negator< B > &r)
template<class A , class B >
negator< A >::template Result< negator< B > >::Mul	operator* (const negator< A > &l, const negator< B > &r)
template<class A , class B >
negator< A >::template Result< B >::Dvd	operator/ (const negator< A > &l, const B &r)
template<class A , class B >
CNT< A >::template Result< negator< B > >::Dvd	operator/ (const A &l, const negator< B > &r)
template<class A , class B >
negator< A >::template Result< negator< B > >::Dvd	operator/ (const negator< A > &l, const negator< B > &r)
template<class A , class B >
bool	operator== (const negator< A > &l, const B &r)
template<class A , class B >
bool	operator== (const A &l, const negator< B > &r)
template<class A , class B >
bool	operator== (const negator< A > &l, const negator< B > &r)
template<class A , class B >
bool	operator!= (const negator< A > &l, const B &r)
template<class A , class B >
bool	operator!= (const A &l, const negator< B > &r)
template<class A , class B >
bool	operator!= (const negator< A > &l, const negator< B > &r)
template<class NUM , class CHAR , class TRAITS >
std::basic_istream< CHAR, TRAITS > &	operator>> (std::basic_istream< CHAR, TRAITS > &is, negator< NUM > &nn)
template<class NUM , class CHAR , class TRAITS >
std::basic_ostream< CHAR, TRAITS > &	operator<< (std::basic_ostream< CHAR, TRAITS > &os, const negator< NUM > &nn)
bool	isNaN (const float &x)
bool	isNaN (const double &x)
template<class P >
bool	isNaN (const std::complex< P > &x)
template<class P >
bool	isNaN (const conjugate< P > &x)
bool	isFinite (const float &x)
bool	isFinite (const double &x)
template<class P >
bool	isFinite (const std::complex< P > &x)
template<class P >
bool	isFinite (const conjugate< P > &x)
bool	isInf (const float &x)
bool	isInf (const double &x)
template<class P >
bool	isInf (const std::complex< P > &x)
template<class P >
bool	isInf (const conjugate< P > &x)
bool	isNumericallyEqual (const float &a, const float &b, double tol=RTraits< float >::getDefaultTolerance())
	Compare two floats for approximate equality. More...
bool	isNumericallyEqual (const double &a, const double &b, double tol=RTraits< double >::getDefaultTolerance())
	Compare two doubles for approximate equality. More...
bool	isNumericallyEqual (const float &a, const double &b, double tol=RTraits< float >::getDefaultTolerance())
	Compare a float and a double for approximate equality at float precision. More...
bool	isNumericallyEqual (const double &a, const float &b, double tol=RTraits< float >::getDefaultTolerance())
	Compare a float and a double for approximate equality at float precision. More...
bool	isNumericallyEqual (const float &a, int b, double tol=RTraits< float >::getDefaultTolerance())
	Test a float for approximate equality to an integer. More...
bool	isNumericallyEqual (int a, const float &b, double tol=RTraits< float >::getDefaultTolerance())
	Test a float for approximate equality to an integer. More...
bool	isNumericallyEqual (const double &a, int b, double tol=RTraits< double >::getDefaultTolerance())
	Test a double for approximate equality to an integer. More...
bool	isNumericallyEqual (int a, const double &b, double tol=RTraits< double >::getDefaultTolerance())
	Test a double for approximate equality to an integer. More...
template<class P , class Q >
bool	isNumericallyEqual (const std::complex< P > &a, const std::complex< Q > &b, double tol=RTraits< typename Narrowest< P, Q >::Precision >::getDefaultTolerance())
	Compare two complex numbers for approximate equality, using the numerical accuracy expectation of the narrower of the two precisions in the case of mixed precision. More...
template<class P , class Q >
bool	isNumericallyEqual (const conjugate< P > &a, const conjugate< Q > &b, double tol=RTraits< typename Narrowest< P, Q >::Precision >::getDefaultTolerance())
	Compare two conjugate numbers for approximate equality, using the numerical accuracy expectation of the narrower of the two precisions in the case of mixed precision. More...
template<class P , class Q >
bool	isNumericallyEqual (const std::complex< P > &a, const conjugate< Q > &b, double tol=RTraits< typename Narrowest< P, Q >::Precision >::getDefaultTolerance())
	Compare a complex and a conjugate number for approximate equality, using the numerical accuracy expectation of the narrower of the two precisions in the case of mixed precision. More...
template<class P , class Q >
bool	isNumericallyEqual (const conjugate< P > &a, const std::complex< Q > &b, double tol=RTraits< typename Narrowest< P, Q >::Precision >::getDefaultTolerance())
	Compare a complex and a conjugate number for approximate equality, using the numerical accuracy expectation of the narrower of the two precisions in the case of mixed precision. More...
template<class P >
bool	isNumericallyEqual (const std::complex< P > &a, const float &b, double tol=RTraits< float >::getDefaultTolerance())
	Test whether a complex number is approximately equal to a particular real float. More...
template<class P >
bool	isNumericallyEqual (const float &a, const std::complex< P > &b, double tol=RTraits< float >::getDefaultTolerance())
	Test whether a complex number is approximately equal to a particular real float. More...
template<class P >
bool	isNumericallyEqual (const std::complex< P > &a, const double &b, double tol=RTraits< typename Narrowest< P, double >::Precision >::getDefaultTolerance())
	Test whether a complex number is approximately equal to a particular real double. More...
template<class P >
bool	isNumericallyEqual (const double &a, const std::complex< P > &b, double tol=RTraits< typename Narrowest< P, double >::Precision >::getDefaultTolerance())
	Test whether a complex number is approximately equal to a particular real double. More...
template<class P >
bool	isNumericallyEqual (const std::complex< P > &a, int b, double tol=RTraits< P >::getDefaultTolerance())
	Test whether a complex number is approximately equal to a particular integer. More...
template<class P >
bool	isNumericallyEqual (int a, const std::complex< P > &b, double tol=RTraits< P >::getDefaultTolerance())
	Test whether a complex number is approximately equal to a particular integer. More...
template<class P >
bool	isNumericallyEqual (const conjugate< P > &a, const float &b, double tol=RTraits< float >::getDefaultTolerance())
	Test whether a conjugate number is approximately equal to a particular real float. More...
template<class P >
bool	isNumericallyEqual (const float &a, const conjugate< P > &b, double tol=RTraits< float >::getDefaultTolerance())
	Test whether a conjugate number is approximately equal to a particular real float. More...
template<class P >
bool	isNumericallyEqual (const conjugate< P > &a, const double &b, double tol=RTraits< typename Narrowest< P, double >::Precision >::getDefaultTolerance())
	Test whether a conjugate number is approximately equal to a particular real double. More...
template<class P >
bool	isNumericallyEqual (const double &a, const conjugate< P > &b, double tol=RTraits< typename Narrowest< P, double >::Precision >::getDefaultTolerance())
	Test whether a conjugate number is approximately equal to a particular real double. More...
template<class P >
bool	isNumericallyEqual (const conjugate< P > &a, int b, double tol=RTraits< P >::getDefaultTolerance())
	Test whether a conjugate number is approximately equal to a particular integer. More...
template<class P >
bool	isNumericallyEqual (int a, const conjugate< P > &b, double tol=RTraits< P >::getDefaultTolerance())
	Test whether a conjugate number is approximately equal to a particular integer. More...
	SimTK_BNTCMPLX_SPEC (float, float)
	SimTK_BNTCMPLX_SPEC (float, double)
	SimTK_BNTCMPLX_SPEC (double, float)
	SimTK_BNTCMPLX_SPEC (double, double)
	SimTK_NTRAITS_CONJ_SPEC (float, float)
	SimTK_NTRAITS_CONJ_SPEC (float, double)
	SimTK_NTRAITS_CONJ_SPEC (double, float)
	SimTK_NTRAITS_CONJ_SPEC (double, double)
	SimTK_DEFINE_REAL_NTRAITS (float)
	SimTK_DEFINE_REAL_NTRAITS (double)
bool	atMostOneBitIsSet (unsigned char v)
bool	atMostOneBitIsSet (unsigned short v)
bool	atMostOneBitIsSet (unsigned int v)
bool	atMostOneBitIsSet (unsigned long v)
bool	atMostOneBitIsSet (unsigned long long v)
bool	atMostOneBitIsSet (signed char v)
bool	atMostOneBitIsSet (char v)
bool	atMostOneBitIsSet (short v)
bool	atMostOneBitIsSet (int v)
bool	atMostOneBitIsSet (long v)
bool	atMostOneBitIsSet (long long v)
bool	exactlyOneBitIsSet (unsigned char v)
bool	exactlyOneBitIsSet (unsigned short v)
bool	exactlyOneBitIsSet (unsigned int v)
bool	exactlyOneBitIsSet (unsigned long v)
bool	exactlyOneBitIsSet (unsigned long long v)
bool	exactlyOneBitIsSet (signed char v)
bool	exactlyOneBitIsSet (char v)
bool	exactlyOneBitIsSet (short v)
bool	exactlyOneBitIsSet (int v)
bool	exactlyOneBitIsSet (long v)
bool	exactlyOneBitIsSet (long long v)
bool	signBit (unsigned char u)
bool	signBit (unsigned short u)
bool	signBit (unsigned int u)
bool	signBit (unsigned long u)
bool	signBit (unsigned long long u)
bool	signBit (signed char i)
bool	signBit (short i)
bool	signBit (int i)
bool	signBit (long long i)
bool	signBit (long i)
bool	signBit (const float &f)
bool	signBit (const double &d)
bool	signBit (const negator< float > &nf)
bool	signBit (const negator< double > &nd)
unsigned int	sign (unsigned char u)
unsigned int	sign (unsigned short u)
unsigned int	sign (unsigned int u)
unsigned int	sign (unsigned long u)
unsigned int	sign (unsigned long long u)
int	sign (signed char i)
int	sign (short i)
int	sign (int i)
int	sign (long i)
int	sign (long long i)
int	sign (const float &x)
int	sign (const double &x)
int	sign (const negator< float > &x)
int	sign (const negator< double > &x)
unsigned char	square (unsigned char u)
unsigned short	square (unsigned short u)
unsigned int	square (unsigned int u)
unsigned long	square (unsigned long u)
unsigned long long	square (unsigned long long u)
char	square (char c)
signed char	square (signed char i)
short	square (short i)
int	square (int i)
long	square (long i)
long long	square (long long i)
float	square (const float &x)
double	square (const double &x)
float	square (const negator< float > &x)
double	square (const negator< double > &x)
template<class P >
std::complex< P >	square (const std::complex< P > &x)
template<class P >
std::complex< P >	square (const conjugate< P > &x)
template<class P >
std::complex< P >	square (const negator< std::complex< P > > &x)
template<class P >
std::complex< P >	square (const negator< conjugate< P > > &x)
unsigned char	cube (unsigned char u)
unsigned short	cube (unsigned short u)
unsigned int	cube (unsigned int u)
unsigned long	cube (unsigned long u)
unsigned long long	cube (unsigned long long u)
char	cube (char c)
signed char	cube (signed char i)
short	cube (short i)
int	cube (int i)
long	cube (long i)
long long	cube (long long i)
float	cube (const float &x)
double	cube (const double &x)
negator< float >	cube (const negator< float > &x)
negator< double >	cube (const negator< double > &x)
template<class P >
std::complex< P >	cube (const std::complex< P > &x)
template<class P >
std::complex< P >	cube (const negator< std::complex< P > > &x)
template<class P >
std::complex< P >	cube (const conjugate< P > &x)
template<class P >
std::complex< P >	cube (const negator< conjugate< P > > &x)
double &	clampInPlace (double low, double &v, double high)
	Check that low <= v <= high and modify v in place if necessary to bring it into that range. More...
float &	clampInPlace (float low, float &v, float high)
	Check that low <= v <= high and modify v in place if necessary to bring it into that range. More...
double &	clampInPlace (int low, double &v, int high)
	Check that low <= v <= high and modify v in place if necessary to bring it into that range. More...
float &	clampInPlace (int low, float &v, int high)
	Check that low <= v <= high and modify v in place if necessary to bring it into that range. More...
double &	clampInPlace (int low, double &v, double high)
	Check that low <= v <= high and modify v in place if necessary to bring it into that range. More...
float &	clampInPlace (int low, float &v, float high)
	Check that low <= v <= high and modify v in place if necessary to bring it into that range. More...
double &	clampInPlace (double low, double &v, int high)
	Check that low <= v <= high and modify v in place if necessary to bring it into that range. More...
float &	clampInPlace (float low, float &v, int high)
	Check that low <= v <= high and modify v in place if necessary to bring it into that range. More...
unsigned char &	clampInPlace (unsigned char low, unsigned char &v, unsigned char high)
	Check that low <= v <= high and modify v in place if necessary to bring it into that range. More...
unsigned short &	clampInPlace (unsigned short low, unsigned short &v, unsigned short high)
	Check that low <= v <= high and modify v in place if necessary to bring it into that range. More...
unsigned int &	clampInPlace (unsigned int low, unsigned int &v, unsigned int high)
	Check that low <= v <= high and modify v in place if necessary to bring it into that range. More...
unsigned long &	clampInPlace (unsigned long low, unsigned long &v, unsigned long high)
	Check that low <= v <= high and modify v in place if necessary to bring it into that range. More...
unsigned long long &	clampInPlace (unsigned long long low, unsigned long long &v, unsigned long long high)
	Check that low <= v <= high and modify v in place if necessary to bring it into that range. More...
char &	clampInPlace (char low, char &v, char high)
	Check that low <= v <= high and modify v in place if necessary to bring it into that range. More...
signed char &	clampInPlace (signed char low, signed char &v, signed char high)
	Check that low <= v <= high and modify v in place if necessary to bring it into that range. More...
short &	clampInPlace (short low, short &v, short high)
	Check that low <= v <= high and modify v in place if necessary to bring it into that range. More...
int &	clampInPlace (int low, int &v, int high)
	Check that low <= v <= high and modify v in place if necessary to bring it into that range. More...
long &	clampInPlace (long low, long &v, long high)
	Check that low <= v <= high and modify v in place if necessary to bring it into that range. More...
long long &	clampInPlace (long long low, long long &v, long long high)
	Check that low <= v <= high and modify v in place if necessary to bring it into that range. More...
negator< float > &	clampInPlace (float low, negator< float > &v, float high)
	Check that low <= v <= high and modify v in place if necessary to bring it into that range. More...
negator< double > &	clampInPlace (double low, negator< double > &v, double high)
	Check that low <= v <= high and modify v in place if necessary to bring it into that range. More...
double	clamp (double low, double v, double high)
	If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v. More...
float	clamp (float low, float v, float high)
	If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v. More...
double	clamp (int low, double v, int high)
	If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v. More...
float	clamp (int low, float v, int high)
	If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v. More...
double	clamp (int low, double v, double high)
	If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v. More...
float	clamp (int low, float v, float high)
	If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v. More...
double	clamp (double low, double v, int high)
	If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v. More...
float	clamp (float low, float v, int high)
	If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v. More...
unsigned char	clamp (unsigned char low, unsigned char v, unsigned char high)
	If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v. More...
unsigned short	clamp (unsigned short low, unsigned short v, unsigned short high)
	If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v. More...
unsigned int	clamp (unsigned int low, unsigned int v, unsigned int high)
	If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v. More...
unsigned long	clamp (unsigned long low, unsigned long v, unsigned long high)
	If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v. More...
unsigned long long	clamp (unsigned long long low, unsigned long long v, unsigned long long high)
	If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v. More...
char	clamp (char low, char v, char high)
	If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v. More...
signed char	clamp (signed char low, signed char v, signed char high)
	If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v. More...
short	clamp (short low, short v, short high)
	If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v. More...
int	clamp (int low, int v, int high)
	If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v. More...
long	clamp (long low, long v, long high)
	If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v. More...
long long	clamp (long long low, long long v, long long high)
	If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v. More...
float	clamp (float low, negator< float > v, float high)
	If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v. More...
double	clamp (double low, negator< double > v, double high)
	If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v. More...
double	stepUp (double x)
	Interpolate smoothly from 0 up to 1 as the input argument goes from 0 to 1, with first and second derivatives zero at either end of the interval. More...
double	stepDown (double x)
	Interpolate smoothly from 1 down to 0 as the input argument goes from 0 to 1, with first and second derivatives zero at either end of the interval. More...
double	stepAny (double y0, double yRange, double x0, double oneOverXRange, double x)
	Interpolate smoothly from y0 to y1 as the input argument goes from x0 to x1, with first and second derivatives zero at either end of the interval. More...
double	dstepUp (double x)
	First derivative of stepUp(): d/dx stepUp(x). More...
double	dstepDown (double x)
	First derivative of stepDown(): d/dx stepDown(x). More...
double	dstepAny (double yRange, double x0, double oneOverXRange, double x)
	First derivative of stepAny(): d/dx stepAny(x). More...
double	d2stepUp (double x)
	Second derivative of stepUp(): d^2/dx^2 stepUp(x). More...
double	d2stepDown (double x)
	Second derivative of stepDown(): d^2/dx^2 stepDown(x). More...
double	d2stepAny (double yRange, double x0, double oneOverXRange, double x)
	Second derivative of stepAny(): d^2/dx^2 stepAny(x). More...
double	d3stepUp (double x)
	Third derivative of stepUp(): d^3/dx^3 stepUp(x). More...
double	d3stepDown (double x)
	Third derivative of stepDown(): d^3/dx^3 stepDown(x). More...
double	d3stepAny (double yRange, double x0, double oneOverXRange, double x)
	Third derivative of stepAny(): d^3/dx^3 stepAny(x). More...
float	stepUp (float x)
	Interpolate smoothly from 0 up to 1 as the input argument goes from 0 to 1, with first and second derivatives zero at either end of the interval. More...
float	stepDown (float x)
	Interpolate smoothly from 1 down to 0 as the input argument goes from 0 to 1, with first and second derivatives zero at either end of the interval. More...
float	stepAny (float y0, float yRange, float x0, float oneOverXRange, float x)
	Interpolate smoothly from y0 to y1 as the input argument goes from x0 to x1, with first and second derivatives zero at either end of the interval. More...
float	dstepUp (float x)
	First derivative of stepUp(): d/dx stepUp(x). More...
float	dstepDown (float x)
	First derivative of stepDown(): d/dx stepDown(x). More...
float	dstepAny (float yRange, float x0, float oneOverXRange, float x)
	First derivative of stepAny(): d/dx stepAny(x). More...
float	d2stepUp (float x)
	Second derivative of stepUp(): d^2/dx^2 stepUp(x). More...
float	d2stepDown (float x)
	Second derivative of stepDown(): d^2/dx^2 stepDown(x). More...
float	d2stepAny (float yRange, float x0, float oneOverXRange, float x)
	Second derivative of stepAny(): d^2/dx^2 stepAny(x). More...
float	d3stepUp (float x)
	Third derivative of stepUp(): d^3/dx^3 stepUp(x). More...
float	d3stepDown (float x)
	Third derivative of stepDown(): d^3/dx^3 stepDown(x). More...
float	d3stepAny (float yRange, float x0, float oneOverXRange, float x)
	Third derivative of stepAny(): d^3/dx^3 stepAny(x). More...
double	stepUp (int x)
	Interpolate smoothly from 0 up to 1 as the input argument goes from 0 to 1, with first and second derivatives zero at either end of the interval. More...
double	stepDown (int x)
	Interpolate smoothly from 1 down to 0 as the input argument goes from 0 to 1, with first and second derivatives zero at either end of the interval. More...
std::pair< double, double >	approxCompleteEllipticIntegralsKE (double m)
	Given 0<=m<=1, return complete elliptic integrals of the first and second kinds, K(m) and E(m), approximated but with a maximum error of 2e-8 so at least 7 digits are correct (same in float or double precision). See Elliptic integrals for a discussion. More...
std::pair< float, float >	approxCompleteEllipticIntegralsKE (float m)
	This is the single precision (float) version of the approximate calculation of elliptic integrals, still yielding about 7 digits of accuracy even though all calculations are done in float precision. More...
std::pair< double, double >	approxCompleteEllipticIntegralsKE (int m)
	This integer overload is present to prevent ambiguity; it converts its argument to double precision and then calls approxCompleteEllipticIntegralsKE(double). More...
std::pair< double, double >	completeEllipticIntegralsKE (double m)
	Given 0<=m<=1, return complete elliptic integrals of the first and second kinds, K(m) and E(m), calculated to (roughly) machine precision (float or double). See Elliptic integrals for a discussion. More...
std::pair< float, float >	completeEllipticIntegralsKE (float m)
	This is the single precision (float) version of the machine-precision calculation of elliptic integrals, providing accuracy to float precision (about 7 digits) which is no better than you'll get with the much faster approximate version, so use that instead! More...
std::pair< double, double >	completeEllipticIntegralsKE (int m)
	This integer overload is present to prevent ambiguity; it converts its argument to double precision and then calls completeEllipticIntegralsKE(double). More...
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (EventId)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (SystemEventTriggerIndex)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (SystemEventTriggerByStageIndex)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (EventTriggerByStageIndex)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (MeasureIndex)
	Define a unique integral type for safe indexing of Measures. More...
std::ostream &	operator<< (std::ostream &o, Stage g)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (SubsystemIndex)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (SystemYIndex)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (SystemQIndex)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (QIndex)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (SystemUIndex)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (UIndex)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (SystemZIndex)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (ZIndex)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (DiscreteVariableIndex)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (CacheEntryIndex)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (SystemYErrIndex)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (SystemQErrIndex)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (QErrIndex)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (SystemUErrIndex)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (UErrIndex)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (SystemUDotErrIndex)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (UDotErrIndex)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (SystemMultiplierIndex)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (MultiplierIndex)
std::ostream &	operator<< (std::ostream &o, const State &s)
template<int M, int N, class EL , int CSL, int RSL, class ER , int CSR, int RSR>
Mat< M, N, EL, CSL, RSL >::template Result< Mat< M, N, ER, CSR, RSR > >::Add	operator+ (const Mat< M, N, EL, CSL, RSL > &l, const Mat< M, N, ER, CSR, RSR > &r)
template<int M, int N, class EL , int CSL, int RSL, class ER , int CSR, int RSR>
Mat< M, N, EL, CSL, RSL >::template Result< Mat< M, N, ER, CSR, RSR > >::Sub	operator- (const Mat< M, N, EL, CSL, RSL > &l, const Mat< M, N, ER, CSR, RSR > &r)
template<int M, int N, class EL , int CSL, int RSL, int P, class ER , int CSR, int RSR>
Mat< M, N, EL, CSL, RSL >::template Result< Mat< N, P, ER, CSR, RSR > >::Mul	operator* (const Mat< M, N, EL, CSL, RSL > &l, const Mat< N, P, ER, CSR, RSR > &r)
template<int M, int N, class EL , int CSL, int RSL, int MM, int NN, class ER , int CSR, int RSR>
Mat< M, N, EL, CSL, RSL >::template Result< Mat< MM, NN, ER, CSR, RSR > >::MulNon	operator* (const Mat< M, N, EL, CSL, RSL > &l, const Mat< MM, NN, ER, CSR, RSR > &r)
template<int M, int N, class EL , int CSL, int RSL, class ER , int CSR, int RSR>
bool	operator== (const Mat< M, N, EL, CSL, RSL > &l, const Mat< M, N, ER, CSR, RSR > &r)
template<int M, int N, class EL , int CSL, int RSL, class ER , int CSR, int RSR>
bool	operator!= (const Mat< M, N, EL, CSL, RSL > &l, const Mat< M, N, ER, CSR, RSR > &r)
template<int M, int N, class E , int CS, int RS>
Mat< M, N, E, CS, RS >::template Result< float >::Mul	operator* (const Mat< M, N, E, CS, RS > &l, const float &r)
template<int M, int N, class E , int CS, int RS>
Mat< M, N, E, CS, RS >::template Result< float >::Mul	operator* (const float &l, const Mat< M, N, E, CS, RS > &r)
template<int M, int N, class E , int CS, int RS>
Mat< M, N, E, CS, RS >::template Result< double >::Mul	operator* (const Mat< M, N, E, CS, RS > &l, const double &r)
template<int M, int N, class E , int CS, int RS>
Mat< M, N, E, CS, RS >::template Result< double >::Mul	operator* (const double &l, const Mat< M, N, E, CS, RS > &r)
template<int M, int N, class E , int CS, int RS>
Mat< M, N, E, CS, RS >::template Result< typename CNT< E >::Precision >::Mul	operator* (const Mat< M, N, E, CS, RS > &l, int r)
template<int M, int N, class E , int CS, int RS>
Mat< M, N, E, CS, RS >::template Result< typename CNT< E >::Precision >::Mul	operator* (int l, const Mat< M, N, E, CS, RS > &r)
template<int M, int N, class E , int CS, int RS, class R >
Mat< M, N, E, CS, RS >::template Result< std::complex< R > >::Mul	operator* (const Mat< M, N, E, CS, RS > &l, const std::complex< R > &r)
template<int M, int N, class E , int CS, int RS, class R >
Mat< M, N, E, CS, RS >::template Result< std::complex< R > >::Mul	operator* (const std::complex< R > &l, const Mat< M, N, E, CS, RS > &r)
template<int M, int N, class E , int CS, int RS, class R >
Mat< M, N, E, CS, RS >::template Result< std::complex< R > >::Mul	operator* (const Mat< M, N, E, CS, RS > &l, const conjugate< R > &r)
template<int M, int N, class E , int CS, int RS, class R >
Mat< M, N, E, CS, RS >::template Result< std::complex< R > >::Mul	operator* (const conjugate< R > &l, const Mat< M, N, E, CS, RS > &r)
template<int M, int N, class E , int CS, int RS, class R >
Mat< M, N, E, CS, RS >::template Result< typename negator< R >::StdNumber >::Mul	operator* (const Mat< M, N, E, CS, RS > &l, const negator< R > &r)
template<int M, int N, class E , int CS, int RS, class R >
Mat< M, N, E, CS, RS >::template Result< typename negator< R >::StdNumber >::Mul	operator* (const negator< R > &l, const Mat< M, N, E, CS, RS > &r)
template<int M, int N, class E , int CS, int RS>
Mat< M, N, E, CS, RS >::template Result< float >::Dvd	operator/ (const Mat< M, N, E, CS, RS > &l, const float &r)
template<int M, int N, class E , int CS, int RS>
CNT< float >::template Result< Mat< M, N, E, CS, RS > >::Dvd	operator/ (const float &l, const Mat< M, N, E, CS, RS > &r)
template<int M, int N, class E , int CS, int RS>
Mat< M, N, E, CS, RS >::template Result< double >::Dvd	operator/ (const Mat< M, N, E, CS, RS > &l, const double &r)
template<int M, int N, class E , int CS, int RS>
CNT< double >::template Result< Mat< M, N, E, CS, RS > >::Dvd	operator/ (const double &l, const Mat< M, N, E, CS, RS > &r)
template<int M, int N, class E , int CS, int RS>
Mat< M, N, E, CS, RS >::template Result< typename CNT< E >::Precision >::Dvd	operator/ (const Mat< M, N, E, CS, RS > &l, int r)
template<int M, int N, class E , int CS, int RS>
CNT< typename CNT< E >::Precision >::template Result< Mat< M, N, E, CS, RS > >::Dvd	operator/ (int l, const Mat< M, N, E, CS, RS > &r)
template<int M, int N, class E , int CS, int RS, class R >
Mat< M, N, E, CS, RS >::template Result< std::complex< R > >::Dvd	operator/ (const Mat< M, N, E, CS, RS > &l, const std::complex< R > &r)
template<int M, int N, class E , int CS, int RS, class R >
CNT< std::complex< R > >::template Result< Mat< M, N, E, CS, RS > >::Dvd	operator/ (const std::complex< R > &l, const Mat< M, N, E, CS, RS > &r)
template<int M, int N, class E , int CS, int RS, class R >
Mat< M, N, E, CS, RS >::template Result< std::complex< R > >::Dvd	operator/ (const Mat< M, N, E, CS, RS > &l, const conjugate< R > &r)
template<int M, int N, class E , int CS, int RS, class R >
CNT< std::complex< R > >::template Result< Mat< M, N, E, CS, RS > >::Dvd	operator/ (const conjugate< R > &l, const Mat< M, N, E, CS, RS > &r)
template<int M, int N, class E , int CS, int RS, class R >
Mat< M, N, E, CS, RS >::template Result< typename negator< R >::StdNumber >::Dvd	operator/ (const Mat< M, N, E, CS, RS > &l, const negator< R > &r)
template<int M, int N, class E , int CS, int RS, class R >
CNT< R >::template Result< Mat< M, N, E, CS, RS > >::Dvd	operator/ (const negator< R > &l, const Mat< M, N, E, CS, RS > &r)
template<int M, int N, class E , int CS, int RS>
Mat< M, N, E, CS, RS >::template Result< float >::Add	operator+ (const Mat< M, N, E, CS, RS > &l, const float &r)
template<int M, int N, class E , int CS, int RS>
Mat< M, N, E, CS, RS >::template Result< float >::Add	operator+ (const float &l, const Mat< M, N, E, CS, RS > &r)
template<int M, int N, class E , int CS, int RS>
Mat< M, N, E, CS, RS >::template Result< double >::Add	operator+ (const Mat< M, N, E, CS, RS > &l, const double &r)
template<int M, int N, class E , int CS, int RS>
Mat< M, N, E, CS, RS >::template Result< double >::Add	operator+ (const double &l, const Mat< M, N, E, CS, RS > &r)
template<int M, int N, class E , int CS, int RS>
Mat< M, N, E, CS, RS >::template Result< typename CNT< E >::Precision >::Add	operator+ (const Mat< M, N, E, CS, RS > &l, int r)
template<int M, int N, class E , int CS, int RS>
Mat< M, N, E, CS, RS >::template Result< typename CNT< E >::Precision >::Add	operator+ (int l, const Mat< M, N, E, CS, RS > &r)
template<int M, int N, class E , int CS, int RS, class R >
Mat< M, N, E, CS, RS >::template Result< std::complex< R > >::Add	operator+ (const Mat< M, N, E, CS, RS > &l, const std::complex< R > &r)
template<int M, int N, class E , int CS, int RS, class R >
Mat< M, N, E, CS, RS >::template Result< std::complex< R > >::Add	operator+ (const std::complex< R > &l, const Mat< M, N, E, CS, RS > &r)
template<int M, int N, class E , int CS, int RS, class R >
Mat< M, N, E, CS, RS >::template Result< std::complex< R > >::Add	operator+ (const Mat< M, N, E, CS, RS > &l, const conjugate< R > &r)
template<int M, int N, class E , int CS, int RS, class R >
Mat< M, N, E, CS, RS >::template Result< std::complex< R > >::Add	operator+ (const conjugate< R > &l, const Mat< M, N, E, CS, RS > &r)
template<int M, int N, class E , int CS, int RS, class R >
Mat< M, N, E, CS, RS >::template Result< typename negator< R >::StdNumber >::Add	operator+ (const Mat< M, N, E, CS, RS > &l, const negator< R > &r)
template<int M, int N, class E , int CS, int RS, class R >
Mat< M, N, E, CS, RS >::template Result< typename negator< R >::StdNumber >::Add	operator+ (const negator< R > &l, const Mat< M, N, E, CS, RS > &r)
template<int M, int N, class E , int CS, int RS>
Mat< M, N, E, CS, RS >::template Result< float >::Sub	operator- (const Mat< M, N, E, CS, RS > &l, const float &r)
template<int M, int N, class E , int CS, int RS>
CNT< float >::template Result< Mat< M, N, E, CS, RS > >::Sub	operator- (const float &l, const Mat< M, N, E, CS, RS > &r)
template<int M, int N, class E , int CS, int RS>
Mat< M, N, E, CS, RS >::template Result< double >::Sub	operator- (const Mat< M, N, E, CS, RS > &l, const double &r)
template<int M, int N, class E , int CS, int RS>
CNT< double >::template Result< Mat< M, N, E, CS, RS > >::Sub	operator- (const double &l, const Mat< M, N, E, CS, RS > &r)
template<int M, int N, class E , int CS, int RS>
Mat< M, N, E, CS, RS >::template Result< typename CNT< E >::Precision >::Sub	operator- (const Mat< M, N, E, CS, RS > &l, int r)
template<int M, int N, class E , int CS, int RS>
CNT< typename CNT< E >::Precision >::template Result< Mat< M, N, E, CS, RS > >::Sub	operator- (int l, const Mat< M, N, E, CS, RS > &r)
template<int M, int N, class E , int CS, int RS, class R >
Mat< M, N, E, CS, RS >::template Result< std::complex< R > >::Sub	operator- (const Mat< M, N, E, CS, RS > &l, const std::complex< R > &r)
template<int M, int N, class E , int CS, int RS, class R >
CNT< std::complex< R > >::template Result< Mat< M, N, E, CS, RS > >::Sub	operator- (const std::complex< R > &l, const Mat< M, N, E, CS, RS > &r)
template<int M, int N, class E , int CS, int RS, class R >
Mat< M, N, E, CS, RS >::template Result< std::complex< R > >::Sub	operator- (const Mat< M, N, E, CS, RS > &l, const conjugate< R > &r)
template<int M, int N, class E , int CS, int RS, class R >
CNT< std::complex< R > >::template Result< Mat< M, N, E, CS, RS > >::Sub	operator- (const conjugate< R > &l, const Mat< M, N, E, CS, RS > &r)
template<int M, int N, class E , int CS, int RS, class R >
Mat< M, N, E, CS, RS >::template Result< typename negator< R >::StdNumber >::Sub	operator- (const Mat< M, N, E, CS, RS > &l, const negator< R > &r)
template<int M, int N, class E , int CS, int RS, class R >
CNT< R >::template Result< Mat< M, N, E, CS, RS > >::Sub	operator- (const negator< R > &l, const Mat< M, N, E, CS, RS > &r)
template<int M, int N, class E , int CS, int RS, class CHAR , class TRAITS >
std::basic_ostream< CHAR, TRAITS > &	operator<< (std::basic_ostream< CHAR, TRAITS > &o, const Mat< M, N, E, CS, RS > &m)
template<int M, int N, class E , int CS, int RS, class CHAR , class TRAITS >
std::basic_istream< CHAR, TRAITS > &	operator>> (std::basic_istream< CHAR, TRAITS > &is, Mat< M, N, E, CS, RS > &m)
template<int N, class E1 , int S1, class E2 , int S2>
Row< N, E1, S1 >::template Result< Row< N, E2, S2 > >::Add	operator+ (const Row< N, E1, S1 > &l, const Row< N, E2, S2 > &r)
template<int N, class E1 , int S1, class E2 , int S2>
Row< N, E1, S1 >::template Result< Row< N, E2, S2 > >::Sub	operator- (const Row< N, E1, S1 > &l, const Row< N, E2, S2 > &r)
template<int N, class E1 , int S1, class E2 , int S2>
bool	operator== (const Row< N, E1, S1 > &l, const Row< N, E2, S2 > &r)
	bool = v1[i] == v2[i], for all elements i More...
template<int N, class E1 , int S1, class E2 , int S2>
bool	operator!= (const Row< N, E1, S1 > &l, const Row< N, E2, S2 > &r)
	bool = v1[i] != v2[i], for any element i More...
template<int N, class E1 , int S1, class E2 , int S2>
bool	operator< (const Row< N, E1, S1 > &l, const Row< N, E2, S2 > &r)
	bool = v1[i] < v2[i], for all elements i More...
template<int N, class E1 , int S1, class E2 >
bool	operator< (const Row< N, E1, S1 > &v, const E2 &e)
	bool = v[i] < e, for all elements v[i] and element e More...
template<int N, class E1 , int S1, class E2 , int S2>
bool	operator> (const Row< N, E1, S1 > &l, const Row< N, E2, S2 > &r)
	bool = v1[i] > v2[i], for all elements i More...
template<int N, class E1 , int S1, class E2 >
bool	operator> (const Row< N, E1, S1 > &v, const E2 &e)
	bool = v[i] > e, for all elements v[i] and element e More...
template<int N, class E1 , int S1, class E2 , int S2>
bool	operator<= (const Row< N, E1, S1 > &l, const Row< N, E2, S2 > &r)
	bool = v1[i] <= v2[i], for all elements i. More...
template<int N, class E1 , int S1, class E2 >
bool	operator<= (const Row< N, E1, S1 > &v, const E2 &e)
	bool = v[i] <= e, for all elements v[i] and element e. More...
template<int N, class E1 , int S1, class E2 , int S2>
bool	operator>= (const Row< N, E1, S1 > &l, const Row< N, E2, S2 > &r)
	bool = v1[i] >= v2[i], for all elements i This is not the same as !(v1<v2). More...
template<int N, class E1 , int S1, class E2 >
bool	operator>= (const Row< N, E1, S1 > &v, const E2 &e)
	bool = v[i] >= e, for all elements v[i] and element e. More...
template<int N, class E , int S>
Row< N, E, S >::template Result< float >::Mul	operator* (const Row< N, E, S > &l, const float &r)
template<int N, class E , int S>
Row< N, E, S >::template Result< float >::Mul	operator* (const float &l, const Row< N, E, S > &r)
template<int N, class E , int S>
Row< N, E, S >::template Result< double >::Mul	operator* (const Row< N, E, S > &l, const double &r)
template<int N, class E , int S>
Row< N, E, S >::template Result< double >::Mul	operator* (const double &l, const Row< N, E, S > &r)
template<int N, class E , int S>
Row< N, E, S >::template Result< typename CNT< E >::Precision >::Mul	operator* (const Row< N, E, S > &l, int r)
template<int N, class E , int S>
Row< N, E, S >::template Result< typename CNT< E >::Precision >::Mul	operator* (int l, const Row< N, E, S > &r)
template<int N, class E , int S, class R >
Row< N, E, S >::template Result< std::complex< R > >::Mul	operator* (const Row< N, E, S > &l, const std::complex< R > &r)
template<int N, class E , int S, class R >
Row< N, E, S >::template Result< std::complex< R > >::Mul	operator* (const std::complex< R > &l, const Row< N, E, S > &r)
template<int N, class E , int S, class R >
Row< N, E, S >::template Result< std::complex< R > >::Mul	operator* (const Row< N, E, S > &l, const conjugate< R > &r)
template<int N, class E , int S, class R >
Row< N, E, S >::template Result< std::complex< R > >::Mul	operator* (const conjugate< R > &l, const Row< N, E, S > &r)
template<int N, class E , int S, class R >
Row< N, E, S >::template Result< typename negator< R >::StdNumber >::Mul	operator* (const Row< N, E, S > &l, const negator< R > &r)
template<int N, class E , int S, class R >
Row< N, E, S >::template Result< typename negator< R >::StdNumber >::Mul	operator* (const negator< R > &l, const Row< N, E, S > &r)
template<int N, class E , int S>
Row< N, E, S >::template Result< float >::Dvd	operator/ (const Row< N, E, S > &l, const float &r)
template<int N, class E , int S>
CNT< float >::template Result< Row< N, E, S > >::Dvd	operator/ (const float &l, const Row< N, E, S > &r)
template<int N, class E , int S>
Row< N, E, S >::template Result< double >::Dvd	operator/ (const Row< N, E, S > &l, const double &r)
template<int N, class E , int S>
CNT< double >::template Result< Row< N, E, S > >::Dvd	operator/ (const double &l, const Row< N, E, S > &r)
template<int N, class E , int S>
Row< N, E, S >::template Result< typename CNT< E >::Precision >::Dvd	operator/ (const Row< N, E, S > &l, int r)
template<int N, class E , int S>
CNT< typename CNT< E >::Precision >::template Result< Row< N, E, S > >::Dvd	operator/ (int l, const Row< N, E, S > &r)
template<int N, class E , int S, class R >
Row< N, E, S >::template Result< std::complex< R > >::Dvd	operator/ (const Row< N, E, S > &l, const std::complex< R > &r)
template<int N, class E , int S, class R >
CNT< std::complex< R > >::template Result< Row< N, E, S > >::Dvd	operator/ (const std::complex< R > &l, const Row< N, E, S > &r)
template<int N, class E , int S, class R >
Row< N, E, S >::template Result< std::complex< R > >::Dvd	operator/ (const Row< N, E, S > &l, const conjugate< R > &r)
template<int N, class E , int S, class R >
CNT< std::complex< R > >::template Result< Row< N, E, S > >::Dvd	operator/ (const conjugate< R > &l, const Row< N, E, S > &r)
template<int N, class E , int S, class R >
Row< N, E, S >::template Result< typename negator< R >::StdNumber >::Dvd	operator/ (const Row< N, E, S > &l, const negator< R > &r)
template<int N, class E , int S, class R >
CNT< R >::template Result< Row< N, E, S > >::Dvd	operator/ (const negator< R > &l, const Row< N, E, S > &r)
template<int N, class E , int S>
Row< N, E, S >::template Result< float >::Add	operator+ (const Row< N, E, S > &l, const float &r)
template<int N, class E , int S>
Row< N, E, S >::template Result< float >::Add	operator+ (const float &l, const Row< N, E, S > &r)
template<int N, class E , int S>
Row< N, E, S >::template Result< double >::Add	operator+ (const Row< N, E, S > &l, const double &r)
template<int N, class E , int S>
Row< N, E, S >::template Result< double >::Add	operator+ (const double &l, const Row< N, E, S > &r)
template<int N, class E , int S>
Row< N, E, S >::template Result< typename CNT< E >::Precision >::Add	operator+ (const Row< N, E, S > &l, int r)
template<int N, class E , int S>
Row< N, E, S >::template Result< typename CNT< E >::Precision >::Add	operator+ (int l, const Row< N, E, S > &r)
template<int N, class E , int S, class R >
Row< N, E, S >::template Result< std::complex< R > >::Add	operator+ (const Row< N, E, S > &l, const std::complex< R > &r)
template<int N, class E , int S, class R >
Row< N, E, S >::template Result< std::complex< R > >::Add	operator+ (const std::complex< R > &l, const Row< N, E, S > &r)
template<int N, class E , int S, class R >
Row< N, E, S >::template Result< std::complex< R > >::Add	operator+ (const Row< N, E, S > &l, const conjugate< R > &r)
template<int N, class E , int S, class R >
Row< N, E, S >::template Result< std::complex< R > >::Add	operator+ (const conjugate< R > &l, const Row< N, E, S > &r)
template<int N, class E , int S, class R >
Row< N, E, S >::template Result< typename negator< R >::StdNumber >::Add	operator+ (const Row< N, E, S > &l, const negator< R > &r)
template<int N, class E , int S, class R >
Row< N, E, S >::template Result< typename negator< R >::StdNumber >::Add	operator+ (const negator< R > &l, const Row< N, E, S > &r)
template<int N, class E , int S>
Row< N, E, S >::template Result< float >::Sub	operator- (const Row< N, E, S > &l, const float &r)
template<int N, class E , int S>
CNT< float >::template Result< Row< N, E, S > >::Sub	operator- (const float &l, const Row< N, E, S > &r)
template<int N, class E , int S>
Row< N, E, S >::template Result< double >::Sub	operator- (const Row< N, E, S > &l, const double &r)
template<int N, class E , int S>
CNT< double >::template Result< Row< N, E, S > >::Sub	operator- (const double &l, const Row< N, E, S > &r)
template<int N, class E , int S>
Row< N, E, S >::template Result< typename CNT< E >::Precision >::Sub	operator- (const Row< N, E, S > &l, int r)
template<int N, class E , int S>
CNT< typename CNT< E >::Precision >::template Result< Row< N, E, S > >::Sub	operator- (int l, const Row< N, E, S > &r)
template<int N, class E , int S, class R >
Row< N, E, S >::template Result< std::complex< R > >::Sub	operator- (const Row< N, E, S > &l, const std::complex< R > &r)
template<int N, class E , int S, class R >
CNT< std::complex< R > >::template Result< Row< N, E, S > >::Sub	operator- (const std::complex< R > &l, const Row< N, E, S > &r)
template<int N, class E , int S, class R >
Row< N, E, S >::template Result< std::complex< R > >::Sub	operator- (const Row< N, E, S > &l, const conjugate< R > &r)
template<int N, class E , int S, class R >
CNT< std::complex< R > >::template Result< Row< N, E, S > >::Sub	operator- (const conjugate< R > &l, const Row< N, E, S > &r)
template<int N, class E , int S, class R >
Row< N, E, S >::template Result< typename negator< R >::StdNumber >::Sub	operator- (const Row< N, E, S > &l, const negator< R > &r)
template<int N, class E , int S, class R >
CNT< R >::template Result< Row< N, E, S > >::Sub	operator- (const negator< R > &l, const Row< N, E, S > &r)
template<int N, class E , int S, class CHAR , class TRAITS >
std::basic_ostream< CHAR, TRAITS > &	operator<< (std::basic_ostream< CHAR, TRAITS > &o, const Row< N, E, S > &v)
template<int N, class E , int S, class CHAR , class TRAITS >
std::basic_istream< CHAR, TRAITS > &	operator>> (std::basic_istream< CHAR, TRAITS > &is, Row< N, E, S > &v)
	Read a Row from a stream as M elements separated by white space or by commas, optionally enclosed in () or [] (but no leading "~"). More...
template<int M, class EL , int CSL, int RSL, class ER , int RSR>
bool	operator== (const Mat< M, M, EL, CSL, RSL > &l, const SymMat< M, ER, RSR > &r)
template<int M, class EL , int CSL, int RSL, class ER , int RSR>
bool	operator!= (const Mat< M, M, EL, CSL, RSL > &l, const SymMat< M, ER, RSR > &r)
template<int M, class EL , int RSL, class ER , int CSR, int RSR>
bool	operator== (const SymMat< M, EL, RSL > &l, const Mat< M, M, ER, CSR, RSR > &r)
template<int M, class EL , int RSL, class ER , int CSR, int RSR>
bool	operator!= (const SymMat< M, EL, RSL > &l, const Mat< M, M, ER, CSR, RSR > &r)
template<int M, class E1 , int S1, class E2 , int S2>
CNT< typename CNT< E1 >::THerm >::template Result< E2 >::Mul	dot (const Vec< M, E1, S1 > &r, const Vec< M, E2, S2 > &v)
template<class E1 , int S1, class E2 , int S2>
CNT< typename CNT< E1 >::THerm >::template Result< E2 >::Mul	dot (const Vec< 1, E1, S1 > &r, const Vec< 1, E2, S2 > &v)
template<int N, class E1 , int S1, class E2 , int S2>
CNT< E1 >::template Result< E2 >::Mul	operator* (const Row< N, E1, S1 > &r, const Vec< N, E2, S2 > &v)
template<class E1 , int S1, class E2 , int S2>
CNT< E1 >::template Result< E2 >::Mul	operator* (const Row< 1, E1, S1 > &r, const Vec< 1, E2, S2 > &v)
template<int N, class E1 , int S1, class E2 , int S2>
CNT< E1 >::template Result< E2 >::Mul	dot (const Row< N, E1, S1 > &r, const Vec< N, E2, S2 > &v)
template<int M, class E1 , int S1, class E2 , int S2>
CNT< E1 >::template Result< E2 >::Mul	dot (const Vec< M, E1, S1 > &v, const Row< M, E2, S2 > &r)
template<int N, class E1 , int S1, class E2 , int S2>
CNT< E1 >::template Result< E2 >::Mul	dot (const Row< N, E1, S1 > &r, const Row< N, E2, S2 > &s)
template<int M, class E1 , int S1, class E2 , int S2>
Mat< M, M, typename CNT< E1 >::template Result< typename CNT< E2 >::THerm >::Mul >	outer (const Vec< M, E1, S1 > &v, const Vec< M, E2, S2 > &w)
template<int M, class E1 , int S1, class E2 , int S2>
Vec< M, E1, S1 >::template Result< Row< M, E2, S2 > >::Mul	operator* (const Vec< M, E1, S1 > &v, const Row< M, E2, S2 > &r)
template<int M, class E1 , int S1, class E2 , int S2>
Mat< M, M, typename CNT< E1 >::template Result< E2 >::Mul >	outer (const Vec< M, E1, S1 > &v, const Row< M, E2, S2 > &r)
template<int M, class E1 , int S1, class E2 , int S2>
Mat< M, M, typename CNT< E1 >::template Result< E2 >::Mul >	outer (const Row< M, E1, S1 > &r, const Vec< M, E2, S2 > &v)
template<int M, class E1 , int S1, class E2 , int S2>
Mat< M, M, typename CNT< E1 >::template Result< E2 >::Mul >	outer (const Row< M, E1, S1 > &r, const Row< M, E2, S2 > &s)
template<int M, int N, class ME , int CS, int RS, class E , int S>
Mat< M, N, ME, CS, RS >::template Result< Vec< N, E, S > >::Mul	operator* (const Mat< M, N, ME, CS, RS > &m, const Vec< N, E, S > &v)
template<int M, class E , int S, int N, class ME , int CS, int RS>
Row< M, E, S >::template Result< Mat< M, N, ME, CS, RS > >::Mul	operator* (const Row< M, E, S > &r, const Mat< M, N, ME, CS, RS > &m)
template<int N, class ME , int RS, class E , int S>
SymMat< N, ME, RS >::template Result< Vec< N, E, S > >::Mul	operator* (const SymMat< N, ME, RS > &m, const Vec< N, E, S > &v)
template<class ME , int RS, class E , int S>
SymMat< 1, ME, RS >::template Result< Vec< 1, E, S > >::Mul	operator* (const SymMat< 1, ME, RS > &m, const Vec< 1, E, S > &v)
template<class ME , int RS, class E , int S>
SymMat< 2, ME, RS >::template Result< Vec< 2, E, S > >::Mul	operator* (const SymMat< 2, ME, RS > &m, const Vec< 2, E, S > &v)
template<class ME , int RS, class E , int S>
SymMat< 3, ME, RS >::template Result< Vec< 3, E, S > >::Mul	operator* (const SymMat< 3, ME, RS > &m, const Vec< 3, E, S > &v)
template<int M, class E , int S, class ME , int RS>
Row< M, E, S >::template Result< SymMat< M, ME, RS > >::Mul	operator* (const Row< M, E, S > &r, const SymMat< M, ME, RS > &m)
template<class E , int S, class ME , int RS>
Row< 1, E, S >::template Result< SymMat< 1, ME, RS > >::Mul	operator* (const Row< 1, E, S > &r, const SymMat< 1, ME, RS > &m)
template<class E , int S, class ME , int RS>
Row< 2, E, S >::template Result< SymMat< 2, ME, RS > >::Mul	operator* (const Row< 2, E, S > &r, const SymMat< 2, ME, RS > &m)
template<class E , int S, class ME , int RS>
Row< 3, E, S >::template Result< SymMat< 3, ME, RS > >::Mul	operator* (const Row< 3, E, S > &r, const SymMat< 3, ME, RS > &m)
template<int M, class E1 , int S1, int N, class E2 , int S2>
Vec< M, E1, S1 >::template Result< Row< N, E2, S2 > >::MulNon	operator* (const Vec< M, E1, S1 > &v, const Row< N, E2, S2 > &r)
template<int M, class E1 , int S1, int MM, int NN, class E2 , int CS2, int RS2>
Vec< M, E1, S1 >::template Result< Mat< MM, NN, E2, CS2, RS2 > >::MulNon	operator* (const Vec< M, E1, S1 > &v, const Mat< MM, NN, E2, CS2, RS2 > &m)
template<int M, class E1 , int S1, int MM, class E2 , int RS2>
Vec< M, E1, S1 >::template Result< SymMat< MM, E2, RS2 > >::MulNon	operator* (const Vec< M, E1, S1 > &v, const SymMat< MM, E2, RS2 > &m)
template<int M, class E1 , int S1, int MM, class E2 , int S2>
Vec< M, E1, S1 >::template Result< Vec< MM, E2, S2 > >::MulNon	operator* (const Vec< M, E1, S1 > &v1, const Vec< MM, E2, S2 > &v2)
template<int M, class E , int S, int MM, int NN, class ME , int CS, int RS>
Row< M, E, S >::template Result< Mat< MM, NN, ME, CS, RS > >::MulNon	operator* (const Row< M, E, S > &r, const Mat< MM, NN, ME, CS, RS > &m)
template<int N, class E1 , int S1, int M, class E2 , int S2>
Row< N, E1, S1 >::template Result< Vec< M, E2, S2 > >::MulNon	operator* (const Row< N, E1, S1 > &r, const Vec< M, E2, S2 > &v)
template<int N1, class E1 , int S1, int N2, class E2 , int S2>
Row< N1, E1, S1 >::template Result< Row< N2, E2, S2 > >::MulNon	operator* (const Row< N1, E1, S1 > &r1, const Row< N2, E2, S2 > &r2)
template<int M, int N, class ME , int CS, int RS, int MM, class E , int S>
Mat< M, N, ME, CS, RS >::template Result< Vec< MM, E, S > >::MulNon	operator* (const Mat< M, N, ME, CS, RS > &m, const Vec< MM, E, S > &v)
template<int M, int N, class ME , int CS, int RS, int NN, class E , int S>
Mat< M, N, ME, CS, RS >::template Result< Row< NN, E, S > >::MulNon	operator* (const Mat< M, N, ME, CS, RS > &m, const Row< NN, E, S > &r)
template<int M, int N, class ME , int CS, int RS, int Dim, class E , int S>
Mat< M, N, ME, CS, RS >::template Result< SymMat< Dim, E, S > >::MulNon	operator* (const Mat< M, N, ME, CS, RS > &m, const SymMat< Dim, E, S > &sy)
template<class E1 , int S1, class E2 , int S2>
Vec< 3, typename CNT< E1 >::template Result< E2 >::Mul >	cross (const Vec< 3, E1, S1 > &a, const Vec< 3, E2, S2 > &b)
template<class E1 , int S1, class E2 , int S2>
Vec< 3, typename CNT< E1 >::template Result< E2 >::Mul >	operator% (const Vec< 3, E1, S1 > &a, const Vec< 3, E2, S2 > &b)
template<class E1 , int S1, class E2 , int S2>
Row< 3, typename CNT< E1 >::template Result< E2 >::Mul >	cross (const Vec< 3, E1, S1 > &a, const Row< 3, E2, S2 > &b)
template<class E1 , int S1, class E2 , int S2>
Row< 3, typename CNT< E1 >::template Result< E2 >::Mul >	operator% (const Vec< 3, E1, S1 > &a, const Row< 3, E2, S2 > &b)
template<class E1 , int S1, class E2 , int S2>
Row< 3, typename CNT< E1 >::template Result< E2 >::Mul >	cross (const Row< 3, E1, S1 > &a, const Vec< 3, E2, S2 > &b)
template<class E1 , int S1, class E2 , int S2>
Row< 3, typename CNT< E1 >::template Result< E2 >::Mul >	operator% (const Row< 3, E1, S1 > &a, const Vec< 3, E2, S2 > &b)
template<class E1 , int S1, class E2 , int S2>
Row< 3, typename CNT< E1 >::template Result< E2 >::Mul >	cross (const Row< 3, E1, S1 > &a, const Row< 3, E2, S2 > &b)
template<class E1 , int S1, class E2 , int S2>
Row< 3, typename CNT< E1 >::template Result< E2 >::Mul >	operator% (const Row< 3, E1, S1 > &a, const Row< 3, E2, S2 > &b)
template<class E1 , int S1, int N, class E2 , int CS, int RS>
Mat< 3, N, typename CNT< E1 >::template Result< E2 >::Mul >	cross (const Vec< 3, E1, S1 > &v, const Mat< 3, N, E2, CS, RS > &m)
template<class E1 , int S1, int N, class E2 , int CS, int RS>
Mat< 3, N, typename CNT< E1 >::template Result< E2 >::Mul >	operator% (const Vec< 3, E1, S1 > &v, const Mat< 3, N, E2, CS, RS > &m)
template<class E1 , int S1, int N, class E2 , int S2, int S3>
Row< N, Vec< 3, typename CNT< E1 >::template Result< E2 >::Mul > >	cross (const Vec< 3, E1, S1 > &v, const Row< N, Vec< 3, E2, S2 >, S3 > &m)
template<class E1 , int S1, class E2 , int S2, int S3>
Row< 3, Vec< 3, typename CNT< E1 >::template Result< E2 >::Mul > >	cross (const Vec< 3, E1, S1 > &v, const Row< 3, Vec< 3, E2, S2 >, S3 > &m)
template<class E1 , int S1, int N, class E2 , int S2, int S3>
Row< N, Vec< 3, typename CNT< E1 >::template Result< E2 >::Mul > >	operator% (const Vec< 3, E1, S1 > &v, const Row< N, Vec< 3, E2, S2 >, S3 > &m)
template<class E1 , int S1, class E2 , int S2, int S3>
Row< 3, Vec< 3, typename CNT< E1 >::template Result< E2 >::Mul > >	operator% (const Vec< 3, E1, S1 > &v, const Row< 3, Vec< 3, E2, S2 >, S3 > &m)
template<class EV , int SV, class EM , int RS>
Mat< 3, 3, typename CNT< EV >::template Result< EM >::Mul >	cross (const Vec< 3, EV, SV > &v, const SymMat< 3, EM, RS > &s)
template<class EV , int SV, class EM , int RS>
Mat< 3, 3, typename CNT< EV >::template Result< EM >::Mul >	operator% (const Vec< 3, EV, SV > &v, const SymMat< 3, EM, RS > &s)
template<class E1 , int S1, int N, class E2 , int CS, int RS>
Mat< 3, N, typename CNT< E1 >::template Result< E2 >::Mul >	cross (const Row< 3, E1, S1 > &r, const Mat< 3, N, E2, CS, RS > &m)
template<class E1 , int S1, int N, class E2 , int CS, int RS>
Mat< 3, N, typename CNT< E1 >::template Result< E2 >::Mul >	operator% (const Row< 3, E1, S1 > &r, const Mat< 3, N, E2, CS, RS > &m)
template<class EV , int SV, class EM , int RS>
Mat< 3, 3, typename CNT< EV >::template Result< EM >::Mul >	cross (const Row< 3, EV, SV > &r, const SymMat< 3, EM, RS > &s)
template<class EV , int SV, class EM , int RS>
Mat< 3, 3, typename CNT< EV >::template Result< EM >::Mul >	operator% (const Row< 3, EV, SV > &r, const SymMat< 3, EM, RS > &s)
template<int M, class EM , int CS, int RS, class EV , int S>
Mat< M, 3, typename CNT< EM >::template Result< EV >::Mul >	cross (const Mat< M, 3, EM, CS, RS > &m, const Vec< 3, EV, S > &v)
template<int M, class EM , int CS, int RS, class EV , int S>
Mat< M, 3, typename CNT< EM >::template Result< EV >::Mul >	operator% (const Mat< M, 3, EM, CS, RS > &m, const Vec< 3, EV, S > &v)
template<class EM , int RS, class EV , int SV>
Mat< 3, 3, typename CNT< EM >::template Result< EV >::Mul >	cross (const SymMat< 3, EM, RS > &s, const Vec< 3, EV, SV > &v)
template<class EM , int RS, class EV , int SV>
Mat< 3, 3, typename CNT< EM >::template Result< EV >::Mul >	operator% (const SymMat< 3, EM, RS > &s, const Vec< 3, EV, SV > &v)
template<int M, class EM , int CS, int RS, class ER , int S>
Mat< M, 3, typename CNT< EM >::template Result< ER >::Mul >	cross (const Mat< M, 3, EM, CS, RS > &m, const Row< 3, ER, S > &r)
template<int M, class EM , int CS, int RS, class ER , int S>
Mat< M, 3, typename CNT< EM >::template Result< ER >::Mul >	operator% (const Mat< M, 3, EM, CS, RS > &m, const Row< 3, ER, S > &r)
template<class EM , int RS, class EV , int SV>
Mat< 3, 3, typename CNT< EM >::template Result< EV >::Mul >	cross (const SymMat< 3, EM, RS > &s, const Row< 3, EV, SV > &r)
template<class EM , int RS, class EV , int SV>
Mat< 3, 3, typename CNT< EM >::template Result< EV >::Mul >	operator% (const SymMat< 3, EM, RS > &s, const Row< 3, EV, SV > &r)
template<class E1 , int S1, class E2 , int S2>
CNT< E1 >::template Result< E2 >::Mul	cross (const Vec< 2, E1, S1 > &a, const Vec< 2, E2, S2 > &b)
template<class E1 , int S1, class E2 , int S2>
CNT< E1 >::template Result< E2 >::Mul	operator% (const Vec< 2, E1, S1 > &a, const Vec< 2, E2, S2 > &b)
template<class E1 , int S1, class E2 , int S2>
CNT< E1 >::template Result< E2 >::Mul	cross (const Row< 2, E1, S1 > &a, const Vec< 2, E2, S2 > &b)
template<class E1 , int S1, class E2 , int S2>
CNT< E1 >::template Result< E2 >::Mul	operator% (const Row< 2, E1, S1 > &a, const Vec< 2, E2, S2 > &b)
template<class E1 , int S1, class E2 , int S2>
CNT< E1 >::template Result< E2 >::Mul	cross (const Vec< 2, E1, S1 > &a, const Row< 2, E2, S2 > &b)
template<class E1 , int S1, class E2 , int S2>
CNT< E1 >::template Result< E2 >::Mul	operator% (const Vec< 2, E1, S1 > &a, const Row< 2, E2, S2 > &b)
template<class E1 , int S1, class E2 , int S2>
CNT< E1 >::template Result< E2 >::Mul	cross (const Row< 2, E1, S1 > &a, const Row< 2, E2, S2 > &b)
template<class E1 , int S1, class E2 , int S2>
CNT< E1 >::template Result< E2 >::Mul	operator% (const Row< 2, E1, S1 > &a, const Row< 2, E2, S2 > &b)
template<class E , int S>
Mat< 3, 3, E >	crossMat (const Vec< 3, E, S > &v)
	Calculate matrix M(v) such that M(v)*w = v % w. More...
template<class E , int S>
Mat< 3, 3, E >	crossMat (const Vec< 3, negator< E >, S > &v)
	Specialize crossMat() for negated scalar types. More...
template<class E , int S>
Mat< 3, 3, E >	crossMat (const Row< 3, E, S > &r)
	Form cross product matrix from a Row vector; 3 flops. More...
template<class E , int S>
Mat< 3, 3, E >	crossMat (const Row< 3, negator< E >, S > &r)
	Form cross product matrix from a Row vector whose elements are negated scalars; 3 flops. More...
template<class E , int S>
Row< 2, E >	crossMat (const Vec< 2, E, S > &v)
	Calculate 2D cross product matrix M(v) such that M(v)*w = v0*w1-v1*w0 = v % w (a scalar). More...
template<class E , int S>
Row< 2, E >	crossMat (const Vec< 2, negator< E >, S > &v)
	Specialize 2D cross product matrix for negated scalar types; 1 flop. More...
template<class E , int S>
Row< 2, E >	crossMat (const Row< 2, E, S > &r)
	Form 2D cross product matrix from a Row<2>; 1 flop. More...
template<class E , int S>
Row< 2, E >	crossMat (const Row< 2, negator< E >, S > &r)
	Form 2D cross product matrix from a Row<2> with negated scalar elements; 1 flop. More...
template<class E , int S>
SymMat< 3, E >	crossMatSq (const Vec< 3, E, S > &v)
	Calculate matrix S(v) such that S(v)*w = -v % (v % w) = (v % w) % v. More...
template<class E , int S>
SymMat< 3, E >	crossMatSq (const Vec< 3, negator< E >, S > &v)
template<class E , int S>
SymMat< 3, E >	crossMatSq (const Row< 3, E, S > &r)
template<class E , int S>
SymMat< 3, E >	crossMatSq (const Row< 3, negator< E >, S > &r)
template<class E , int CS, int RS>
E	det (const Mat< 1, 1, E, CS, RS > &m)
	Special case Mat 1x1 determinant. No computation. More...
template<class E , int RS>
E	det (const SymMat< 1, E, RS > &s)
	Special case SymMat 1x1 determinant. No computation. More...
template<class E , int CS, int RS>
E	det (const Mat< 2, 2, E, CS, RS > &m)
	Special case Mat 2x2 determinant. 3 flops (if elements are Real). More...
template<class E , int RS>
E	det (const SymMat< 2, E, RS > &s)
	Special case 2x2 SymMat determinant. 3 flops (if elements are Real). More...
template<class E , int CS, int RS>
E	det (const Mat< 3, 3, E, CS, RS > &m)
	Special case Mat 3x3 determinant. 14 flops (if elements are Real). More...
template<class E , int RS>
E	det (const SymMat< 3, E, RS > &s)
	Special case SymMat 3x3 determinant. 14 flops (if elements are Real). More...
template<int M, class E , int CS, int RS>
E	det (const Mat< M, M, E, CS, RS > &m)
	Calculate the determinant of a square matrix larger than 3x3 by recursive template expansion. More...
template<int M, class E , int RS>
E	det (const SymMat< M, E, RS > &s)
	Determinant of SymMat larger than 3x3. More...
template<class E , int CS, int RS>
Mat< 1, 1, E, CS, RS >::TInvert	lapackInverse (const Mat< 1, 1, E, CS, RS > &m)
	Specialized 1x1 lapackInverse(): costs one divide. More...
template<int M, class E , int CS, int RS>
Mat< M, M, E, CS, RS >::TInvert	lapackInverse (const Mat< M, M, E, CS, RS > &m)
	General inverse of small, fixed-size, square (mXm), non-singular matrix with scalar elements: use Lapack's LU routine with pivoting. More...
template<class E , int CS, int RS>
Mat< 1, 1, E, CS, RS >::TInvert	inverse (const Mat< 1, 1, E, CS, RS > &m)
	Specialized 1x1 Mat inverse: costs one divide. More...
template<class E , int RS>
SymMat< 1, E, RS >::TInvert	inverse (const SymMat< 1, E, RS > &s)
	Specialized 1x1 SymMat inverse: costs one divide. More...
template<class E , int CS, int RS>
Mat< 2, 2, E, CS, RS >::TInvert	inverse (const Mat< 2, 2, E, CS, RS > &m)
	Specialized 2x2 Mat inverse: costs one divide plus 9 flops. More...
template<class E , int RS>
SymMat< 2, E, RS >::TInvert	inverse (const SymMat< 2, E, RS > &s)
	Specialized 2x2 SymMat inverse: costs one divide plus 7 flops. More...
template<class E , int CS, int RS>
Mat< 3, 3, E, CS, RS >::TInvert	inverse (const Mat< 3, 3, E, CS, RS > &m)
	Specialized 3x3 inverse: costs one divide plus 41 flops (for real-valued matrices). More...
template<class E , int RS>
SymMat< 3, E, RS >::TInvert	inverse (const SymMat< 3, E, RS > &s)
	Specialized 3x3 inverse for symmetric or Hermitian: costs one divide plus 29 flops (for real-valued matrices). More...
template<int M, class E , int CS, int RS>
Mat< M, M, E, CS, RS >::TInvert	inverse (const Mat< M, M, E, CS, RS > &m)
	For any matrix larger than 3x3, we just punt to the Lapack implementation. More...
template<int M, class E1 , int S1, class E2 , int S2>
SymMat< M, E1, S1 >::template Result< SymMat< M, E2, S2 > >::Add	operator+ (const SymMat< M, E1, S1 > &l, const SymMat< M, E2, S2 > &r)
template<int M, class E1 , int S1, class E2 , int S2>
SymMat< M, E1, S1 >::template Result< SymMat< M, E2, S2 > >::Sub	operator- (const SymMat< M, E1, S1 > &l, const SymMat< M, E2, S2 > &r)
template<int M, class E1 , int S1, class E2 , int S2>
SymMat< M, E1, S1 >::template Result< SymMat< M, E2, S2 > >::Mul	operator* (const SymMat< M, E1, S1 > &l, const SymMat< M, E2, S2 > &r)
template<int M, class E1 , int S1, class E2 , int S2>
bool	operator== (const SymMat< M, E1, S1 > &l, const SymMat< M, E2, S2 > &r)
template<int M, class E1 , int S1, class E2 , int S2>
bool	operator!= (const SymMat< M, E1, S1 > &l, const SymMat< M, E2, S2 > &r)
template<int M, class E , int S>
SymMat< M, E, S >::template Result< float >::Mul	operator* (const SymMat< M, E, S > &l, const float &r)
template<int M, class E , int S>
SymMat< M, E, S >::template Result< float >::Mul	operator* (const float &l, const SymMat< M, E, S > &r)
template<int M, class E , int S>
SymMat< M, E, S >::template Result< double >::Mul	operator* (const SymMat< M, E, S > &l, const double &r)
template<int M, class E , int S>
SymMat< M, E, S >::template Result< double >::Mul	operator* (const double &l, const SymMat< M, E, S > &r)
template<int M, class E , int S>
SymMat< M, E, S >::template Result< typename CNT< E >::Precision >::Mul	operator* (const SymMat< M, E, S > &l, int r)
template<int M, class E , int S>
SymMat< M, E, S >::template Result< typename CNT< E >::Precision >::Mul	operator* (int l, const SymMat< M, E, S > &r)
template<int M, class E , int S, class R >
SymMat< M, E, S >::template Result< std::complex< R > >::Mul	operator* (const SymMat< M, E, S > &l, const std::complex< R > &r)
template<int M, class E , int S, class R >
SymMat< M, E, S >::template Result< std::complex< R > >::Mul	operator* (const std::complex< R > &l, const SymMat< M, E, S > &r)
template<int M, class E , int S, class R >
SymMat< M, E, S >::template Result< std::complex< R > >::Mul	operator* (const SymMat< M, E, S > &l, const conjugate< R > &r)
template<int M, class E , int S, class R >
SymMat< M, E, S >::template Result< std::complex< R > >::Mul	operator* (const conjugate< R > &l, const SymMat< M, E, S > &r)
template<int M, class E , int S, class R >
SymMat< M, E, S >::template Result< typename negator< R >::StdNumber >::Mul	operator* (const SymMat< M, E, S > &l, const negator< R > &r)
template<int M, class E , int S, class R >
SymMat< M, E, S >::template Result< typename negator< R >::StdNumber >::Mul	operator* (const negator< R > &l, const SymMat< M, E, S > &r)
template<int M, class E , int S>
SymMat< M, E, S >::template Result< float >::Dvd	operator/ (const SymMat< M, E, S > &l, const float &r)
template<int M, class E , int S>
CNT< float >::template Result< SymMat< M, E, S > >::Dvd	operator/ (const float &l, const SymMat< M, E, S > &r)
template<int M, class E , int S>
SymMat< M, E, S >::template Result< double >::Dvd	operator/ (const SymMat< M, E, S > &l, const double &r)
template<int M, class E , int S>
CNT< double >::template Result< SymMat< M, E, S > >::Dvd	operator/ (const double &l, const SymMat< M, E, S > &r)
template<int M, class E , int S>
SymMat< M, E, S >::template Result< typename CNT< E >::Precision >::Dvd	operator/ (const SymMat< M, E, S > &l, int r)
template<int M, class E , int S>
CNT< typename CNT< E >::Precision >::template Result< SymMat< M, E, S > >::Dvd	operator/ (int l, const SymMat< M, E, S > &r)
template<int M, class E , int S, class R >
SymMat< M, E, S >::template Result< std::complex< R > >::Dvd	operator/ (const SymMat< M, E, S > &l, const std::complex< R > &r)
template<int M, class E , int S, class R >
CNT< std::complex< R > >::template Result< SymMat< M, E, S > >::Dvd	operator/ (const std::complex< R > &l, const SymMat< M, E, S > &r)
template<int M, class E , int S, class R >
SymMat< M, E, S >::template Result< std::complex< R > >::Dvd	operator/ (const SymMat< M, E, S > &l, const conjugate< R > &r)
template<int M, class E , int S, class R >
CNT< std::complex< R > >::template Result< SymMat< M, E, S > >::Dvd	operator/ (const conjugate< R > &l, const SymMat< M, E, S > &r)
template<int M, class E , int S, class R >
SymMat< M, E, S >::template Result< typename negator< R >::StdNumber >::Dvd	operator/ (const SymMat< M, E, S > &l, const negator< R > &r)
template<int M, class E , int S, class R >
CNT< R >::template Result< SymMat< M, E, S > >::Dvd	operator/ (const negator< R > &l, const SymMat< M, E, S > &r)
template<int M, class E , int S>
SymMat< M, E, S >::template Result< float >::Add	operator+ (const SymMat< M, E, S > &l, const float &r)
template<int M, class E , int S>
SymMat< M, E, S >::template Result< float >::Add	operator+ (const float &l, const SymMat< M, E, S > &r)
template<int M, class E , int S>
SymMat< M, E, S >::template Result< double >::Add	operator+ (const SymMat< M, E, S > &l, const double &r)
template<int M, class E , int S>
SymMat< M, E, S >::template Result< double >::Add	operator+ (const double &l, const SymMat< M, E, S > &r)
template<int M, class E , int S>
SymMat< M, E, S >::template Result< typename CNT< E >::Precision >::Add	operator+ (const SymMat< M, E, S > &l, int r)
template<int M, class E , int S>
SymMat< M, E, S >::template Result< typename CNT< E >::Precision >::Add	operator+ (int l, const SymMat< M, E, S > &r)
template<int M, class E , int S, class R >
SymMat< M, E, S >::template Result< std::complex< R > >::Add	operator+ (const SymMat< M, E, S > &l, const std::complex< R > &r)
template<int M, class E , int S, class R >
SymMat< M, E, S >::template Result< std::complex< R > >::Add	operator+ (const std::complex< R > &l, const SymMat< M, E, S > &r)
template<int M, class E , int S, class R >
SymMat< M, E, S >::template Result< std::complex< R > >::Add	operator+ (const SymMat< M, E, S > &l, const conjugate< R > &r)
template<int M, class E , int S, class R >
SymMat< M, E, S >::template Result< std::complex< R > >::Add	operator+ (const conjugate< R > &l, const SymMat< M, E, S > &r)
template<int M, class E , int S, class R >
SymMat< M, E, S >::template Result< typename negator< R >::StdNumber >::Add	operator+ (const SymMat< M, E, S > &l, const negator< R > &r)
template<int M, class E , int S, class R >
SymMat< M, E, S >::template Result< typename negator< R >::StdNumber >::Add	operator+ (const negator< R > &l, const SymMat< M, E, S > &r)
template<int M, class E , int S>
SymMat< M, E, S >::template Result< float >::Sub	operator- (const SymMat< M, E, S > &l, const float &r)
template<int M, class E , int S>
CNT< float >::template Result< SymMat< M, E, S > >::Sub	operator- (const float &l, const SymMat< M, E, S > &r)
template<int M, class E , int S>
SymMat< M, E, S >::template Result< double >::Sub	operator- (const SymMat< M, E, S > &l, const double &r)
template<int M, class E , int S>
CNT< double >::template Result< SymMat< M, E, S > >::Sub	operator- (const double &l, const SymMat< M, E, S > &r)
template<int M, class E , int S>
SymMat< M, E, S >::template Result< typename CNT< E >::Precision >::Sub	operator- (const SymMat< M, E, S > &l, int r)
template<int M, class E , int S>
CNT< typename CNT< E >::Precision >::template Result< SymMat< M, E, S > >::Sub	operator- (int l, const SymMat< M, E, S > &r)
template<int M, class E , int S, class R >
SymMat< M, E, S >::template Result< std::complex< R > >::Sub	operator- (const SymMat< M, E, S > &l, const std::complex< R > &r)
template<int M, class E , int S, class R >
CNT< std::complex< R > >::template Result< SymMat< M, E, S > >::Sub	operator- (const std::complex< R > &l, const SymMat< M, E, S > &r)
template<int M, class E , int S, class R >
SymMat< M, E, S >::template Result< std::complex< R > >::Sub	operator- (const SymMat< M, E, S > &l, const conjugate< R > &r)
template<int M, class E , int S, class R >
CNT< std::complex< R > >::template Result< SymMat< M, E, S > >::Sub	operator- (const conjugate< R > &l, const SymMat< M, E, S > &r)
template<int M, class E , int S, class R >
SymMat< M, E, S >::template Result< typename negator< R >::StdNumber >::Sub	operator- (const SymMat< M, E, S > &l, const negator< R > &r)
template<int M, class E , int S, class R >
CNT< R >::template Result< SymMat< M, E, S > >::Sub	operator- (const negator< R > &l, const SymMat< M, E, S > &r)
template<int M, class E , int RS, class CHAR , class TRAITS >
std::basic_ostream< CHAR, TRAITS > &	operator<< (std::basic_ostream< CHAR, TRAITS > &o, const SymMat< M, E, RS > &m)
template<int M, class E , int RS, class CHAR , class TRAITS >
std::basic_istream< CHAR, TRAITS > &	operator>> (std::basic_istream< CHAR, TRAITS > &is, SymMat< M, E, RS > &m)
template<int M, class E1 , int S1, class E2 , int S2>
Vec< M, E1, S1 >::template Result< Vec< M, E2, S2 > >::Add	operator+ (const Vec< M, E1, S1 > &l, const Vec< M, E2, S2 > &r)
template<int M, class E1 , int S1, class E2 , int S2>
Vec< M, E1, S1 >::template Result< Vec< M, E2, S2 > >::Sub	operator- (const Vec< M, E1, S1 > &l, const Vec< M, E2, S2 > &r)
template<int M, class E1 , int S1, class E2 , int S2>
bool	operator== (const Vec< M, E1, S1 > &l, const Vec< M, E2, S2 > &r)
	bool = v1[i] == v2[i], for all elements i More...
template<int M, class E1 , int S1, class E2 , int S2>
bool	operator!= (const Vec< M, E1, S1 > &l, const Vec< M, E2, S2 > &r)
	bool = v1[i] != v2[i], for any element i More...
template<int M, class E1 , int S1, class E2 >
bool	operator== (const Vec< M, E1, S1 > &v, const E2 &e)
	bool = v[i] == e, for all elements v[i] and element e More...
template<int M, class E1 , int S1, class E2 >
bool	operator!= (const Vec< M, E1, S1 > &v, const E2 &e)
	bool = v[i] != e, for any element v[i] and element e More...
template<int M, class E1 , int S1, class E2 , int S2>
bool	operator< (const Vec< M, E1, S1 > &l, const Vec< M, E2, S2 > &r)
	bool = v1[i] < v2[i], for all elements i More...
template<int M, class E1 , int S1, class E2 >
bool	operator< (const Vec< M, E1, S1 > &v, const E2 &e)
	bool = v[i] < e, for all elements v[i] and element e More...
template<int M, class E1 , int S1, class E2 , int S2>
bool	operator> (const Vec< M, E1, S1 > &l, const Vec< M, E2, S2 > &r)
	bool = v1[i] > v2[i], for all elements i More...
template<int M, class E1 , int S1, class E2 >
bool	operator> (const Vec< M, E1, S1 > &v, const E2 &e)
	bool = v[i] > e, for all elements v[i] and element e More...
template<int M, class E1 , int S1, class E2 , int S2>
bool	operator<= (const Vec< M, E1, S1 > &l, const Vec< M, E2, S2 > &r)
	bool = v1[i] <= v2[i], for all elements i. More...
template<int M, class E1 , int S1, class E2 >
bool	operator<= (const Vec< M, E1, S1 > &v, const E2 &e)
	bool = v[i] <= e, for all elements v[i] and element e. More...
template<int M, class E1 , int S1, class E2 , int S2>
bool	operator>= (const Vec< M, E1, S1 > &l, const Vec< M, E2, S2 > &r)
	bool = v1[i] >= v2[i], for all elements i This is not the same as !(v1<v2). More...
template<int M, class E1 , int S1, class E2 >
bool	operator>= (const Vec< M, E1, S1 > &v, const E2 &e)
	bool = v[i] >= e, for all elements v[i] and element e. More...
template<int M, class E , int S>
Vec< M, E, S >::template Result< float >::Mul	operator* (const Vec< M, E, S > &l, const float &r)
template<int M, class E , int S>
Vec< M, E, S >::template Result< float >::Mul	operator* (const float &l, const Vec< M, E, S > &r)
template<int M, class E , int S>
Vec< M, E, S >::template Result< double >::Mul	operator* (const Vec< M, E, S > &l, const double &r)
template<int M, class E , int S>
Vec< M, E, S >::template Result< double >::Mul	operator* (const double &l, const Vec< M, E, S > &r)
template<int M, class E , int S>
Vec< M, E, S >::template Result< typename CNT< E >::Precision >::Mul	operator* (const Vec< M, E, S > &l, int r)
template<int M, class E , int S>
Vec< M, E, S >::template Result< typename CNT< E >::Precision >::Mul	operator* (int l, const Vec< M, E, S > &r)
template<int M, class E , int S, class R >
Vec< M, E, S >::template Result< std::complex< R > >::Mul	operator* (const Vec< M, E, S > &l, const std::complex< R > &r)
template<int M, class E , int S, class R >
Vec< M, E, S >::template Result< std::complex< R > >::Mul	operator* (const std::complex< R > &l, const Vec< M, E, S > &r)
template<int M, class E , int S, class R >
Vec< M, E, S >::template Result< std::complex< R > >::Mul	operator* (const Vec< M, E, S > &l, const conjugate< R > &r)
template<int M, class E , int S, class R >
Vec< M, E, S >::template Result< std::complex< R > >::Mul	operator* (const conjugate< R > &l, const Vec< M, E, S > &r)
template<int M, class E , int S, class R >
Vec< M, E, S >::template Result< typename negator< R >::StdNumber >::Mul	operator* (const Vec< M, E, S > &l, const negator< R > &r)
template<int M, class E , int S, class R >
Vec< M, E, S >::template Result< typename negator< R >::StdNumber >::Mul	operator* (const negator< R > &l, const Vec< M, E, S > &r)
template<int M, class E , int S>
Vec< M, E, S >::template Result< float >::Dvd	operator/ (const Vec< M, E, S > &l, const float &r)
template<int M, class E , int S>
CNT< float >::template Result< Vec< M, E, S > >::Dvd	operator/ (const float &l, const Vec< M, E, S > &r)
template<int M, class E , int S>
Vec< M, E, S >::template Result< double >::Dvd	operator/ (const Vec< M, E, S > &l, const double &r)
template<int M, class E , int S>
CNT< double >::template Result< Vec< M, E, S > >::Dvd	operator/ (const double &l, const Vec< M, E, S > &r)
template<int M, class E , int S>
Vec< M, E, S >::template Result< typename CNT< E >::Precision >::Dvd	operator/ (const Vec< M, E, S > &l, int r)
template<int M, class E , int S>
CNT< typename CNT< E >::Precision >::template Result< Vec< M, E, S > >::Dvd	operator/ (int l, const Vec< M, E, S > &r)
template<int M, class E , int S, class R >
Vec< M, E, S >::template Result< std::complex< R > >::Dvd	operator/ (const Vec< M, E, S > &l, const std::complex< R > &r)
template<int M, class E , int S, class R >
CNT< std::complex< R > >::template Result< Vec< M, E, S > >::Dvd	operator/ (const std::complex< R > &l, const Vec< M, E, S > &r)
template<int M, class E , int S, class R >
Vec< M, E, S >::template Result< std::complex< R > >::Dvd	operator/ (const Vec< M, E, S > &l, const conjugate< R > &r)
template<int M, class E , int S, class R >
CNT< std::complex< R > >::template Result< Vec< M, E, S > >::Dvd	operator/ (const conjugate< R > &l, const Vec< M, E, S > &r)
template<int M, class E , int S, class R >
Vec< M, E, S >::template Result< typename negator< R >::StdNumber >::Dvd	operator/ (const Vec< M, E, S > &l, const negator< R > &r)
template<int M, class E , int S, class R >
CNT< R >::template Result< Vec< M, E, S > >::Dvd	operator/ (const negator< R > &l, const Vec< M, E, S > &r)
template<int M, class E , int S>
Vec< M, E, S >::template Result< float >::Add	operator+ (const Vec< M, E, S > &l, const float &r)
template<int M, class E , int S>
Vec< M, E, S >::template Result< float >::Add	operator+ (const float &l, const Vec< M, E, S > &r)
template<int M, class E , int S>
Vec< M, E, S >::template Result< double >::Add	operator+ (const Vec< M, E, S > &l, const double &r)
template<int M, class E , int S>
Vec< M, E, S >::template Result< double >::Add	operator+ (const double &l, const Vec< M, E, S > &r)
template<int M, class E , int S>
Vec< M, E, S >::template Result< typename CNT< E >::Precision >::Add	operator+ (const Vec< M, E, S > &l, int r)
template<int M, class E , int S>
Vec< M, E, S >::template Result< typename CNT< E >::Precision >::Add	operator+ (int l, const Vec< M, E, S > &r)
template<int M, class E , int S, class R >
Vec< M, E, S >::template Result< std::complex< R > >::Add	operator+ (const Vec< M, E, S > &l, const std::complex< R > &r)
template<int M, class E , int S, class R >
Vec< M, E, S >::template Result< std::complex< R > >::Add	operator+ (const std::complex< R > &l, const Vec< M, E, S > &r)
template<int M, class E , int S, class R >
Vec< M, E, S >::template Result< std::complex< R > >::Add	operator+ (const Vec< M, E, S > &l, const conjugate< R > &r)
template<int M, class E , int S, class R >
Vec< M, E, S >::template Result< std::complex< R > >::Add	operator+ (const conjugate< R > &l, const Vec< M, E, S > &r)
template<int M, class E , int S, class R >
Vec< M, E, S >::template Result< typename negator< R >::StdNumber >::Add	operator+ (const Vec< M, E, S > &l, const negator< R > &r)
template<int M, class E , int S, class R >
Vec< M, E, S >::template Result< typename negator< R >::StdNumber >::Add	operator+ (const negator< R > &l, const Vec< M, E, S > &r)
template<int M, class E , int S>
Vec< M, E, S >::template Result< float >::Sub	operator- (const Vec< M, E, S > &l, const float &r)
template<int M, class E , int S>
CNT< float >::template Result< Vec< M, E, S > >::Sub	operator- (const float &l, const Vec< M, E, S > &r)
template<int M, class E , int S>
Vec< M, E, S >::template Result< double >::Sub	operator- (const Vec< M, E, S > &l, const double &r)
template<int M, class E , int S>
CNT< double >::template Result< Vec< M, E, S > >::Sub	operator- (const double &l, const Vec< M, E, S > &r)
template<int M, class E , int S>
Vec< M, E, S >::template Result< typename CNT< E >::Precision >::Sub	operator- (const Vec< M, E, S > &l, int r)
template<int M, class E , int S>
CNT< typename CNT< E >::Precision >::template Result< Vec< M, E, S > >::Sub	operator- (int l, const Vec< M, E, S > &r)
template<int M, class E , int S, class R >
Vec< M, E, S >::template Result< std::complex< R > >::Sub	operator- (const Vec< M, E, S > &l, const std::complex< R > &r)
template<int M, class E , int S, class R >
CNT< std::complex< R > >::template Result< Vec< M, E, S > >::Sub	operator- (const std::complex< R > &l, const Vec< M, E, S > &r)
template<int M, class E , int S, class R >
Vec< M, E, S >::template Result< std::complex< R > >::Sub	operator- (const Vec< M, E, S > &l, const conjugate< R > &r)
template<int M, class E , int S, class R >
CNT< std::complex< R > >::template Result< Vec< M, E, S > >::Sub	operator- (const conjugate< R > &l, const Vec< M, E, S > &r)
template<int M, class E , int S, class R >
Vec< M, E, S >::template Result< typename negator< R >::StdNumber >::Sub	operator- (const Vec< M, E, S > &l, const negator< R > &r)
template<int M, class E , int S, class R >
CNT< R >::template Result< Vec< M, E, S > >::Sub	operator- (const negator< R > &l, const Vec< M, E, S > &r)
template<int M, class E , int S, class CHAR , class TRAITS >
std::basic_ostream< CHAR, TRAITS > &	operator<< (std::basic_ostream< CHAR, TRAITS > &o, const Vec< M, E, S > &v)
template<int M, class E , int S, class CHAR , class TRAITS >
std::basic_istream< CHAR, TRAITS > &	operator>> (std::basic_istream< CHAR, TRAITS > &is, Vec< M, E, S > &v)
	Read a Vec from a stream as M elements separated by white space or by commas, optionally enclosed in () [] ~() or ~[]. More...
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (ContactSurfaceIndex)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (ContactId)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (ContactTypeId)
std::ostream &	operator<< (std::ostream &o, const Contact &c)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (ContactGeometryTypeId)
OrientedBoundingBox	operator* (const Transform &t, const OrientedBoundingBox &box)
static int	explicitODE_static (const CPodesSystem &sys, Real t, const Vector &y, Vector &fout)
static int	implicitODE_static (const CPodesSystem &sys, Real t, const Vector &y, const Vector &yp, Vector &fout)
static int	constraint_static (const CPodesSystem &sys, Real t, const Vector &y, Vector &cout)
static int	project_static (const CPodesSystem &sys, Real t, const Vector &ycur, Vector &corr, Real epsProj, Vector &err)
static int	quadrature_static (const CPodesSystem &sys, Real t, const Vector &y, Vector &qout)
static int	root_static (const CPodesSystem &sys, Real t, const Vector &y, const Vector &yp, Vector &gout)
static int	weight_static (const CPodesSystem &sys, const Vector &y, Vector &weights)
static void	errorHandler_static (const CPodesSystem &sys, int error_code, const char *module, const char *function, char *msg)
Global operators involving Matrix objects
These operators take MatrixBase arguments and produce Matrix_ results.
template<class E1 , class E2 >
Matrix_< typename CNT< E1 >::template Result< E2 >::Add >	operator+ (const MatrixBase< E1 > &l, const MatrixBase< E2 > &r)
template<class E >
Matrix_< E >	operator+ (const MatrixBase< E > &l, const typename CNT< E >::T &r)
template<class E >
Matrix_< E >	operator+ (const typename CNT< E >::T &l, const MatrixBase< E > &r)
template<class E1 , class E2 >
Matrix_< typename CNT< E1 >::template Result< E2 >::Sub >	operator- (const MatrixBase< E1 > &l, const MatrixBase< E2 > &r)
template<class E >
Matrix_< E >	operator- (const MatrixBase< E > &l, const typename CNT< E >::T &r)
template<class E >
Matrix_< E >	operator- (const typename CNT< E >::T &l, const MatrixBase< E > &r)
template<class E >
Matrix_< E >	operator* (const MatrixBase< E > &l, const typename CNT< E >::StdNumber &r)
template<class E >
Matrix_< E >	operator* (const typename CNT< E >::StdNumber &l, const MatrixBase< E > &r)
template<class E >
Matrix_< E >	operator/ (const MatrixBase< E > &l, const typename CNT< E >::StdNumber &r)
template<class E >
Matrix_< E >	operator* (const MatrixBase< E > &l, int r)
template<class E >
Matrix_< E >	operator* (int l, const MatrixBase< E > &r)
template<class E >
Matrix_< E >	operator/ (const MatrixBase< E > &l, int r)
Global operators involving Vector objects
These operators take VectorBase arguments and produce Vector_ results.
template<class E1 , class E2 >
Vector_< typename CNT< E1 >::template Result< E2 >::Add >	operator+ (const VectorBase< E1 > &l, const VectorBase< E2 > &r)
template<class E >
Vector_< E >	operator+ (const VectorBase< E > &l, const typename CNT< E >::T &r)
template<class E >
Vector_< E >	operator+ (const typename CNT< E >::T &l, const VectorBase< E > &r)
template<class E1 , class E2 >
Vector_< typename CNT< E1 >::template Result< E2 >::Sub >	operator- (const VectorBase< E1 > &l, const VectorBase< E2 > &r)
template<class E >
Vector_< E >	operator- (const VectorBase< E > &l, const typename CNT< E >::T &r)
template<class E >
Vector_< E >	operator- (const typename CNT< E >::T &l, const VectorBase< E > &r)
template<class E >
Vector_< E >	operator* (const VectorBase< E > &l, const typename CNT< E >::StdNumber &r)
template<class E >
Vector_< E >	operator* (const typename CNT< E >::StdNumber &l, const VectorBase< E > &r)
template<class E >
Vector_< E >	operator/ (const VectorBase< E > &l, const typename CNT< E >::StdNumber &r)
template<class E >
Vector_< E >	operator* (const VectorBase< E > &l, int r)
template<class E >
Vector_< E >	operator* (int l, const VectorBase< E > &r)
template<class E >
Vector_< E >	operator/ (const VectorBase< E > &l, int r)
template<class E1 , int M, class E2 , int S>
Vector_< typename CNT< E1 >::template Result< Vec< M, E2, S > >::Mul >	operator* (const VectorBase< E1 > &v, const Vec< M, E2, S > &s)
template<class E1 , int M, class E2 , int S>
Vector_< typename Vec< M, E2, S >::template Result< E1 >::Mul >	operator* (const Vec< M, E2, S > &s, const VectorBase< E1 > &v)
template<class E1 , int N, class E2 , int S>
Vector_< typename CNT< E1 >::template Result< Row< N, E2, S > >::Mul >	operator* (const VectorBase< E1 > &v, const Row< N, E2, S > &s)
template<class E1 , int N, class E2 , int S>
Vector_< typename Row< N, E2, S >::template Result< E1 >::Mul >	operator* (const Row< N, E2, S > &s, const VectorBase< E1 > &v)
template<class E1 , int M, int N, class E2 , int S1, int S2>
Vector_< typename CNT< E1 >::template Result< Mat< M, N, E2, S1, S2 > >::Mul >	operator* (const VectorBase< E1 > &v, const Mat< M, N, E2, S1, S2 > &s)
template<class E1 , int M, int N, class E2 , int S1, int S2>
Vector_< typename Mat< M, N, E2, S1, S2 >::template Result< E1 >::Mul >	operator* (const Mat< M, N, E2, S1, S2 > &s, const VectorBase< E1 > &v)
template<class E1 , int M, class E2 , int S>
Vector_< typename CNT< E1 >::template Result< SymMat< M, E2, S > >::Mul >	operator* (const VectorBase< E1 > &v, const SymMat< M, E2, S > &s)
template<class E1 , int M, class E2 , int S>
Vector_< typename SymMat< M, E2, S >::template Result< E1 >::Mul >	operator* (const SymMat< M, E2, S > &s, const VectorBase< E1 > &v)
Global operators involving RowVector objects
These operators take RowVectorBase arguments and produce RowVector_ results.
template<class E1 , class E2 >
RowVector_< typename CNT< E1 >::template Result< E2 >::Add >	operator+ (const RowVectorBase< E1 > &l, const RowVectorBase< E2 > &r)
template<class E >
RowVector_< E >	operator+ (const RowVectorBase< E > &l, const typename CNT< E >::T &r)
template<class E >
RowVector_< E >	operator+ (const typename CNT< E >::T &l, const RowVectorBase< E > &r)
template<class E1 , class E2 >
RowVector_< typename CNT< E1 >::template Result< E2 >::Sub >	operator- (const RowVectorBase< E1 > &l, const RowVectorBase< E2 > &r)
template<class E >
RowVector_< E >	operator- (const RowVectorBase< E > &l, const typename CNT< E >::T &r)
template<class E >
RowVector_< E >	operator- (const typename CNT< E >::T &l, const RowVectorBase< E > &r)
template<class E >
RowVector_< E >	operator* (const RowVectorBase< E > &l, const typename CNT< E >::StdNumber &r)
template<class E >
RowVector_< E >	operator* (const typename CNT< E >::StdNumber &l, const RowVectorBase< E > &r)
template<class E >
RowVector_< E >	operator/ (const RowVectorBase< E > &l, const typename CNT< E >::StdNumber &r)
template<class E >
RowVector_< E >	operator* (const RowVectorBase< E > &l, int r)
template<class E >
RowVector_< E >	operator* (int l, const RowVectorBase< E > &r)
template<class E >
RowVector_< E >	operator/ (const RowVectorBase< E > &l, int r)
template<class E1 , int M, class E2 , int S>
RowVector_< typename CNT< E1 >::template Result< Vec< M, E2, S > >::Mul >	operator* (const RowVectorBase< E1 > &v, const Vec< M, E2, S > &s)
template<class E1 , int M, class E2 , int S>
RowVector_< typename Vec< M, E2, S >::template Result< E1 >::Mul >	operator* (const Vec< M, E2, S > &s, const RowVectorBase< E1 > &v)
template<class E1 , int N, class E2 , int S>
RowVector_< typename CNT< E1 >::template Result< Row< N, E2, S > >::Mul >	operator* (const RowVectorBase< E1 > &v, const Row< N, E2, S > &s)
template<class E1 , int N, class E2 , int S>
RowVector_< typename Row< N, E2, S >::template Result< E1 >::Mul >	operator* (const Row< N, E2, S > &s, const RowVectorBase< E1 > &v)
template<class E1 , int M, int N, class E2 , int S1, int S2>
RowVector_< typename CNT< E1 >::template Result< Mat< M, N, E2, S1, S2 > >::Mul >	operator* (const RowVectorBase< E1 > &v, const Mat< M, N, E2, S1, S2 > &s)
template<class E1 , int M, int N, class E2 , int S1, int S2>
RowVector_< typename Mat< M, N, E2, S1, S2 >::template Result< E1 >::Mul >	operator* (const Mat< M, N, E2, S1, S2 > &s, const RowVectorBase< E1 > &v)
template<class E1 , int M, class E2 , int S>
RowVector_< typename CNT< E1 >::template Result< SymMat< M, E2, S > >::Mul >	operator* (const RowVectorBase< E1 > &v, const SymMat< M, E2, S > &s)
template<class E1 , int M, class E2 , int S>
RowVector_< typename SymMat< M, E2, S >::template Result< E1 >::Mul >	operator* (const SymMat< M, E2, S > &s, const RowVectorBase< E1 > &v)
Global operators involving mixed matrix, vector, and row vector objects
These operators take MatrixBase, VectorBase, and RowVectorBase arguments and produce Matrix_, Vector_, and RowVector_ results.
template<class E1 , class E2 >
CNT< E1 >::template Result< E2 >::Mul	operator* (const RowVectorBase< E1 > &r, const VectorBase< E2 > &v)
template<class E1 , class E2 >
Vector_< typename CNT< E1 >::template Result< E2 >::Mul >	operator* (const MatrixBase< E1 > &m, const VectorBase< E2 > &v)
template<class E1 , class E2 >
Matrix_< typename CNT< E1 >::template Result< E2 >::Mul >	operator* (const MatrixBase< E1 > &m1, const MatrixBase< E2 > &m2)

Variables
const Vec3	Black
	RGB=( 0, 0, 0) More...
const Vec3	Gray
	RGB=(.5,.5,.5) More...
const Vec3	Red
	RGB=( 1, 0, 0) More...
const Vec3	Green
	RGB=( 0, 1, 0) More...
const Vec3	Blue
	RGB=( 0, 0, 1) More...
const Vec3	Yellow
	RGB=( 1, 1, 0) More...
const Vec3	Orange
	RGB=( 1,.5, 0) More...
const Vec3	Magenta
	RGB=( 1, 0, 1) More...
const Vec3	Purple
	RGB=(.5, 0,.5) More...
const Vec3	Cyan
	RGB=( 0, 1, 1) More...
const Vec3	White
	RGB=( 1, 1, 1) More...
static const int	InvalidIndex = -1111111111
static const bool	Is64BitPlatform = detect64BitPlatform()
const int	LosslessNumDigitsReal
	This is the smallest number of decimal digits you should store in a text file if you want to be able to get exactly the same bit pattern back when you read it back in and convert the text to a Real value. More...
const CoordinateAxis::XCoordinateAxis	XAxis
	Constant representing the X coordinate axis; will implicitly convert to the integer 0 when used in a context requiring an integer. More...
const CoordinateAxis::YCoordinateAxis	YAxis
	Constant representing the Y coordinate axis; will implicitly convert to the integer 1 when used in a context requiring an integer. More...
const CoordinateAxis::ZCoordinateAxis	ZAxis
	Constant representing the Z coordinate axis; will implicitly convert to the integer 2 when used in a context requiring an integer. More...
const CoordinateDirection::NegXDirection	NegXAxis
	Global constant indicating -X coordinate direction. More...
const CoordinateDirection::NegYDirection	NegYAxis
	Global constant indicating -Y coordinate direction. More...
const CoordinateDirection::NegZDirection	NegZAxis
	Global constant indicating -Z coordinate direction. More...
const Real	NaN
	This is the IEEE "not a number" constant for this implementation of the default-precision Real type; be very careful using this because it has many strange properties such as not comparing equal to itself. More...
const Real	Infinity
	This is the IEEE positive infinity constant for this implementation of the default-precision Real type; -Infinity will produce the negative infinity constant. More...
const Real	Eps
	Epsilon is the size of roundoff noise; it is the smallest positive number of default-precision type Real such that 1+Eps != 1. More...
const Real	SqrtEps
	This is the square root of Eps, ~1e-8 if Real is double, ~3e-4 if Real is float. More...
const Real	TinyReal
	TinyReal is a floating point value smaller than the floating point precision; it is defined as Eps^(5/4) which is ~1e-20 for Real==double and ~1e-9 for float. More...
const Real	SignificantReal
	SignificantReal is the smallest value that we consider to be clearly distinct from roundoff error when it is the result of a computation; it is defined as Eps^(7/8) which is ~1e-14 when Real==double, ~1e-6 when Real==float. More...
const Real	LeastPositiveReal
	This is the smallest positive real number that can be expressed in the type Real; it is ~1e-308 when Real==double, ~1e-38 when Real==float. More...
const Real	MostPositiveReal
	This is the largest finite positive real number that can be expressed in the Real type; ~1e+308 when Real==double, ~1e+38 when Real==float. Note that there is also a value Infinity that will test larger than this one. More...
const Real	LeastNegativeReal
	This is the largest negative real number (that is, closest to zero) that can be expressed in values of type Real. More...
const Real	MostNegativeReal
	This is the smallest finite negative real number that can be expressed in values of type Real. Note that -Infinity is a value that will still test smaller than this one. More...
const int	NumDigitsReal
	This is the number of decimal digits that can be reliably stored and retrieved in the default Real precision (typically log10(1/eps)-1), that is, about 15 digits when Real==double and 6 digits when Real==float. More...
const Real	Zero
	Real(0) More...
const Real	One
	Real(1) More...
const Real	MinusOne
	Real(-1) More...
const Real	Two
	Real(2) More...
const Real	Three
	Real(3) More...
const Real	OneHalf
	Real(1)/2. More...
const Real	OneThird
	Real(1)/3. More...
const Real	OneFourth
	Real(1)/4. More...
const Real	OneFifth
	Real(1)/5. More...
const Real	OneSixth
	Real(1)/6. More...
const Real	OneSeventh
	Real(1)/7. More...
const Real	OneEighth
	Real(1)/8. More...
const Real	OneNinth
	Real(1)/9. More...
const Real	Pi
	Real(pi) More...
const Real	OneOverPi
	1/Real(pi) More...
const Real	E
	e = Real(exp(1)) More...
const Real	Log2E
	Real(log2(e)) (log base 2) More...
const Real	Log10E
	Real(log10(e)) (log base 10) More...
const Real	Sqrt2
	Real(sqrt(2)) More...
const Real	OneOverSqrt2
	1/sqrt(2)==sqrt(2)/2 as Real More...
const Real	Sqrt3
	Real(sqrt(3)) More...
const Real	OneOverSqrt3
	Real(1/sqrt(3)) More...
const Real	CubeRoot2
	Real(2^(1/3)) (cube root of 2) More...
const Real	CubeRoot3
	Real(3^(1/3)) (cube root of 3) More...
const Real	Ln2
	Real(ln(2)) (natural log of 2) More...
const Real	Ln10
	Real(ln(10)) (natural log of 10) More...
const Complex	I
	We only need one complex constant, i = sqrt(-1). For the rest just multiply the real constant by i, or convert with Complex(the Real constant), or if you need an address you can use NTraits<Complex>::getPi(), etc. More...
static const double	DefaultRecpCondition = 1e-12

Detailed Description

This is the top-level SimTK namespace into which all SimTK names are placed to avoid collision with other symbols.

This is a System that represents the dynamics of a particle moving along a smooth surface.

If you get tired of prefacing every symbol with "SimTK::", include the statement "using namespace SimTK;" at the beginning of your SimTK-using compilation units. Any names which cannot be put in the namespace (macro names, for example) begin with the prefix "SimTK_" instead.

It is used to integrate Geodesic curves along implicit surfaces. The particle on surface constraint is stabilized with coordinate projection. (Implementation based on PendulumSystem.h)

Typedef Documentation

ForceSubsystemRep

typedef ForceSubsystem::Guts SimTK::ForceSubsystemRep

VTKVisualizer

typedef Visualizer SimTK::VTKVisualizer

OBSOLETE: This provides limited backwards compatibility with the old VTK Visualizer that is no longer supported. Switch to Visualizer instead.

VTKEventReporter

typedef Visualizer::Reporter SimTK::VTKEventReporter

OBSOLETE: This provides limited backwards compatibility with the old VTK Visualizer that is no longer supported. Switch to Visualizer::Reporter instead.

Real

typedef SimTK_Real SimTK::Real

This is the default compiled-in floating point type for SimTK, either float or double.

See also

SimTK_DEFAULT_PRECISION

Complex

typedef std::complex<Real> SimTK::Complex

This is the default complex type for SimTK, with precision for the real and imaginary parts set to the compiled-in Real type.

See also

Real

fComplex

typedef std::complex<float> SimTK::fComplex

An abbreviation for std::complex<float> for consistency with others.

dComplex

typedef std::complex<double> SimTK::dComplex

An abbreviation for std::complex<double> for consistency with others.

Is64BitPlatformType

typedef Is64BitHelper<Is64BitPlatform>::Result SimTK::Is64BitPlatformType

Function

typedef Function_<Real> SimTK::Function

This typedef is used for the very common case that the return type of the Function object is Real.

fSpatialVec

typedef Vec<2, Vec<3,float> > SimTK::fSpatialVec

A SpatialVec that is always single (float) precision regardless of the compiled-in precision of Real.

dSpatialVec

typedef Vec<2, Vec<3,double> > SimTK::dSpatialVec

A SpatialVec that is always double precision regardless of the compiled-in precision of Real.

fSpatialRow

typedef Row<2, Row<3,float> > SimTK::fSpatialRow

A SpatialRow that is always single (float) precision regardless of the compiled-in precision of Real.

dSpatialRow

typedef Row<2, Row<3,double> > SimTK::dSpatialRow

A SpatialRow that is always double precision regardless of the compiled-in precision of Real.

fSpatialMat

typedef Mat<2,2, Mat<3,3,float> > SimTK::fSpatialMat

A SpatialMat that is always single (float) precision regardless of the compiled-in precision of Real.

dSpatialMat

typedef Mat<2,2, Mat<3,3,double> > SimTK::dSpatialMat

A SpatialMat that is always double precision regardless of the compiled-in precision of Real.

UnitInertia

typedef UnitInertia_<Real> SimTK::UnitInertia

A unit inertia (gyration) tensor at default precision.

fUnitInertia

typedef UnitInertia_<float> SimTK::fUnitInertia

A unit inertia (gyration) tensor at float precision.

dUnitInertia

typedef UnitInertia_<double> SimTK::dUnitInertia

A unit inertia (gyration) tensor at double precision.

Inertia

typedef Inertia_<Real> SimTK::Inertia

An inertia tensor at default precision.

fInertia

typedef Inertia_<float> SimTK::fInertia

An inertia tensor at float precision.

dInertia

typedef Inertia_<double> SimTK::dInertia

An inertia tensor at double precision.

MassProperties

typedef MassProperties_<Real> SimTK::MassProperties

Rigid body mass properties at default precision.

fMassProperties

typedef MassProperties_<float> SimTK::fMassProperties

Rigid body mass properties at float precision.

dMassProperties

typedef MassProperties_<double> SimTK::dMassProperties

Rigid body mass properties at double precision.

SpatialInertia

typedef SpatialInertia_<Real> SimTK::SpatialInertia

A spatial (rigid body) inertia matrix at default precision.

fSpatialInertia

typedef SpatialInertia_<float> SimTK::fSpatialInertia

A spatial (rigid body) inertia matrix at float precision.

dSpatialInertia

typedef SpatialInertia_<double> SimTK::dSpatialInertia

A spatial (rigid body) inertia matrix at double precision.

ArticulatedInertia

typedef ArticulatedInertia_<Real> SimTK::ArticulatedInertia

An articulated body inertia matrix at default precision.

fArticulatedInertia

typedef ArticulatedInertia_<float> SimTK::fArticulatedInertia

An articulated body inertia matrix at float precision.

dArticulatedInertia

typedef ArticulatedInertia_<double> SimTK::dArticulatedInertia

An articulated body inertia matrix at double precision.

Gyration

typedef UnitInertia SimTK::Gyration

For backwards compatibility only; use UnitInertia instead.

Quaternion

typedef Quaternion_<Real> SimTK::Quaternion

fQuaternion

typedef Quaternion_<float> SimTK::fQuaternion

dQuaternion

typedef Quaternion_<double> SimTK::dQuaternion

Rotation

typedef Rotation_<Real> SimTK::Rotation

fRotation

typedef Rotation_<float> SimTK::fRotation

dRotation

typedef Rotation_<double> SimTK::dRotation

InverseRotation

typedef InverseRotation_<Real> SimTK::InverseRotation

fInverseRotation

typedef InverseRotation_<float> SimTK::fInverseRotation

dInverseRotation

typedef InverseRotation_<double> SimTK::dInverseRotation

Transform

typedef Transform_<Real> SimTK::Transform

fTransform

typedef Transform_<float> SimTK::fTransform

dTransform

typedef Transform_<double> SimTK::dTransform

UnitVec3

typedef UnitVec<Real,1> SimTK::UnitVec3

fUnitVec3

typedef UnitVec<float,1> SimTK::fUnitVec3

dUnitVec3

typedef UnitVec<double,1> SimTK::dUnitVec3

Conjugate

typedef conjugate<Real> SimTK::Conjugate

Measure

typedef Measure_<Real> SimTK::Measure

This typedef is a convenient abbreviation for the most common kind of Measure – one that returns a single Real result; the underlying class is Measure_; look there for documentation.

StageVersion

typedef long long SimTK::StageVersion

This is the type to use for Stage version numbers that get incremented whenever a state variable change invalidates a Stage.

Whenever time or any state variable is modified, we increment the StageVersion for any Stage that gets invalidated. -1 means "uninitialized". 0 is never used as a StageVersion, but is allowed as a remembered StageVersion which is guaranteed never to look valid.

ValueVersion

typedef long long SimTK::ValueVersion

This is the type to use for state variable version numbers that get incremented whenever a state value changes.

Whenever time or any state variable is modified, we increment a version number for the state variable that changes, so that cache entries can have finer-grained prerequisites than just on whole stages. -1 means "uninitialized". 0 is never used as a ValueVersion, but is allowed as a remembered version which is guaranteed never to look valid.

CacheEntryKey

using SimTK::CacheEntryKey = typedef std::pair<SubsystemIndex,CacheEntryIndex>

DiscreteVarKey

using SimTK::DiscreteVarKey = typedef std::pair<SubsystemIndex,DiscreteVariableIndex>

Spline

typedef Spline_<Real> SimTK::Spline

Provide a convenient name for a scalar-valued Spline_.

Enumeration Type Documentation

CableSpanAlgorithm

enum SimTK::CableSpanAlgorithm

strong

Enumerator
Scholz2015	This is the original algorithm as described in: Scholz, A., Sherman, M., Stavness, I. et al (2015). A fast multi-obstacle muscle wrapping method using natural geodesic variations. Multibody System Dynamics 36, 195–219, DOI https://doi.org/10.1007/s11044-015-9451-1. The path error vector captures the misalignment of the straight line and curved segments at the contact points. The computation of the path is then done by driving this path error to zero (up to tolerance), such that all segments are smoothly connected, and the optimization step size converges to zero. A drawback of this algorithm is that it converges to any cable length optimum. This means that the cable might be of maximum length or minimal length.
MinimumLength	The Minimal length algorithm finds the optimal path by minimizing the total cable length directly, while enforcing the contour constraints. The first step is to describe the total cable length using a second order approximation: l(q) = l + ~g * q + ~q * H * q / 2 + ... where l is the total cable length, q is the vector of natural geodesic corrections (see Scholz2015 paper), g and H are the gradient and Hessian of l to q. For the constraints we use the normal path errors described in the Scholz2015 paper: c_i(q) = [ ~e_P * n_P ] [ ~e_Q * n_Q ] where c is the vector of constraints, c_i are the two constraint elements associated with the i-th curve segment, e_P is the direction of the straight line segment at the P frame, n_P is normal direction at the P-frame, and similarly for e_Q and n_Q. Taking the first order approximation of these constraints gives: c(q) = c + J * q + ... The optimization problem that is solved is then posed as: minimize l(q) subject to c(q) = 0 This problem is solved by repeatedly solving a Quadratic Program given by: [ Q J^T ] [ q ] [ -g ] [ J 0 ] * [ λ ] = [ -c ] where Q is a symmetric positive definite approximation of H, and λ are the lagrange multipliers. The approximation Q is used because H is itself not symmetric positive definite. Q is obtained from H by flipping the sign of any negative eigenvalues of H, to get a positive definite approximation. Consider the following eigen decomposition: (H + ~H)/2 = ~P D P Then Q is given as: Q = ~P abs(D) P For a comparison between Algorithm::Scholz2015 and this Algorithm::MinimumLength see https://github.com/simbody/simbody/pull/814.

BodyOrSpaceType

enum SimTK::BodyOrSpaceType

Enumerator
BodyRotationSequence
SpaceRotationSequence

anonymous enum

anonymous enum

Enumerator
SCALAR_DEPTH
SCALAR_COMPOSITE_DEPTH
COMPOSITE_COMPOSITE_DEPTH
COMPOSITE_3_DEPTH
MAX_RESOLVED_DEPTH

OptimizerAlgorithm

enum SimTK::OptimizerAlgorithm

The available Optimizer algorithms.

Gradient descent algorithms seek to find a local minimum, and are not guaranteed to find the global minimum. See the description of Optimizer for specific information about how to use the algorithms.

Enumerator
BestAvailable	Simmath will select best Optimizer based on problem type.
InteriorPoint	IpOpt algorithm (https://projects.coin-or.org/ipopt); gradient descent.
LBFGS	Limited-memory Broyden-Fletcher-Goldfarb-Shanno algorithm; gradient descent.
LBFGSB	LBFGS with simple bound constraints; gradient descent.
CFSQP	C implementation of sequential quadratic programming (requires external library: ftp://frcatel.fri.uniza.sk/pub/soft/math/matprog/doc/fsqp.html); gradient descent.
CMAES	Covariance matrix adaptation, evolution strategy (https://github.com/cma-es/c-cmaes); this is a randomized algorithm that attempts to find a global minimum.
UnknownOptimizerAlgorithm
UserSuppliedOptimizerAlgorithm	An algorithm that is implemented outside of Simmath.

Function Documentation

SimTK_DEFINE_UNIQUE_INDEX_TYPE() [1/63]

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

AssemblyConditionIndex

)

SimTK_DEFINE_UNIQUE_INDEX_TYPE() [2/63]

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

CableObstacleIndex

)

SimTK_DEFINE_UNIQUE_INDEX_TYPE() [3/63]

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

CableSpanObstacleIndex

)

SimTK_DEFINE_UNIQUE_INDEX_TYPE() [4/63]

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

CableSpanIndex

)

SimTK_DEFINE_UNIQUE_INDEX_TYPE() [5/63]

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

CablePathIndex

)

SimTK_DEFINE_UNIQUE_INDEX_TYPE() [6/63]

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

MobilizedBodyIndex

)

SimTK_DEFINE_UNIQUE_INDEX_TYPE() [7/63]

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

ConstraintIndex

)

SimTK_DEFINE_UNIQUE_INDEX_TYPE() [8/63]

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

UnilateralContactIndex

)

SimTK_DEFINE_UNIQUE_INDEX_TYPE() [9/63]

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

UnilateralSpeedConstraintIndex

)

SimTK_DEFINE_UNIQUE_INDEX_TYPE() [10/63]

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

BoundedSpeedConstraintIndex

)

SimTK_DEFINE_UNIQUE_INDEX_TYPE() [11/63]

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

ConstraintLimitedFrictionIndex

)

SimTK_DEFINE_UNIQUE_INDEX_TYPE() [12/63]

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

StateLimitedFrictionIndex

)

SimTK_DEFINE_UNIQUE_INDEX_TYPE() [13/63]

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

ParticleIndex

)

SimTK_DEFINE_UNIQUE_INDEX_TYPE() [14/63]

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

AncestorConstrainedBodyPoolIndex

)

SimTK_DEFINE_UNIQUE_INDEX_TYPE() [15/63]

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

USquaredIndex

)

SimTK_DEFINE_UNIQUE_INDEX_TYPE() [16/63]

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

QuaternionPoolIndex

)

SimTK_DEFINE_UNIQUE_INDEX_TYPE() [17/63]

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

MobodQPoolIndex

)

SimTK_DEFINE_UNIQUE_INDEX_TYPE() [18/63]

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

PresQPoolIndex

)

SimTK_DEFINE_UNIQUE_INDEX_TYPE() [19/63]

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

PresUPoolIndex

)

SimTK_DEFINE_UNIQUE_INDEX_TYPE() [20/63]

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

PresUDotPoolIndex

)

SimTK_DEFINE_UNIQUE_INDEX_TYPE() [21/63]

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

PresForcePoolIndex

)

SimTK_DEFINE_UNIQUE_INDEX_TYPE() [22/63]

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

MobilizerQIndex

)

SimTK_DEFINE_UNIQUE_INDEX_TYPE() [23/63]

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

MobilizerUIndex

)

SimTK_DEFINE_UNIQUE_INDEX_TYPE() [24/63]

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

ConstrainedBodyIndex

)

SimTK_DEFINE_UNIQUE_INDEX_TYPE() [25/63]

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

ConstrainedMobilizerIndex

)

SimTK_DEFINE_UNIQUE_INDEX_TYPE() [26/63]

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

ConstrainedQIndex

)

SimTK_DEFINE_UNIQUE_INDEX_TYPE() [27/63]

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

ConstrainedUIndex

)

SimTK_DEFINE_UNIQUE_INDEX_TYPE() [28/63]

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

ParticipatingQIndex

)

SimTK_DEFINE_UNIQUE_INDEX_TYPE() [29/63]

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

ParticipatingUIndex

)

SimTK_DEFINE_UNIQUE_INDEX_TYPE() [30/63]

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

SubtreeBodyIndex

)

SubtreeAncestorIndex()

static const SubtreeBodyIndex SimTK::SubtreeAncestorIndex ( 0  )

static

SimTK_DEFINE_UNIQUE_INDEX_TYPE() [31/63]

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

SubtreeQIndex

)

SimTK_DEFINE_UNIQUE_INDEX_TYPE() [32/63]

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

SubtreeUIndex

)

SimTK_DEFINE_UNIQUE_INDEX_TYPE() [33/63]

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

ForceIndex

)

SimTK_DEFINE_UNIQUE_INDEX_TYPE() [34/63]

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

ContactSetIndex

)

operator<<() [1/18]

std::ostream& SimTK::operator<< ( std::ostream &  o, const ContactForce &  f  )

inline

operator<<() [2/18]

std::ostream& SimTK::operator<< ( std::ostream &  o, const ContactDetail &  d  )

inline

SimTK_DEFINE_UNIQUE_INDEX_TYPE() [35/63]

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

ContactCliqueId

)

operator<<() [3/18]

std::ostream& SimTK::operator<< ( std::ostream &  o, const ContactSnapshot &  cs  )

inline

operator<<() [4/18]

std::ostream& SimTK::operator<<	(	std::ostream &	,
		const SimbodyMatterSubtree &
	)

operator<<() [5/18]

std::ostream& SimTK::operator<<	(	std::ostream &	,
		const SimbodyMatterSubtreeResults &
	)

operator+() [1/79]

template<class E1 , class E2 >

Matrix_<typename CNT<E1>::template Result<E2>::Add> SimTK::operator+	(	const MatrixBase< E1 > &	l,
		const MatrixBase< E2 > &	r
	)

operator+() [2/79]

template<class E >

Matrix_<E> SimTK::operator+	(	const MatrixBase< E > &	l,
		const typename CNT< E >::T &	r
	)

operator+() [3/79]

template<class E >

Matrix_<E> SimTK::operator+	(	const typename CNT< E >::T &	l,
		const MatrixBase< E > &	r
	)

operator-() [1/79]

template<class E1 , class E2 >

Matrix_<typename CNT<E1>::template Result<E2>::Sub> SimTK::operator-	(	const MatrixBase< E1 > &	l,
		const MatrixBase< E2 > &	r
	)

operator-() [2/79]

template<class E >

Matrix_<E> SimTK::operator-	(	const MatrixBase< E > &	l,
		const typename CNT< E >::T &	r
	)

operator-() [3/79]

template<class E >

Matrix_<E> SimTK::operator-	(	const typename CNT< E >::T &	l,
		const MatrixBase< E > &	r
	)

operator*() [1/161]

template<class E >

Matrix_<E> SimTK::operator*	(	const MatrixBase< E > &	l,
		const typename CNT< E >::StdNumber &	r
	)

operator*() [2/161]

template<class E >

Matrix_<E> SimTK::operator*	(	const typename CNT< E >::StdNumber &	l,
		const MatrixBase< E > &	r
	)

operator/() [1/76]

template<class E >

Matrix_<E> SimTK::operator/	(	const MatrixBase< E > &	l,
		const typename CNT< E >::StdNumber &	r
	)

operator*() [3/161]

template<class E >

Matrix_<E> SimTK::operator*	(	const MatrixBase< E > &	l,
		int	r
	)

operator*() [4/161]

template<class E >

Matrix_<E> SimTK::operator*	(	int	l,
		const MatrixBase< E > &	r
	)

operator/() [2/76]

template<class E >

Matrix_<E> SimTK::operator/	(	const MatrixBase< E > &	l,
		int	r
	)

operator+() [4/79]

template<class E1 , class E2 >

Vector_<typename CNT<E1>::template Result<E2>::Add> SimTK::operator+	(	const VectorBase< E1 > &	l,
		const VectorBase< E2 > &	r
	)

operator+() [5/79]

template<class E >

Vector_<E> SimTK::operator+	(	const VectorBase< E > &	l,
		const typename CNT< E >::T &	r
	)

operator+() [6/79]

template<class E >

Vector_<E> SimTK::operator+	(	const typename CNT< E >::T &	l,
		const VectorBase< E > &	r
	)

operator-() [4/79]

template<class E1 , class E2 >

Vector_<typename CNT<E1>::template Result<E2>::Sub> SimTK::operator-	(	const VectorBase< E1 > &	l,
		const VectorBase< E2 > &	r
	)

operator-() [5/79]

template<class E >

Vector_<E> SimTK::operator-	(	const VectorBase< E > &	l,
		const typename CNT< E >::T &	r
	)

operator-() [6/79]

template<class E >

Vector_<E> SimTK::operator-	(	const typename CNT< E >::T &	l,
		const VectorBase< E > &	r
	)

operator*() [5/161]

template<class E >

Vector_<E> SimTK::operator*	(	const VectorBase< E > &	l,
		const typename CNT< E >::StdNumber &	r
	)

operator*() [6/161]

template<class E >

Vector_<E> SimTK::operator*	(	const typename CNT< E >::StdNumber &	l,
		const VectorBase< E > &	r
	)

operator/() [3/76]

template<class E >

Vector_<E> SimTK::operator/	(	const VectorBase< E > &	l,
		const typename CNT< E >::StdNumber &	r
	)

operator*() [7/161]

template<class E >

Vector_<E> SimTK::operator*	(	const VectorBase< E > &	l,
		int	r
	)

operator*() [8/161]

template<class E >

Vector_<E> SimTK::operator*	(	int	l,
		const VectorBase< E > &	r
	)

operator/() [4/76]

template<class E >

Vector_<E> SimTK::operator/	(	const VectorBase< E > &	l,
		int	r
	)

operator*() [9/161]

template<class E1 , int M, class E2 , int S>

Vector_<typename CNT<E1>::template Result< Vec<M,E2,S> >::Mul> SimTK::operator*	(	const VectorBase< E1 > &	v,
		const Vec< M, E2, S > &	s
	)

operator*() [10/161]

template<class E1 , int M, class E2 , int S>

Vector_<typename Vec<M,E2,S>::template Result<E1>::Mul> SimTK::operator*	(	const Vec< M, E2, S > &	s,
		const VectorBase< E1 > &	v
	)

operator*() [11/161]

template<class E1 , int N, class E2 , int S>

Vector_<typename CNT<E1>::template Result< Row<N,E2,S> >::Mul> SimTK::operator*	(	const VectorBase< E1 > &	v,
		const Row< N, E2, S > &	s
	)

operator*() [12/161]

template<class E1 , int N, class E2 , int S>

Vector_<typename Row<N,E2,S>::template Result<E1>::Mul> SimTK::operator*	(	const Row< N, E2, S > &	s,
		const VectorBase< E1 > &	v
	)

operator*() [13/161]

template<class E1 , int M, int N, class E2 , int S1, int S2>

Vector_<typename CNT<E1>::template Result< Mat<M,N,E2,S1,S2> >::Mul> SimTK::operator*	(	const VectorBase< E1 > &	v,
		const Mat< M, N, E2, S1, S2 > &	s
	)

operator*() [14/161]

template<class E1 , int M, int N, class E2 , int S1, int S2>

Vector_<typename Mat<M,N,E2,S1,S2>::template Result<E1>::Mul> SimTK::operator*	(	const Mat< M, N, E2, S1, S2 > &	s,
		const VectorBase< E1 > &	v
	)

operator*() [15/161]

template<class E1 , int M, class E2 , int S>

Vector_<typename CNT<E1>::template Result< SymMat<M,E2,S> >::Mul> SimTK::operator*	(	const VectorBase< E1 > &	v,
		const SymMat< M, E2, S > &	s
	)

operator*() [16/161]

template<class E1 , int M, class E2 , int S>

Vector_<typename SymMat<M,E2,S>::template Result<E1>::Mul> SimTK::operator*	(	const SymMat< M, E2, S > &	s,
		const VectorBase< E1 > &	v
	)

operator+() [7/79]

template<class E1 , class E2 >

RowVector_<typename CNT<E1>::template Result<E2>::Add> SimTK::operator+	(	const RowVectorBase< E1 > &	l,
		const RowVectorBase< E2 > &	r
	)

operator+() [8/79]

template<class E >

RowVector_<E> SimTK::operator+	(	const RowVectorBase< E > &	l,
		const typename CNT< E >::T &	r
	)

operator+() [9/79]

template<class E >

RowVector_<E> SimTK::operator+	(	const typename CNT< E >::T &	l,
		const RowVectorBase< E > &	r
	)

operator-() [7/79]

template<class E1 , class E2 >

RowVector_<typename CNT<E1>::template Result<E2>::Sub> SimTK::operator-	(	const RowVectorBase< E1 > &	l,
		const RowVectorBase< E2 > &	r
	)

operator-() [8/79]

template<class E >

RowVector_<E> SimTK::operator-	(	const RowVectorBase< E > &	l,
		const typename CNT< E >::T &	r
	)

operator-() [9/79]

template<class E >

RowVector_<E> SimTK::operator-	(	const typename CNT< E >::T &	l,
		const RowVectorBase< E > &	r
	)

operator*() [17/161]

template<class E >

RowVector_<E> SimTK::operator*	(	const RowVectorBase< E > &	l,
		const typename CNT< E >::StdNumber &	r
	)

operator*() [18/161]

template<class E >

RowVector_<E> SimTK::operator*	(	const typename CNT< E >::StdNumber &	l,
		const RowVectorBase< E > &	r
	)

operator/() [5/76]

template<class E >

RowVector_<E> SimTK::operator/	(	const RowVectorBase< E > &	l,
		const typename CNT< E >::StdNumber &	r
	)

operator*() [19/161]

template<class E >

RowVector_<E> SimTK::operator*	(	const RowVectorBase< E > &	l,
		int	r
	)

operator*() [20/161]

template<class E >

RowVector_<E> SimTK::operator*	(	int	l,
		const RowVectorBase< E > &	r
	)

operator/() [6/76]

template<class E >

RowVector_<E> SimTK::operator/	(	const RowVectorBase< E > &	l,
		int	r
	)

operator*() [21/161]

template<class E1 , int M, class E2 , int S>

RowVector_<typename CNT<E1>::template Result< Vec<M,E2,S> >::Mul> SimTK::operator*	(	const RowVectorBase< E1 > &	v,
		const Vec< M, E2, S > &	s
	)

operator*() [22/161]

template<class E1 , int M, class E2 , int S>

RowVector_<typename Vec<M,E2,S>::template Result<E1>::Mul> SimTK::operator*	(	const Vec< M, E2, S > &	s,
		const RowVectorBase< E1 > &	v
	)

operator*() [23/161]

template<class E1 , int N, class E2 , int S>

RowVector_<typename CNT<E1>::template Result< Row<N,E2,S> >::Mul> SimTK::operator*	(	const RowVectorBase< E1 > &	v,
		const Row< N, E2, S > &	s
	)

operator*() [24/161]

template<class E1 , int N, class E2 , int S>

RowVector_<typename Row<N,E2,S>::template Result<E1>::Mul> SimTK::operator*	(	const Row< N, E2, S > &	s,
		const RowVectorBase< E1 > &	v
	)

operator*() [25/161]

template<class E1 , int M, int N, class E2 , int S1, int S2>

RowVector_<typename CNT<E1>::template Result< Mat<M,N,E2,S1,S2> >::Mul> SimTK::operator*	(	const RowVectorBase< E1 > &	v,
		const Mat< M, N, E2, S1, S2 > &	s
	)

operator*() [26/161]

template<class E1 , int M, int N, class E2 , int S1, int S2>

RowVector_<typename Mat<M,N,E2,S1,S2>::template Result<E1>::Mul> SimTK::operator*	(	const Mat< M, N, E2, S1, S2 > &	s,
		const RowVectorBase< E1 > &	v
	)

operator*() [27/161]

template<class E1 , int M, class E2 , int S>

RowVector_<typename CNT<E1>::template Result< SymMat<M,E2,S> >::Mul> SimTK::operator*	(	const RowVectorBase< E1 > &	v,
		const SymMat< M, E2, S > &	s
	)

operator*() [28/161]

template<class E1 , int M, class E2 , int S>

RowVector_<typename SymMat<M,E2,S>::template Result<E1>::Mul> SimTK::operator*	(	const SymMat< M, E2, S > &	s,
		const RowVectorBase< E1 > &	v
	)

operator*() [29/161]

template<class E1 , class E2 >

CNT<E1>::template Result<E2>::Mul SimTK::operator*	(	const RowVectorBase< E1 > &	r,
		const VectorBase< E2 > &	v
	)

operator*() [30/161]

template<class E1 , class E2 >

Vector_<typename CNT<E1>::template Result<E2>::Mul> SimTK::operator*	(	const MatrixBase< E1 > &	m,
		const VectorBase< E2 > &	v
	)

operator*() [31/161]

template<class E1 , class E2 >

Matrix_<typename CNT<E1>::template Result<E2>::Mul> SimTK::operator*	(	const MatrixBase< E1 > &	m1,
		const MatrixBase< E2 > &	m2
	)

readVectorFromStreamHelper()

template<class T >

static std::istream& SimTK::readVectorFromStreamHelper ( std::istream &  in, bool  isFixedSize, Vector_< T > &  out  )

inlinestatic

readArrayFromStreamHelper()

template<class T , class X >

static std::istream& SimTK::readArrayFromStreamHelper ( std::istream &  in, bool  isFixedSize, Array_< T, X > &  out  )

inlinestatic

canStoreInInt() [1/12]

bool SimTK::canStoreInInt ( bool  )

inline

canStoreInInt() [2/12]

bool SimTK::canStoreInInt ( char  )

inline

canStoreInInt() [3/12]

bool SimTK::canStoreInInt ( unsigned char  )

inline

canStoreInInt() [4/12]

bool SimTK::canStoreInInt ( signed char  )

inline

canStoreInInt() [5/12]

bool SimTK::canStoreInInt ( short  )

inline

canStoreInInt() [6/12]

bool SimTK::canStoreInInt ( unsigned short  )

inline

canStoreInInt() [7/12]

bool SimTK::canStoreInInt ( int  )

inline

canStoreInInt() [8/12]

bool SimTK::canStoreInInt ( unsigned int  u )

inline

canStoreInInt() [9/12]

bool SimTK::canStoreInInt ( long  i )

inline

canStoreInInt() [10/12]

bool SimTK::canStoreInInt ( unsigned long  u )

inline

canStoreInInt() [11/12]

bool SimTK::canStoreInInt ( long long  i )

inline

canStoreInInt() [12/12]

bool SimTK::canStoreInInt ( unsigned long long  u )

inline

canStoreInNonnegativeInt() [1/12]

bool SimTK::canStoreInNonnegativeInt ( bool  )

inline

canStoreInNonnegativeInt() [2/12]

bool SimTK::canStoreInNonnegativeInt ( char  c )

inline

canStoreInNonnegativeInt() [3/12]

bool SimTK::canStoreInNonnegativeInt ( unsigned char  )

inline

canStoreInNonnegativeInt() [4/12]

bool SimTK::canStoreInNonnegativeInt ( signed char  c )

inline

canStoreInNonnegativeInt() [5/12]

bool SimTK::canStoreInNonnegativeInt ( short  s )

inline

canStoreInNonnegativeInt() [6/12]

bool SimTK::canStoreInNonnegativeInt ( unsigned short  )

inline

canStoreInNonnegativeInt() [7/12]

bool SimTK::canStoreInNonnegativeInt ( int  i )

inline

canStoreInNonnegativeInt() [8/12]

bool SimTK::canStoreInNonnegativeInt ( long  l )

inline

canStoreInNonnegativeInt() [9/12]

bool SimTK::canStoreInNonnegativeInt ( long long  l )

inline

canStoreInNonnegativeInt() [10/12]

bool SimTK::canStoreInNonnegativeInt ( unsigned int  u )

inline

canStoreInNonnegativeInt() [11/12]

bool SimTK::canStoreInNonnegativeInt ( unsigned long  u )

inline

canStoreInNonnegativeInt() [12/12]

bool SimTK::canStoreInNonnegativeInt ( unsigned long long  u )

inline

isSizeInRange() [1/11]

bool SimTK::isSizeInRange ( char  sz, char  mx  )

inline

isSizeInRange() [2/11]

bool SimTK::isSizeInRange ( signed char  sz, signed char  mx  )

inline

isSizeInRange() [3/11]

bool SimTK::isSizeInRange ( short  sz, short  mx  )

inline

isSizeInRange() [4/11]

bool SimTK::isSizeInRange ( int  sz, int  mx  )

inline

isSizeInRange() [5/11]

bool SimTK::isSizeInRange ( long  sz, long  mx  )

inline

isSizeInRange() [6/11]

bool SimTK::isSizeInRange ( long long  sz, long long  mx  )

inline

isSizeInRange() [7/11]

bool SimTK::isSizeInRange ( unsigned char  sz, unsigned char  mx  )

inline

isSizeInRange() [8/11]

bool SimTK::isSizeInRange ( unsigned short  sz, unsigned short  mx  )

inline

isSizeInRange() [9/11]

bool SimTK::isSizeInRange ( unsigned int  sz, unsigned int  mx  )

inline

isSizeInRange() [10/11]

bool SimTK::isSizeInRange ( unsigned long  sz, unsigned long  mx  )

inline

isSizeInRange() [11/11]

bool SimTK::isSizeInRange ( unsigned long long  sz, unsigned long long  mx  )

inline

isIndexInRange() [1/11]

bool SimTK::isIndexInRange ( char  ix, char  sz  )

inline

isIndexInRange() [2/11]

bool SimTK::isIndexInRange ( signed char  ix, signed char  sz  )

inline

isIndexInRange() [3/11]

bool SimTK::isIndexInRange ( short  ix, short  sz  )

inline

isIndexInRange() [4/11]

bool SimTK::isIndexInRange ( int  ix, int  sz  )

inline

isIndexInRange() [5/11]

bool SimTK::isIndexInRange ( long  ix, long  sz  )

inline

isIndexInRange() [6/11]

bool SimTK::isIndexInRange ( long long  ix, long long  sz  )

inline

isIndexInRange() [7/11]

bool SimTK::isIndexInRange ( unsigned char  ix, unsigned char  sz  )

inline

isIndexInRange() [8/11]

bool SimTK::isIndexInRange ( unsigned short  ix, unsigned short  sz  )

inline

isIndexInRange() [9/11]

bool SimTK::isIndexInRange ( unsigned int  ix, unsigned int  sz  )

inline

isIndexInRange() [10/11]

bool SimTK::isIndexInRange ( unsigned long  ix, unsigned long  sz  )

inline

isIndexInRange() [11/11]

bool SimTK::isIndexInRange ( unsigned long long  ix, unsigned long long  sz  )

inline

isNonnegative() [1/12]

bool SimTK::isNonnegative ( bool  )

inline

isNonnegative() [2/12]

bool SimTK::isNonnegative ( char  n )

inline

isNonnegative() [3/12]

bool SimTK::isNonnegative ( signed char  n )

inline

isNonnegative() [4/12]

bool SimTK::isNonnegative ( short  n )

inline

isNonnegative() [5/12]

bool SimTK::isNonnegative ( int  n )

inline

isNonnegative() [6/12]

bool SimTK::isNonnegative ( long  n )

inline

isNonnegative() [7/12]

bool SimTK::isNonnegative ( long long  n )

inline

isNonnegative() [8/12]

bool SimTK::isNonnegative ( unsigned char  )

inline

isNonnegative() [9/12]

bool SimTK::isNonnegative ( unsigned short  )

inline

isNonnegative() [10/12]

bool SimTK::isNonnegative ( unsigned int  )

inline

isNonnegative() [11/12]

bool SimTK::isNonnegative ( unsigned long  )

inline

isNonnegative() [12/12]

bool SimTK::isNonnegative ( unsigned long long  )

inline

operator!=() [1/18]

template<class L , class R >

bool SimTK::operator!= ( const L &  left, const R &  right  )

inline

operator>() [1/5]

template<class L , class R >

bool SimTK::operator> ( const L &  left, const R &  right  )

inline

operator<=() [1/5]

template<class L , class R >

bool SimTK::operator<= ( const L &  left, const R &  right  )

inline

operator>=() [1/5]

template<class L , class R >

bool SimTK::operator>= ( const L &  left, const R &  right  )

inline

SimTK_SPECIALIZE_INTEGRAL_TYPE() [1/12]

SimTK::SimTK_SPECIALIZE_INTEGRAL_TYPE

(

bool

)

SimTK_SPECIALIZE_INTEGRAL_TYPE() [2/12]

SimTK::SimTK_SPECIALIZE_INTEGRAL_TYPE

(

char

)

SimTK_SPECIALIZE_INTEGRAL_TYPE() [3/12]

SimTK::SimTK_SPECIALIZE_INTEGRAL_TYPE

(

signed char

)

SimTK_SPECIALIZE_INTEGRAL_TYPE() [4/12]

SimTK::SimTK_SPECIALIZE_INTEGRAL_TYPE

(

unsigned char

)

SimTK_SPECIALIZE_INTEGRAL_TYPE() [5/12]

SimTK::SimTK_SPECIALIZE_INTEGRAL_TYPE

(

short

)

SimTK_SPECIALIZE_INTEGRAL_TYPE() [6/12]

SimTK::SimTK_SPECIALIZE_INTEGRAL_TYPE

(

unsigned short

)

SimTK_SPECIALIZE_INTEGRAL_TYPE() [7/12]

SimTK::SimTK_SPECIALIZE_INTEGRAL_TYPE

(

int

)

SimTK_SPECIALIZE_INTEGRAL_TYPE() [8/12]

SimTK::SimTK_SPECIALIZE_INTEGRAL_TYPE

(

unsigned int

)

SimTK_SPECIALIZE_INTEGRAL_TYPE() [9/12]

SimTK::SimTK_SPECIALIZE_INTEGRAL_TYPE

(

long

)

SimTK_SPECIALIZE_INTEGRAL_TYPE() [10/12]

SimTK::SimTK_SPECIALIZE_INTEGRAL_TYPE

(

unsigned long

)

SimTK_SPECIALIZE_INTEGRAL_TYPE() [11/12]

SimTK::SimTK_SPECIALIZE_INTEGRAL_TYPE

(

long long

)

SimTK_SPECIALIZE_INTEGRAL_TYPE() [12/12]

SimTK::SimTK_SPECIALIZE_INTEGRAL_TYPE

(

unsigned long long

)

SimTK_SPECIALIZE_FLOATING_TYPE() [1/2]

SimTK::SimTK_SPECIALIZE_FLOATING_TYPE

(

float

)

SimTK_SPECIALIZE_FLOATING_TYPE() [2/2]

SimTK::SimTK_SPECIALIZE_FLOATING_TYPE

(

double

)

detect64BitPlatform()

constexpr bool SimTK::detect64BitPlatform ( )

constexpr

Compile-time test: this typedef will be TrueType if this is a 64-bit platform, meaning that the size of a pointer is the same as the size of a long long; otherwise it will be FalseType and we have a 32-bit platform meaning that the size of a pointer is the same as an int.

operator<<() [6/18]

template<class H , class IMPL , bool PTR>

std::ostream& SimTK::operator<<	(	std::ostream &	o,
		const PIMPLHandle< H, IMPL, PTR > &	h
	)

operator<<() [7/18]

template<class HANDLE , class IMPL , bool PTR>

std::ostream& SimTK::operator<<	(	std::ostream &	o,
		const PIMPLHandle< HANDLE, IMPL, PTR > &	h
	)

tryConvertStringTo() [1/9]

template<class T >

static bool SimTK::tryConvertStringTo ( const String &  value, T &  out  )

inlinestatic

tryConvertStringTo() [2/9]

template<>

bool SimTK::tryConvertStringTo ( const String &  value, bool &  out  )

inline

tryConvertStringTo() [3/9]

template<>

bool SimTK::tryConvertStringTo ( const String &  value, float &  out  )

inline

tryConvertStringTo() [4/9]

template<>

bool SimTK::tryConvertStringTo ( const String &  value, double &  out  )

inline

tryConvertStringTo() [5/9]

template<>

bool SimTK::tryConvertStringTo ( const String &  value, String &  out  )

inline

tryConvertStringTo() [6/9]

template<>

bool SimTK::tryConvertStringTo ( const String &  value, std::string &  out  )

inline

tryConvertStringTo() [7/9]

template<class T >

bool SimTK::tryConvertStringTo ( const String &  value, negator< T > &  out  )

inline

Partial specialization to read negator<T> as a T.

tryConvertStringTo() [8/9]

template<class T >

bool SimTK::tryConvertStringTo ( const String &  value, conjugate< T > &  out  )

inline

Partial specialization to read conjugate<T> as a std::complex<T>.

tryConvertStringTo() [9/9]

template<class T >

static bool SimTK::tryConvertStringTo ( const String &  value, T *&  out  )

inlinestatic

SimTK_ELEMENTWISE_FUNCTION()

SimTK::SimTK_ELEMENTWISE_FUNCTION

(

exp

)

abs() [1/8]

template<class ELEM >

RowVectorBase<typename CNT<ELEM>::TAbs> SimTK::abs

(

const RowVectorBase< ELEM > &

v

)

abs() [2/8]

template<class ELEM >

MatrixBase<typename CNT<ELEM>::TAbs> SimTK::abs

(

const MatrixBase< ELEM > &

v

)

abs() [3/8]

template<int N, class ELEM >

Vec<N, typename CNT<ELEM>::TAbs> SimTK::abs

(

const Vec< N, ELEM > &

v

)

abs() [4/8]

template<int N, class ELEM >

Row<N, typename CNT<ELEM>::TAbs> SimTK::abs

(

const Row< N, ELEM > &

v

)

abs() [5/8]

template<int M, int N, class ELEM >

Mat<M, N, typename CNT<ELEM>::TAbs> SimTK::abs

(

const Mat< M, N, ELEM > &

v

)

abs() [6/8]

template<int N, class ELEM >

SymMat<N, typename CNT<ELEM>::TAbs> SimTK::abs

(

const SymMat< N, ELEM > &

v

)

sum() [1/7]

template<class ELEM >

ELEM SimTK::sum

(

const VectorBase< ELEM > &

v

)

sum() [2/7]

template<class ELEM >

ELEM SimTK::sum

(

const RowVectorBase< ELEM > &

v

)

sum() [3/7]

template<class ELEM >

RowVectorBase<ELEM> SimTK::sum

(

const MatrixBase< ELEM > &

v

)

sum() [4/7]

template<int N, class ELEM >

ELEM SimTK::sum

(

const Vec< N, ELEM > &

v

)

sum() [5/7]

template<int N, class ELEM >

ELEM SimTK::sum

(

const Row< N, ELEM > &

v

)

sum() [6/7]

template<int M, int N, class ELEM >

Row<N, ELEM> SimTK::sum

(

const Mat< M, N, ELEM > &

v

)

sum() [7/7]

template<int N, class ELEM >

Row<N, ELEM> SimTK::sum

(

const SymMat< N, ELEM > &

v

)

min() [1/7]

template<class ELEM >

ELEM SimTK::min

(

const VectorBase< ELEM > &

v

)

min() [2/7]

template<class ELEM >

ELEM SimTK::min

(

const RowVectorBase< ELEM > &

v

)

min() [3/7]

template<class ELEM >

RowVectorBase<ELEM> SimTK::min

(

const MatrixBase< ELEM > &

v

)

min() [4/7]

template<int N, class ELEM >

ELEM SimTK::min

(

const Vec< N, ELEM > &

v

)

min() [5/7]

template<int N, class ELEM >

ELEM SimTK::min

(

const Row< N, ELEM > &

v

)

min() [6/7]

template<int M, int N, class ELEM >

Row<N, ELEM> SimTK::min

(

const Mat< M, N, ELEM > &

v

)

min() [7/7]

template<int N, class ELEM >

Row<N, ELEM> SimTK::min

(

const SymMat< N, ELEM > &

v

)

max() [1/7]

template<class ELEM >

ELEM SimTK::max

(

const VectorBase< ELEM > &

v

)

max() [2/7]

template<class ELEM >

ELEM SimTK::max

(

const RowVectorBase< ELEM > &

v

)

max() [3/7]

template<class ELEM >

RowVectorBase<ELEM> SimTK::max

(

const MatrixBase< ELEM > &

v

)

max() [4/7]

template<int N, class ELEM >

ELEM SimTK::max

(

const Vec< N, ELEM > &

v

)

max() [5/7]

template<int N, class ELEM >

ELEM SimTK::max

(

const Row< N, ELEM > &

v

)

max() [6/7]

template<int M, int N, class ELEM >

Row<N, ELEM> SimTK::max

(

const Mat< M, N, ELEM > &

v

)

max() [7/7]

template<int N, class ELEM >

Row<N, ELEM> SimTK::max

(

const SymMat< N, ELEM > &

v

)

mean() [1/7]

template<class ELEM >

ELEM SimTK::mean

(

const VectorBase< ELEM > &

v

)

mean() [2/7]

template<class ELEM >

ELEM SimTK::mean

(

const RowVectorBase< ELEM > &

v

)

mean() [3/7]

template<class ELEM >

RowVectorBase<ELEM> SimTK::mean

(

const MatrixBase< ELEM > &

v

)

mean() [4/7]

template<int N, class ELEM >

ELEM SimTK::mean

(

const Vec< N, ELEM > &

v

)

mean() [5/7]

template<int N, class ELEM >

ELEM SimTK::mean

(

const Row< N, ELEM > &

v

)

mean() [6/7]

template<int M, int N, class ELEM >

Row<N, ELEM> SimTK::mean

(

const Mat< M, N, ELEM > &

v

)

mean() [7/7]

template<int N, class ELEM >

Row<N, ELEM> SimTK::mean

(

const SymMat< N, ELEM > &

v

)

sort() [1/7]

template<class ELEM >

VectorBase<ELEM> SimTK::sort

(

const VectorBase< ELEM > &

v

)

sort() [2/7]

template<class ELEM >

RowVectorBase<ELEM> SimTK::sort

(

const RowVectorBase< ELEM > &

v

)

sort() [3/7]

template<class ELEM >

MatrixBase<ELEM> SimTK::sort

(

const MatrixBase< ELEM > &

v

)

sort() [4/7]

template<int N, class ELEM >

Vec<N, ELEM> SimTK::sort

(

Vec< N, ELEM >

v

)

sort() [5/7]

template<int N, class ELEM >

Row<N, ELEM> SimTK::sort

(

Row< N, ELEM >

v

)

sort() [6/7]

template<int M, int N, class ELEM >

Mat<M, N, ELEM> SimTK::sort

(

Mat< M, N, ELEM >

v

)

sort() [7/7]

template<int N, class ELEM >

Mat<N, N, ELEM> SimTK::sort

(

const SymMat< N, ELEM > &

v

)

median() [1/8]

template<class ELEM , class RandomAccessIterator >

ELEM SimTK::median	(	RandomAccessIterator	start,
		RandomAccessIterator	end
	)

median() [2/8]

template<class ELEM >

ELEM SimTK::median

(

const VectorBase< ELEM > &

v

)

median() [3/8]

template<class ELEM >

ELEM SimTK::median

(

const RowVectorBase< ELEM > &

v

)

median() [4/8]

template<class ELEM >

RowVectorBase<ELEM> SimTK::median

(

const MatrixBase< ELEM > &

v

)

median() [5/8]

template<int N, class ELEM >

ELEM SimTK::median

(

Vec< N, ELEM >

v

)

median() [6/8]

template<int N, class ELEM >

ELEM SimTK::median

(

Row< N, ELEM >

v

)

median() [7/8]

template<int M, int N, class ELEM >

Row<N, ELEM> SimTK::median

(

const Mat< M, N, ELEM > &

v

)

median() [8/8]

template<int N, class ELEM >

Row<N, ELEM> SimTK::median

(

const SymMat< N, ELEM > &

v

)

operator<<() [8/18]

template<class P >

std::ostream& SimTK::operator<<	(	std::ostream &	,
		const Rotation_< P > &
	)

Write a Rotation matrix to an output stream by writing out its underlying Mat33.

operator<<() [9/18]

template<class P >

std::ostream& SimTK::operator<<	(	std::ostream &	,
		const InverseRotation_< P > &
	)

Write an InverseRotation matrix to an output stream by writing out its underlying Mat33.

operator*() [32/161]

template<class P , int S>

UnitVec<P,1> SimTK::operator* ( const Rotation_< P > &  R, const UnitVec< P, S > &  v  )

inline

Rotating a unit vector leaves it unit length, saving us from having to perform an expensive normalization.

So we override the multiply operators here changing the return type to UnitVec or UnitRow.

operator*() [33/161]

template<class P , int S>

UnitRow<P,1> SimTK::operator* ( const UnitRow< P, S > &  r, const Rotation_< P > &  R  )

inline

operator*() [34/161]

template<class P , int S>

UnitVec<P,1> SimTK::operator* ( const InverseRotation_< P > &  R, const UnitVec< P, S > &  v  )

inline

operator*() [35/161]

template<class P , int S>

UnitRow<P,1> SimTK::operator* ( const UnitRow< P, S > &  r, const InverseRotation_< P > &  R  )

inline

operator*() [36/161]

template<class P >

Rotation_<P> SimTK::operator* ( const Rotation_< P > &  R1, const Rotation_< P > &  R2  )

inline

Composition of Rotation matrices via operator*.

operator*() [37/161]

template<class P >

Rotation_<P> SimTK::operator* ( const Rotation_< P > &  R1, const InverseRotation_< P > &  R2  )

inline

operator*() [38/161]

template<class P >

Rotation_<P> SimTK::operator* ( const InverseRotation_< P > &  R1, const Rotation_< P > &  R2  )

inline

operator*() [39/161]

template<class P >

Rotation_<P> SimTK::operator* ( const InverseRotation_< P > &  R1, const InverseRotation_< P > &  R2  )

inline

operator/() [7/76]

template<class P >

Rotation_<P> SimTK::operator/ ( const Rotation_< P > &  R1, const Rotation_< P > &  R2  )

inline

Composition of a Rotation matrix and the inverse of another Rotation via operator/, that is R1/R2 == R1*(~R2).

operator/() [8/76]

template<class P >

Rotation_<P> SimTK::operator/ ( const Rotation_< P > &  R1, const InverseRotation &  R2  )

inline

operator/() [9/76]

template<class P >

Rotation_<P> SimTK::operator/ ( const InverseRotation_< P > &  R1, const Rotation_< P > &  R2  )

inline

operator/() [10/76]

template<class P >

Rotation_<P> SimTK::operator/ ( const InverseRotation_< P > &  R1, const InverseRotation_< P > &  R2  )

inline

transpose()

PhiMatrixTranspose SimTK::transpose ( const PhiMatrix &  phi )

inline

operator~()

PhiMatrixTranspose SimTK::operator~ ( const PhiMatrix &  phi )

inline

operator*() [40/161]

SpatialVec SimTK::operator* ( const PhiMatrix &  phi, const SpatialVec &  v  )

inline

operator*() [41/161]

SpatialMat SimTK::operator* ( const PhiMatrix &  phi, const SpatialMat &  m  )

inline

operator*() [42/161]

SpatialMat SimTK::operator* ( const SpatialMat &  m, const PhiMatrix &  phi  )

inline

operator*() [43/161]

SpatialVec SimTK::operator* ( const PhiMatrixTranspose &  phiT, const SpatialVec &  v  )

inline

operator*() [44/161]

SpatialMat SimTK::operator* ( const PhiMatrixTranspose &  phiT, const SpatialMat &  m  )

inline

operator*() [45/161]

SpatialMat SimTK::operator* ( const SpatialMat::THerm &  m, const PhiMatrixTranspose &  phiT  )

inline

operator*() [46/161]

SpatialMat SimTK::operator* ( const SpatialMat &  m, const PhiMatrixTranspose &  phiT  )

inline

operator==() [1/22]

bool SimTK::operator== ( const PhiMatrix &  p1, const PhiMatrix &  p2  )

inline

operator==() [2/22]

bool SimTK::operator== ( const PhiMatrixTranspose &  p1, const PhiMatrixTranspose &  p2  )

inline

operator*() [47/161]

template<class P , int S>

Vec<3,P> SimTK::operator* ( const InverseTransform_< P > &  X_BF, const Vec< 3, P, S > &  s_F  )

inline

operator*() [48/161]

template<class P , int S>

Vec<3,P> SimTK::operator* ( const Transform_< P > &  X_BF, const Vec< 3, negator< P >, S > &  s_F  )

inline

operator*() [49/161]

template<class P , int S>

Vec<3,P> SimTK::operator* ( const InverseTransform_< P > &  X_BF, const Vec< 3, negator< P >, S > &  s_F  )

inline

operator*() [50/161]

template<class P , int S>

Vec<4,P> SimTK::operator* ( const InverseTransform_< P > &  X_BF, const Vec< 4, P, S > &  a_F  )

inline

operator*() [51/161]

template<class P , int S>

Vec<4,P> SimTK::operator* ( const Transform_< P > &  X_BF, const Vec< 4, negator< P >, S > &  s_F  )

inline

operator*() [52/161]

template<class P , int S>

Vec<4,P> SimTK::operator* ( const InverseTransform_< P > &  X_BF, const Vec< 4, negator< P >, S > &  s_F  )

inline

operator*() [53/161]

template<class P , class E >

Vector_<E> SimTK::operator* ( const VectorBase< E > &  v, const Transform_< P > &  X  )

inline

operator*() [54/161]

template<class P , class E >

RowVector_<E> SimTK::operator* ( const Transform_< P > &  X, const RowVectorBase< E > &  v  )

inline

operator*() [55/161]

template<class P , class E >

RowVector_<E> SimTK::operator* ( const RowVectorBase< E > &  v, const Transform_< P > &  X  )

inline

operator*() [56/161]

template<class P , class E >

Matrix_<E> SimTK::operator* ( const Transform_< P > &  X, const MatrixBase< E > &  v  )

inline

operator*() [57/161]

template<class P , class E >

Matrix_<E> SimTK::operator* ( const MatrixBase< E > &  v, const Transform_< P > &  X  )

inline

operator*() [58/161]

template<class P , int N, class E , int S>

Vec<N,E> SimTK::operator* ( const Transform_< P > &  X, const Vec< N, E, S > &  v  )

inline

operator*() [59/161]

template<class P , int N, class E , int S>

Vec<N,E> SimTK::operator* ( const Vec< N, E, S > &  v, const Transform_< P > &  X  )

inline

operator*() [60/161]

template<class P , int N, class E , int S>

Row<N,E> SimTK::operator* ( const Transform_< P > &  X, const Row< N, E, S > &  v  )

inline

operator*() [61/161]

template<class P , int N, class E , int S>

Row<N,E> SimTK::operator* ( const Row< N, E, S > &  v, const Transform_< P > &  X  )

inline

operator*() [62/161]

template<class P , int M, int N, class E , int CS, int RS>

Mat<M,N,E> SimTK::operator* ( const Transform_< P > &  X, const Mat< M, N, E, CS, RS > &  v  )

inline

operator*() [63/161]

template<class P , int M, int N, class E , int CS, int RS>

Mat<M,N,E> SimTK::operator* ( const Mat< M, N, E, CS, RS > &  v, const Transform_< P > &  X  )

inline

operator*() [64/161]

template<class P >

Transform_<P> SimTK::operator* ( const Transform_< P > &  X1, const InverseTransform_< P > &  X2  )

inline

operator*() [65/161]

template<class P >

Transform_<P> SimTK::operator* ( const InverseTransform_< P > &  X1, const Transform_< P > &  X2  )

inline

operator*() [66/161]

template<class P >

Transform_<P> SimTK::operator* ( const InverseTransform_< P > &  X1, const InverseTransform_< P > &  X2  )

inline

operator==() [3/22]

template<class P >

bool SimTK::operator== ( const InverseTransform_< P > &  X1, const InverseTransform_< P > &  X2  )

inline

operator==() [4/22]

template<class P >

bool SimTK::operator== ( const Transform_< P > &  X1, const InverseTransform_< P > &  X2  )

inline

operator==() [5/22]

template<class P >

bool SimTK::operator== ( const InverseTransform_< P > &  X1, const Transform_< P > &  X2  )

inline

convertRadiansToDegrees()

static Real SimTK::convertRadiansToDegrees ( const Real  rad )

inlinestatic

convertDegreesToRadians()

static Real SimTK::convertDegreesToRadians ( const Real  deg )

inlinestatic

operator*() [67/161]

complex<float> SimTK::operator* ( const complex< float > &  c, int  r  )

inline

operator*() [68/161]

complex<float> SimTK::operator* ( int  r, const complex< float > &  c  )

inline

operator*() [69/161]

complex<double> SimTK::operator* ( const complex< float > &  c, const double &  r  )

inline

operator*() [70/161]

complex<double> SimTK::operator* ( const double &  r, const complex< float > &  c  )

inline

operator/() [11/76]

complex<float> SimTK::operator/ ( const complex< float > &  c, int  r  )

inline

operator/() [12/76]

complex<float> SimTK::operator/ ( int  r, const complex< float > &  c  )

inline

operator/() [13/76]

complex<double> SimTK::operator/ ( const complex< float > &  c, const double &  r  )

inline

operator/() [14/76]

complex<double> SimTK::operator/ ( const double &  r, const complex< float > &  c  )

inline

operator+() [10/79]

complex<float> SimTK::operator+ ( const complex< float > &  c, int  r  )

inline

operator+() [11/79]

complex<float> SimTK::operator+ ( int  r, const complex< float > &  c  )

inline

operator+() [12/79]

complex<double> SimTK::operator+ ( const complex< float > &  c, const double &  r  )

inline

operator+() [13/79]

complex<double> SimTK::operator+ ( const double &  r, const complex< float > &  c  )

inline

operator-() [10/79]

complex<float> SimTK::operator- ( const complex< float > &  c, int  r  )

inline

operator-() [11/79]

complex<float> SimTK::operator- ( int  r, const complex< float > &  c  )

inline

operator-() [12/79]

complex<double> SimTK::operator- ( const complex< float > &  c, const double &  r  )

inline

operator-() [13/79]

complex<double> SimTK::operator- ( const double &  r, const complex< float > &  c  )

inline

operator*() [71/161]

complex<double> SimTK::operator* ( const complex< double > &  c, int  r  )

inline

operator*() [72/161]

complex<double> SimTK::operator* ( int  r, const complex< double > &  c  )

inline

operator*() [73/161]

complex<double> SimTK::operator* ( const complex< double > &  c, const float &  r  )

inline

operator*() [74/161]

complex<double> SimTK::operator* ( const float &  r, const complex< double > &  c  )

inline

operator/() [15/76]

complex<double> SimTK::operator/ ( const complex< double > &  c, int  r  )

inline

operator/() [16/76]

complex<double> SimTK::operator/ ( int  r, const complex< double > &  c  )

inline

operator/() [17/76]

complex<double> SimTK::operator/ ( const complex< double > &  c, const float &  r  )

inline

operator/() [18/76]

complex<double> SimTK::operator/ ( const float &  r, const complex< double > &  c  )

inline

operator+() [14/79]

complex<double> SimTK::operator+ ( const complex< double > &  c, int  r  )

inline

operator+() [15/79]

complex<double> SimTK::operator+ ( int  r, const complex< double > &  c  )

inline

operator+() [16/79]

complex<double> SimTK::operator+ ( const complex< double > &  c, const float &  r  )

inline

operator+() [17/79]

complex<double> SimTK::operator+ ( const float &  r, const complex< double > &  c  )

inline

operator-() [14/79]

complex<double> SimTK::operator- ( const complex< double > &  c, int  r  )

inline

operator-() [15/79]

complex<double> SimTK::operator- ( int  r, const complex< double > &  c  )

inline

operator-() [16/79]

complex<double> SimTK::operator- ( const complex< double > &  c, const float &  r  )

inline

operator-() [17/79]

complex<double> SimTK::operator- ( const float &  r, const complex< double > &  c  )

inline

real() [1/2]

const float& SimTK::real ( const conjugate< float > &  c )

inline

imag() [1/2]

const negator<float>& SimTK::imag ( const conjugate< float > &  c )

inline

conj() [1/2]

const complex<float>& SimTK::conj ( const conjugate< float > &  c )

inline

abs() [7/8]

float SimTK::abs ( const conjugate< float > &  c )

inline

norm() [1/2]

float SimTK::norm ( const conjugate< float > &  c )

inline

real() [2/2]

const double& SimTK::real ( const conjugate< double > &  c )

inline

imag() [2/2]

const negator<double>& SimTK::imag ( const conjugate< double > &  c )

inline

conj() [2/2]

const complex<double>& SimTK::conj ( const conjugate< double > &  c )

inline

abs() [8/8]

double SimTK::abs ( const conjugate< double > &  c )

inline

norm() [2/2]

double SimTK::norm ( const conjugate< double > &  c )

inline

operator>>() [1/6]

template<class R , class CHAR , class TRAITS >

std::basic_istream<CHAR,TRAITS>& SimTK::operator>> ( std::basic_istream< CHAR, TRAITS > &  is, conjugate< R > &  c  )

inline

operator<<() [10/18]

template<class R , class CHAR , class TRAITS >

std::basic_ostream<CHAR,TRAITS>& SimTK::operator<< ( std::basic_ostream< CHAR, TRAITS > &  os, const conjugate< R > &  c  )

inline

operator+() [18/79]

template<class R >

conjugate<R> SimTK::operator+ ( const conjugate< R > &  a, const float &  b  )

inline

operator+() [19/79]

template<class R >

Wider<R,double>::WConj SimTK::operator+ ( const conjugate< R > &  a, const double &  b  )

inline

operator+() [20/79]

template<class R >

conjugate<R> SimTK::operator+ ( const float &  a, const conjugate< R > &  b  )

inline

operator+() [21/79]

template<class R >

Wider<R,double>::WConj SimTK::operator+ ( const double &  a, const conjugate< R > &  b  )

inline

operator*() [75/161]

template<class R >

conjugate<R> SimTK::operator* ( const conjugate< R > &  a, const float &  b  )

inline

operator*() [76/161]

template<class R >

Wider<R,double>::WConj SimTK::operator* ( const conjugate< R > &  a, const double &  b  )

inline

operator*() [77/161]

template<class R >

conjugate<R> SimTK::operator* ( const float &  a, const conjugate< R > &  b  )

inline

operator*() [78/161]

template<class R >

Wider<R,double>::WConj SimTK::operator* ( const double &  a, const conjugate< R > &  b  )

inline

operator==() [6/22]

template<class R >

bool SimTK::operator== ( const conjugate< R > &  a, const float &  b  )

inline

operator==() [7/22]

template<class R >

bool SimTK::operator== ( const conjugate< R > &  a, const double &  b  )

inline

operator==() [8/22]

template<class R >

bool SimTK::operator== ( const float &  a, const conjugate< R > &  b  )

inline

operator==() [9/22]

template<class R >

bool SimTK::operator== ( const double &  a, const conjugate< R > &  b  )

inline

operator!=() [2/18]

template<class R >

bool SimTK::operator!= ( const conjugate< R > &  a, const float &  b  )

inline

operator!=() [3/18]

template<class R >

bool SimTK::operator!= ( const conjugate< R > &  a, const double &  b  )

inline

operator!=() [4/18]

template<class R >

bool SimTK::operator!= ( const float &  a, const conjugate< R > &  b  )

inline

operator!=() [5/18]

template<class R >

bool SimTK::operator!= ( const double &  a, const conjugate< R > &  b  )

inline

operator-() [18/79]

template<class R >

conjugate<R> SimTK::operator- ( const conjugate< R > &  a, const float &  b  )

inline

operator-() [19/79]

template<class R >

Wider<R,double>::WConj SimTK::operator- ( const conjugate< R > &  a, const double &  b  )

inline

operator-() [20/79]

template<class R >

complex<R> SimTK::operator- ( const float &  a, const conjugate< R > &  b  )

inline

operator-() [21/79]

template<class R >

Wider<R,double>::WCplx SimTK::operator- ( const double &  a, const conjugate< R > &  b  )

inline

operator/() [19/76]

template<class R >

conjugate<R> SimTK::operator/ ( const conjugate< R > &  a, const float &  b  )

inline

operator/() [20/76]

template<class R >

Wider<R,double>::WConj SimTK::operator/ ( const conjugate< R > &  a, const double &  b  )

inline

operator/() [21/76]

template<class R >

complex<R> SimTK::operator/ ( const float &  a, const conjugate< R > &  b  )

inline

operator/() [22/76]

template<class R >

Wider<R,double>::WCplx SimTK::operator/ ( const double &  a, const conjugate< R > &  b  )

inline

operator+() [22/79]

template<class R , class S >

Wider<R,S>::WConj SimTK::operator+ ( const conjugate< R > &  a, const conjugate< S > &  r  )

inline

operator+() [23/79]

template<class R , class S >

Wider<R,S>::WCplx SimTK::operator+ ( const conjugate< R > &  a, const complex< S > &  r  )

inline

operator+() [24/79]

template<class R , class S >

Wider<R,S>::WCplx SimTK::operator+ ( const complex< R > &  a, const conjugate< S > &  r  )

inline

operator-() [22/79]

template<class R , class S >

Wider<R,S>::WCplx SimTK::operator- ( const conjugate< R > &  a, const conjugate< S > &  r  )

inline

operator-() [23/79]

template<class R , class S >

negator<typename Wider<R,S>::WCplx> SimTK::operator- ( const conjugate< R > &  a, const complex< S > &  r  )

inline

operator-() [24/79]

template<class R , class S >

Wider<R,S>::WCplx SimTK::operator- ( const complex< R > &  a, const conjugate< S > &  r  )

inline

operator*() [79/161]

template<class R , class S >

negator<typename Wider<R,S>::WCplx> SimTK::operator* ( const conjugate< R > &  a, const conjugate< S > &  r  )

inline

operator*() [80/161]

template<class R , class S >

Wider<R,S>::WCplx SimTK::operator* ( const conjugate< R > &  a, const complex< S > &  r  )

inline

operator*() [81/161]

template<class R , class S >

Wider<R,S>::WCplx SimTK::operator* ( const complex< R > &  a, const conjugate< S > &  r  )

inline

operator*() [82/161]

template<class R , class S >

Wider<R,S>::WCplx SimTK::operator* ( const negator< complex< R > > &  a, const conjugate< S > &  r  )

inline

operator*() [83/161]

template<class R , class S >

Wider<R,S>::WCplx SimTK::operator* ( const conjugate< R > &  a, const negator< complex< S > > &  r  )

inline

operator/() [23/76]

template<class R , class S >

Wider<R,S>::WCplx SimTK::operator/ ( const conjugate< R > &  a, const conjugate< S > &  r  )

inline

operator/() [24/76]

template<class R , class S >

Wider<R,S>::WCplx SimTK::operator/ ( const conjugate< R > &  a, const complex< S > &  r  )

inline

operator/() [25/76]

template<class R , class S >

Wider<R,S>::WCplx SimTK::operator/ ( const complex< R > &  a, const conjugate< S > &  r  )

inline

operator==() [10/22]

template<class R , class S >

bool SimTK::operator== ( const conjugate< R > &  a, const conjugate< S > &  r  )

inline

operator==() [11/22]

template<class R , class S >

bool SimTK::operator== ( const conjugate< R > &  a, const complex< S > &  r  )

inline

operator==() [12/22]

template<class R , class S >

bool SimTK::operator== ( const complex< R > &  a, const conjugate< S > &  r  )

inline

operator!=() [6/18]

template<class R , class S >

bool SimTK::operator!= ( const conjugate< R > &  a, const conjugate< S > &  r  )

inline

operator!=() [7/18]

template<class R , class S >

bool SimTK::operator!= ( const conjugate< R > &  a, const complex< S > &  r  )

inline

operator!=() [8/18]

template<class R , class S >

bool SimTK::operator!= ( const complex< R > &  a, const conjugate< S > &  r  )

inline

isNaN() [1/8]

bool SimTK::isNaN ( const negator< float > &  x )

inline

isNaN() [2/8]

bool SimTK::isNaN ( const negator< double > &  x )

inline

isNaN() [3/8]

template<class P >

bool SimTK::isNaN ( const negator< std::complex< P > > &  x )

inline

isNaN() [4/8]

template<class P >

bool SimTK::isNaN ( const negator< conjugate< P > > &  x )

inline

isFinite() [1/8]

bool SimTK::isFinite ( const negator< float > &  x )

inline

isFinite() [2/8]

bool SimTK::isFinite ( const negator< double > &  x )

inline

isFinite() [3/8]

template<class P >

bool SimTK::isFinite ( const negator< std::complex< P > > &  x )

inline

isFinite() [4/8]

template<class P >

bool SimTK::isFinite ( const negator< conjugate< P > > &  x )

inline

isInf() [1/8]

bool SimTK::isInf ( const negator< float > &  x )

inline

isInf() [2/8]

bool SimTK::isInf ( const negator< double > &  x )

inline

isInf() [3/8]

template<class P >

bool SimTK::isInf ( const negator< std::complex< P > > &  x )

inline

isInf() [4/8]

template<class P >

bool SimTK::isInf ( const negator< conjugate< P > > &  x )

inline

negRecast()

template<class DEST , class SRC >

static const DEST& SimTK::negRecast ( const SRC &  s )

inlinestatic

operator+() [25/79]

template<class A , class B >

negator<A>::template Result<B>::Add SimTK::operator+ ( const negator< A > &  l, const B &  r  )

inline

operator+() [26/79]

template<class A , class B >

CNT<A>::template Result<negator<B> >::Add SimTK::operator+ ( const A &  l, const negator< B > &  r  )

inline

operator+() [27/79]

template<class A , class B >

negator<A>::template Result<negator<B> >::Add SimTK::operator+ ( const negator< A > &  l, const negator< B > &  r  )

inline

operator-() [25/79]

template<class A , class B >

negator<A>::template Result<B>::Sub SimTK::operator- ( const negator< A > &  l, const B &  r  )

inline

operator-() [26/79]

template<class A , class B >

CNT<A>::template Result<negator<B> >::Sub SimTK::operator- ( const A &  l, const negator< B > &  r  )

inline

operator-() [27/79]

template<class A , class B >

negator<A>::template Result<negator<B> >::Sub SimTK::operator- ( const negator< A > &  l, const negator< B > &  r  )

inline

operator*() [84/161]

template<class A , class B >

negator<A>::template Result<B>::Mul SimTK::operator* ( const negator< A > &  l, const B &  r  )

inline

operator*() [85/161]

template<class A , class B >

CNT<A>::template Result<negator<B> >::Mul SimTK::operator* ( const A &  l, const negator< B > &  r  )

inline

operator*() [86/161]

template<class A , class B >

negator<A>::template Result<negator<B> >::Mul SimTK::operator* ( const negator< A > &  l, const negator< B > &  r  )

inline

operator/() [26/76]

template<class A , class B >

negator<A>::template Result<B>::Dvd SimTK::operator/ ( const negator< A > &  l, const B &  r  )

inline

operator/() [27/76]

template<class A , class B >

CNT<A>::template Result<negator<B> >::Dvd SimTK::operator/ ( const A &  l, const negator< B > &  r  )

inline

operator/() [28/76]

template<class A , class B >

negator<A>::template Result<negator<B> >::Dvd SimTK::operator/ ( const negator< A > &  l, const negator< B > &  r  )

inline

operator==() [13/22]

template<class A , class B >

bool SimTK::operator== ( const negator< A > &  l, const B &  r  )

inline

operator==() [14/22]

template<class A , class B >

bool SimTK::operator== ( const A &  l, const negator< B > &  r  )

inline

operator==() [15/22]

template<class A , class B >

bool SimTK::operator== ( const negator< A > &  l, const negator< B > &  r  )

inline

operator!=() [9/18]

template<class A , class B >

bool SimTK::operator!= ( const negator< A > &  l, const B &  r  )

inline

operator!=() [10/18]

template<class A , class B >

bool SimTK::operator!= ( const A &  l, const negator< B > &  r  )

inline

operator!=() [11/18]

template<class A , class B >

bool SimTK::operator!= ( const negator< A > &  l, const negator< B > &  r  )

inline

operator>>() [2/6]

template<class NUM , class CHAR , class TRAITS >

std::basic_istream<CHAR,TRAITS>& SimTK::operator>> ( std::basic_istream< CHAR, TRAITS > &  is, negator< NUM > &  nn  )

inline

operator<<() [11/18]

template<class NUM , class CHAR , class TRAITS >

std::basic_ostream<CHAR,TRAITS>& SimTK::operator<< ( std::basic_ostream< CHAR, TRAITS > &  os, const negator< NUM > &  nn  )

inline

isNaN() [5/8]

bool SimTK::isNaN ( const float &  x )

inline

isNaN() [6/8]

bool SimTK::isNaN ( const double &  x )

inline

isNaN() [7/8]

template<class P >

bool SimTK::isNaN ( const std::complex< P > &  x )

inline

isNaN() [8/8]

template<class P >

bool SimTK::isNaN ( const conjugate< P > &  x )

inline

isFinite() [5/8]

bool SimTK::isFinite ( const float &  x )

inline

isFinite() [6/8]

bool SimTK::isFinite ( const double &  x )

inline

isFinite() [7/8]

template<class P >

bool SimTK::isFinite ( const std::complex< P > &  x )

inline

isFinite() [8/8]

template<class P >

bool SimTK::isFinite ( const conjugate< P > &  x )

inline

isInf() [5/8]

bool SimTK::isInf ( const float &  x )

inline

isInf() [6/8]

bool SimTK::isInf ( const double &  x )

inline

isInf() [7/8]

template<class P >

bool SimTK::isInf ( const std::complex< P > &  x )

inline

isInf() [8/8]

template<class P >

bool SimTK::isInf ( const conjugate< P > &  x )

inline

isNumericallyEqual() [1/24]

bool SimTK::isNumericallyEqual ( const float &  a, const float &  b, double  tol = RTraits<float>::getDefaultTolerance()  )

inline

Compare two floats for approximate equality.

isNumericallyEqual() [2/24]

bool SimTK::isNumericallyEqual ( const double &  a, const double &  b, double  tol = RTraits<double>::getDefaultTolerance()  )

inline

Compare two doubles for approximate equality.

isNumericallyEqual() [3/24]

bool SimTK::isNumericallyEqual ( const float &  a, const double &  b, double  tol = RTraits<float>::getDefaultTolerance()  )

inline

Compare a float and a double for approximate equality at float precision.

isNumericallyEqual() [4/24]

bool SimTK::isNumericallyEqual ( const double &  a, const float &  b, double  tol = RTraits<float>::getDefaultTolerance()  )

inline

Compare a float and a double for approximate equality at float precision.

isNumericallyEqual() [5/24]

bool SimTK::isNumericallyEqual ( const float &  a, int  b, double  tol = RTraits<float>::getDefaultTolerance()  )

inline

Test a float for approximate equality to an integer.

isNumericallyEqual() [6/24]

bool SimTK::isNumericallyEqual ( int  a, const float &  b, double  tol = RTraits<float>::getDefaultTolerance()  )

inline

Test a float for approximate equality to an integer.

isNumericallyEqual() [7/24]

bool SimTK::isNumericallyEqual ( const double &  a, int  b, double  tol = RTraits<double>::getDefaultTolerance()  )

inline

Test a double for approximate equality to an integer.

isNumericallyEqual() [8/24]

bool SimTK::isNumericallyEqual ( int  a, const double &  b, double  tol = RTraits<double>::getDefaultTolerance()  )

inline

Test a double for approximate equality to an integer.

isNumericallyEqual() [9/24]

template<class P , class Q >

bool SimTK::isNumericallyEqual ( const std::complex< P > &  a, const std::complex< Q > &  b, double  tol = RTraits<typename Narrowest<P,Q>::Precision>::getDefaultTolerance()  )

inline

Compare two complex numbers for approximate equality, using the numerical accuracy expectation of the narrower of the two precisions in the case of mixed precision.

isNumericallyEqual() [10/24]

template<class P , class Q >

bool SimTK::isNumericallyEqual ( const conjugate< P > &  a, const conjugate< Q > &  b, double  tol = RTraits<typename Narrowest<P,Q>::Precision>::getDefaultTolerance()  )

inline

Compare two conjugate numbers for approximate equality, using the numerical accuracy expectation of the narrower of the two precisions in the case of mixed precision.

isNumericallyEqual() [11/24]

template<class P , class Q >

bool SimTK::isNumericallyEqual ( const std::complex< P > &  a, const conjugate< Q > &  b, double  tol = RTraits<typename Narrowest<P,Q>::Precision>::getDefaultTolerance()  )

inline

Compare a complex and a conjugate number for approximate equality, using the numerical accuracy expectation of the narrower of the two precisions in the case of mixed precision.

isNumericallyEqual() [12/24]

template<class P , class Q >

bool SimTK::isNumericallyEqual ( const conjugate< P > &  a, const std::complex< Q > &  b, double  tol = RTraits<typename Narrowest<P,Q>::Precision>::getDefaultTolerance()  )

inline

Compare a complex and a conjugate number for approximate equality, using the numerical accuracy expectation of the narrower of the two precisions in the case of mixed precision.

isNumericallyEqual() [13/24]

template<class P >

bool SimTK::isNumericallyEqual ( const std::complex< P > &  a, const float &  b, double  tol = RTraits<float>::getDefaultTolerance()  )

inline

Test whether a complex number is approximately equal to a particular real float.

isNumericallyEqual() [14/24]

template<class P >

bool SimTK::isNumericallyEqual ( const float &  a, const std::complex< P > &  b, double  tol = RTraits<float>::getDefaultTolerance()  )

inline

Test whether a complex number is approximately equal to a particular real float.

isNumericallyEqual() [15/24]

template<class P >

bool SimTK::isNumericallyEqual ( const std::complex< P > &  a, const double &  b, double  tol = RTraits<typename Narrowest<P,double>::Precision>::getDefaultTolerance()  )

inline

Test whether a complex number is approximately equal to a particular real double.

isNumericallyEqual() [16/24]

template<class P >

bool SimTK::isNumericallyEqual ( const double &  a, const std::complex< P > &  b, double  tol = RTraits<typename Narrowest<P,double>::Precision>::getDefaultTolerance()  )

inline

Test whether a complex number is approximately equal to a particular real double.

isNumericallyEqual() [17/24]

template<class P >

bool SimTK::isNumericallyEqual ( const std::complex< P > &  a, int  b, double  tol = RTraits<P>::getDefaultTolerance()  )

inline

Test whether a complex number is approximately equal to a particular integer.

isNumericallyEqual() [18/24]

template<class P >

bool SimTK::isNumericallyEqual ( int  a, const std::complex< P > &  b, double  tol = RTraits<P>::getDefaultTolerance()  )

inline

Test whether a complex number is approximately equal to a particular integer.

isNumericallyEqual() [19/24]

template<class P >

bool SimTK::isNumericallyEqual ( const conjugate< P > &  a, const float &  b, double  tol = RTraits<float>::getDefaultTolerance()  )

inline

Test whether a conjugate number is approximately equal to a particular real float.

isNumericallyEqual() [20/24]

template<class P >

bool SimTK::isNumericallyEqual ( const float &  a, const conjugate< P > &  b, double  tol = RTraits<float>::getDefaultTolerance()  )

inline

Test whether a conjugate number is approximately equal to a particular real float.

isNumericallyEqual() [21/24]

template<class P >

bool SimTK::isNumericallyEqual ( const conjugate< P > &  a, const double &  b, double  tol = RTraits<typename Narrowest<P,double>::Precision>::getDefaultTolerance()  )

inline

Test whether a conjugate number is approximately equal to a particular real double.

isNumericallyEqual() [22/24]

template<class P >

bool SimTK::isNumericallyEqual ( const double &  a, const conjugate< P > &  b, double  tol = RTraits<typename Narrowest<P,double>::Precision>::getDefaultTolerance()  )

inline

Test whether a conjugate number is approximately equal to a particular real double.

isNumericallyEqual() [23/24]

template<class P >

bool SimTK::isNumericallyEqual ( const conjugate< P > &  a, int  b, double  tol = RTraits<P>::getDefaultTolerance()  )

inline

Test whether a conjugate number is approximately equal to a particular integer.

isNumericallyEqual() [24/24]

template<class P >

bool SimTK::isNumericallyEqual ( int  a, const conjugate< P > &  b, double  tol = RTraits<P>::getDefaultTolerance()  )

inline

Test whether a conjugate number is approximately equal to a particular integer.

SimTK_BNTCMPLX_SPEC() [1/4]

SimTK::SimTK_BNTCMPLX_SPEC	(	float	,
		float
	)

SimTK_BNTCMPLX_SPEC() [2/4]

SimTK::SimTK_BNTCMPLX_SPEC	(	float	,
		double
	)

SimTK_BNTCMPLX_SPEC() [3/4]

SimTK::SimTK_BNTCMPLX_SPEC	(	double	,
		float
	)

SimTK_BNTCMPLX_SPEC() [4/4]

SimTK::SimTK_BNTCMPLX_SPEC	(	double	,
		double
	)

SimTK_NTRAITS_CONJ_SPEC() [1/4]

SimTK::SimTK_NTRAITS_CONJ_SPEC	(	float	,
		float
	)

SimTK_NTRAITS_CONJ_SPEC() [2/4]

SimTK::SimTK_NTRAITS_CONJ_SPEC	(	float	,
		double
	)

SimTK_NTRAITS_CONJ_SPEC() [3/4]

SimTK::SimTK_NTRAITS_CONJ_SPEC	(	double	,
		float
	)

SimTK_NTRAITS_CONJ_SPEC() [4/4]

SimTK::SimTK_NTRAITS_CONJ_SPEC	(	double	,
		double
	)

SimTK_DEFINE_REAL_NTRAITS() [1/2]

SimTK::SimTK_DEFINE_REAL_NTRAITS

(

float

)

SimTK_DEFINE_REAL_NTRAITS() [2/2]

SimTK::SimTK_DEFINE_REAL_NTRAITS

(

double

)

atMostOneBitIsSet() [1/11]

bool SimTK::atMostOneBitIsSet ( unsigned char  v )

inline

atMostOneBitIsSet() [2/11]

bool SimTK::atMostOneBitIsSet ( unsigned short  v )

inline

atMostOneBitIsSet() [3/11]

bool SimTK::atMostOneBitIsSet ( unsigned int  v )

inline

atMostOneBitIsSet() [4/11]

bool SimTK::atMostOneBitIsSet ( unsigned long  v )

inline

atMostOneBitIsSet() [5/11]

bool SimTK::atMostOneBitIsSet ( unsigned long long  v )

inline

atMostOneBitIsSet() [6/11]

bool SimTK::atMostOneBitIsSet ( signed char  v )

inline

atMostOneBitIsSet() [7/11]

bool SimTK::atMostOneBitIsSet ( char  v )

inline

atMostOneBitIsSet() [8/11]

bool SimTK::atMostOneBitIsSet ( short  v )

inline

atMostOneBitIsSet() [9/11]

bool SimTK::atMostOneBitIsSet ( int  v )

inline

atMostOneBitIsSet() [10/11]

bool SimTK::atMostOneBitIsSet ( long  v )

inline

atMostOneBitIsSet() [11/11]

bool SimTK::atMostOneBitIsSet ( long long  v )

inline

exactlyOneBitIsSet() [1/11]

bool SimTK::exactlyOneBitIsSet ( unsigned char  v )

inline

exactlyOneBitIsSet() [2/11]

bool SimTK::exactlyOneBitIsSet ( unsigned short  v )

inline

exactlyOneBitIsSet() [3/11]

bool SimTK::exactlyOneBitIsSet ( unsigned int  v )

inline

exactlyOneBitIsSet() [4/11]

bool SimTK::exactlyOneBitIsSet ( unsigned long  v )

inline

exactlyOneBitIsSet() [5/11]

bool SimTK::exactlyOneBitIsSet ( unsigned long long  v )

inline

exactlyOneBitIsSet() [6/11]

bool SimTK::exactlyOneBitIsSet ( signed char  v )

inline

exactlyOneBitIsSet() [7/11]

bool SimTK::exactlyOneBitIsSet ( char  v )

inline

exactlyOneBitIsSet() [8/11]

bool SimTK::exactlyOneBitIsSet ( short  v )

inline

exactlyOneBitIsSet() [9/11]

bool SimTK::exactlyOneBitIsSet ( int  v )

inline

exactlyOneBitIsSet() [10/11]

bool SimTK::exactlyOneBitIsSet ( long  v )

inline

exactlyOneBitIsSet() [11/11]

bool SimTK::exactlyOneBitIsSet ( long long  v )

inline

signBit() [1/14]

bool SimTK::signBit ( unsigned char  u )

inline

signBit() [2/14]

bool SimTK::signBit ( unsigned short  u )

inline

signBit() [3/14]

bool SimTK::signBit ( unsigned int  u )

inline

signBit() [4/14]

bool SimTK::signBit ( unsigned long  u )

inline

signBit() [5/14]

bool SimTK::signBit ( unsigned long long  u )

inline

signBit() [6/14]

bool SimTK::signBit ( signed char  i )

inline

signBit() [7/14]

bool SimTK::signBit ( short  i )

inline

signBit() [8/14]

bool SimTK::signBit ( int  i )

inline

signBit() [9/14]

bool SimTK::signBit ( long long  i )

inline

signBit() [10/14]

bool SimTK::signBit ( long  i )

inline

signBit() [11/14]

bool SimTK::signBit ( const float &  f )

inline

signBit() [12/14]

bool SimTK::signBit ( const double &  d )

inline

signBit() [13/14]

bool SimTK::signBit ( const negator< float > &  nf )

inline

signBit() [14/14]

bool SimTK::signBit ( const negator< double > &  nd )

inline

sign() [1/14]

unsigned int SimTK::sign ( unsigned char  u )

inline

sign() [2/14]

unsigned int SimTK::sign ( unsigned short  u )

inline

sign() [3/14]

unsigned int SimTK::sign ( unsigned int  u )

inline

sign() [4/14]

unsigned int SimTK::sign ( unsigned long  u )

inline

sign() [5/14]

unsigned int SimTK::sign ( unsigned long long  u )

inline

sign() [6/14]

int SimTK::sign ( signed char  i )

inline

sign() [7/14]

int SimTK::sign ( short  i )

inline

sign() [8/14]

int SimTK::sign ( int  i )

inline

sign() [9/14]

int SimTK::sign ( long  i )

inline

sign() [10/14]

int SimTK::sign ( long long  i )

inline

sign() [11/14]

int SimTK::sign ( const float &  x )

inline

sign() [12/14]

int SimTK::sign ( const double &  x )

inline

sign() [13/14]

int SimTK::sign ( const negator< float > &  x )

inline

sign() [14/14]

int SimTK::sign ( const negator< double > &  x )

inline

square() [1/19]

unsigned char SimTK::square ( unsigned char  u )

inline

square() [2/19]

unsigned short SimTK::square ( unsigned short  u )

inline

square() [3/19]

unsigned int SimTK::square ( unsigned int  u )

inline

square() [4/19]

unsigned long SimTK::square ( unsigned long  u )

inline

square() [5/19]

unsigned long long SimTK::square ( unsigned long long  u )

inline

square() [6/19]

char SimTK::square ( char  c )

inline

square() [7/19]

signed char SimTK::square ( signed char  i )

inline

square() [8/19]

short SimTK::square ( short  i )

inline

square() [9/19]

int SimTK::square ( int  i )

inline

square() [10/19]

long SimTK::square ( long  i )

inline

square() [11/19]

long long SimTK::square ( long long  i )

inline

square() [12/19]

float SimTK::square ( const float &  x )

inline

square() [13/19]

double SimTK::square ( const double &  x )

inline

square() [14/19]

float SimTK::square ( const negator< float > &  x )

inline

square() [15/19]

double SimTK::square ( const negator< double > &  x )

inline

square() [16/19]

template<class P >

std::complex<P> SimTK::square ( const std::complex< P > &  x )

inline

square() [17/19]

template<class P >

std::complex<P> SimTK::square ( const conjugate< P > &  x )

inline

square() [18/19]

template<class P >

std::complex<P> SimTK::square ( const negator< std::complex< P > > &  x )

inline

square() [19/19]

template<class P >

std::complex<P> SimTK::square ( const negator< conjugate< P > > &  x )

inline

cube() [1/19]

unsigned char SimTK::cube ( unsigned char  u )

inline

cube() [2/19]

unsigned short SimTK::cube ( unsigned short  u )

inline

cube() [3/19]

unsigned int SimTK::cube ( unsigned int  u )

inline

cube() [4/19]

unsigned long SimTK::cube ( unsigned long  u )

inline

cube() [5/19]

unsigned long long SimTK::cube ( unsigned long long  u )

inline

cube() [6/19]

char SimTK::cube ( char  c )

inline

cube() [7/19]

signed char SimTK::cube ( signed char  i )

inline

cube() [8/19]

short SimTK::cube ( short  i )

inline

cube() [9/19]

int SimTK::cube ( int  i )

inline

cube() [10/19]

long SimTK::cube ( long  i )

inline

cube() [11/19]

long long SimTK::cube ( long long  i )

inline

cube() [12/19]

float SimTK::cube ( const float &  x )

inline

cube() [13/19]

double SimTK::cube ( const double &  x )

inline

cube() [14/19]

negator<float> SimTK::cube ( const negator< float > &  x )

inline

cube() [15/19]

negator<double> SimTK::cube ( const negator< double > &  x )

inline

cube() [16/19]

template<class P >

std::complex<P> SimTK::cube ( const std::complex< P > &  x )

inline

cube() [17/19]

template<class P >

std::complex<P> SimTK::cube ( const negator< std::complex< P > > &  x )

inline

cube() [18/19]

template<class P >

std::complex<P> SimTK::cube ( const conjugate< P > &  x )

inline

cube() [19/19]

template<class P >

std::complex<P> SimTK::cube ( const negator< conjugate< P > > &  x )

inline

clampInPlace() [1/21]

double& SimTK::clampInPlace ( double  low, double &  v, double  high  )

inline

Check that low <= v <= high and modify v in place if necessary to bring it into that range.

Parameters

[in]	low	The lower bound; must be <= high.
[in,out]	v	The variable whose value is changed if necessary.
[in]	high	The upper bound; must be >= low.

Returns

A writable reference to the now-possibly-modified input variable v.

This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.

Cost: These are very fast inline methods; the floating point ones use just two flops.

clampInPlace() [2/21]

float& SimTK::clampInPlace ( float  low, float &  v, float  high  )

inline

Check that low <= v <= high and modify v in place if necessary to bring it into that range.

Parameters

[in]	low	The lower bound; must be <= high.
[in,out]	v	The variable whose value is changed if necessary.
[in]	high	The upper bound; must be >= low.

Returns

A writable reference to the now-possibly-modified input variable v.

This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.

Cost: These are very fast inline methods; the floating point ones use just two flops.

clampInPlace() [3/21]

double& SimTK::clampInPlace ( int  low, double &  v, int  high  )

inline

Check that low <= v <= high and modify v in place if necessary to bring it into that range.

Parameters

[in]	low	The lower bound; must be <= high.
[in,out]	v	The variable whose value is changed if necessary.
[in]	high	The upper bound; must be >= low.

Returns

A writable reference to the now-possibly-modified input variable v.

This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.

Cost: These are very fast inline methods; the floating point ones use just two flops. Takes integer bounds to avoid need for explicit casts.

clampInPlace() [4/21]

float& SimTK::clampInPlace ( int  low, float &  v, int  high  )

inline

Check that low <= v <= high and modify v in place if necessary to bring it into that range.

Parameters

[in]	low	The lower bound; must be <= high.
[in,out]	v	The variable whose value is changed if necessary.
[in]	high	The upper bound; must be >= low.

Returns

A writable reference to the now-possibly-modified input variable v.

This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.

Cost: These are very fast inline methods; the floating point ones use just two flops. Takes integer bounds to avoid need for explicit casts.

clampInPlace() [5/21]

double& SimTK::clampInPlace ( int  low, double &  v, double  high  )

inline

Check that low <= v <= high and modify v in place if necessary to bring it into that range.

Parameters

[in]	low	The lower bound; must be <= high.
[in,out]	v	The variable whose value is changed if necessary.
[in]	high	The upper bound; must be >= low.

Returns

A writable reference to the now-possibly-modified input variable v.

This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.

Cost: These are very fast inline methods; the floating point ones use just two flops. Takes an integer bound to avoid need for explicit casts.

clampInPlace() [6/21]

float& SimTK::clampInPlace ( int  low, float &  v, float  high  )

inline

Check that low <= v <= high and modify v in place if necessary to bring it into that range.

Parameters

[in]	low	The lower bound; must be <= high.
[in,out]	v	The variable whose value is changed if necessary.
[in]	high	The upper bound; must be >= low.

Returns

A writable reference to the now-possibly-modified input variable v.

This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.

Cost: These are very fast inline methods; the floating point ones use just two flops. Takes an integer bound to avoid need for explicit casts.

clampInPlace() [7/21]

double& SimTK::clampInPlace ( double  low, double &  v, int  high  )

inline

Check that low <= v <= high and modify v in place if necessary to bring it into that range.

Parameters

[in]	low	The lower bound; must be <= high.
[in,out]	v	The variable whose value is changed if necessary.
[in]	high	The upper bound; must be >= low.

Returns

A writable reference to the now-possibly-modified input variable v.

This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.

Cost: These are very fast inline methods; the floating point ones use just two flops. Takes an integer bound to avoid need for explicit casts.

clampInPlace() [8/21]

float& SimTK::clampInPlace ( float  low, float &  v, int  high  )

inline

Check that low <= v <= high and modify v in place if necessary to bring it into that range.

Parameters

[in]	low	The lower bound; must be <= high.
[in,out]	v	The variable whose value is changed if necessary.
[in]	high	The upper bound; must be >= low.

Returns

A writable reference to the now-possibly-modified input variable v.

This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.

Cost: These are very fast inline methods; the floating point ones use just two flops. Takes an integer bound to avoid need for explicit casts.

clampInPlace() [9/21]

unsigned char& SimTK::clampInPlace ( unsigned char  low, unsigned char &  v, unsigned char  high  )

inline

Check that low <= v <= high and modify v in place if necessary to bring it into that range.

Parameters

[in]	low	The lower bound; must be <= high.
[in,out]	v	The variable whose value is changed if necessary.
[in]	high	The upper bound; must be >= low.

Returns

A writable reference to the now-possibly-modified input variable v.

This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.

Cost: These are very fast inline methods; the floating point ones use just two flops.

clampInPlace() [10/21]

unsigned short& SimTK::clampInPlace ( unsigned short  low, unsigned short &  v, unsigned short  high  )

inline

Check that low <= v <= high and modify v in place if necessary to bring it into that range.

Parameters

[in]	low	The lower bound; must be <= high.
[in,out]	v	The variable whose value is changed if necessary.
[in]	high	The upper bound; must be >= low.

Returns

A writable reference to the now-possibly-modified input variable v.

This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.

Cost: These are very fast inline methods; the floating point ones use just two flops.

clampInPlace() [11/21]

unsigned int& SimTK::clampInPlace ( unsigned int  low, unsigned int &  v, unsigned int  high  )

inline

Check that low <= v <= high and modify v in place if necessary to bring it into that range.

Parameters

[in]	low	The lower bound; must be <= high.
[in,out]	v	The variable whose value is changed if necessary.
[in]	high	The upper bound; must be >= low.

Returns

A writable reference to the now-possibly-modified input variable v.

This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.

Cost: These are very fast inline methods; the floating point ones use just two flops.

clampInPlace() [12/21]

unsigned long& SimTK::clampInPlace ( unsigned long  low, unsigned long &  v, unsigned long  high  )

inline

Check that low <= v <= high and modify v in place if necessary to bring it into that range.

Parameters

[in]	low	The lower bound; must be <= high.
[in,out]	v	The variable whose value is changed if necessary.
[in]	high	The upper bound; must be >= low.

Returns

A writable reference to the now-possibly-modified input variable v.

This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.

Cost: These are very fast inline methods; the floating point ones use just two flops.

clampInPlace() [13/21]

unsigned long long& SimTK::clampInPlace ( unsigned long long  low, unsigned long long &  v, unsigned long long  high  )

inline

Check that low <= v <= high and modify v in place if necessary to bring it into that range.

Parameters

[in]	low	The lower bound; must be <= high.
[in,out]	v	The variable whose value is changed if necessary.
[in]	high	The upper bound; must be >= low.

Returns

A writable reference to the now-possibly-modified input variable v.

This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.

Cost: These are very fast inline methods; the floating point ones use just two flops.

clampInPlace() [14/21]

char& SimTK::clampInPlace ( char  low, char &  v, char  high  )

inline

Check that low <= v <= high and modify v in place if necessary to bring it into that range.

Parameters

[in]	low	The lower bound; must be <= high.
[in,out]	v	The variable whose value is changed if necessary.
[in]	high	The upper bound; must be >= low.

Returns

A writable reference to the now-possibly-modified input variable v.

This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.

Cost: These are very fast inline methods; the floating point ones use just two flops.

clampInPlace() [15/21]

signed char& SimTK::clampInPlace ( signed char  low, signed char &  v, signed char  high  )

inline

Check that low <= v <= high and modify v in place if necessary to bring it into that range.

Parameters

[in]	low	The lower bound; must be <= high.
[in,out]	v	The variable whose value is changed if necessary.
[in]	high	The upper bound; must be >= low.

Returns

A writable reference to the now-possibly-modified input variable v.

This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.

Cost: These are very fast inline methods; the floating point ones use just two flops.

clampInPlace() [16/21]

short& SimTK::clampInPlace ( short  low, short &  v, short  high  )

inline

Check that low <= v <= high and modify v in place if necessary to bring it into that range.

Parameters

[in]	low	The lower bound; must be <= high.
[in,out]	v	The variable whose value is changed if necessary.
[in]	high	The upper bound; must be >= low.

Returns

A writable reference to the now-possibly-modified input variable v.

This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.

Cost: These are very fast inline methods; the floating point ones use just two flops.

clampInPlace() [17/21]

int& SimTK::clampInPlace ( int  low, int &  v, int  high  )

inline

Check that low <= v <= high and modify v in place if necessary to bring it into that range.

Parameters

[in]	low	The lower bound; must be <= high.
[in,out]	v	The variable whose value is changed if necessary.
[in]	high	The upper bound; must be >= low.

Returns

A writable reference to the now-possibly-modified input variable v.

This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.

Cost: These are very fast inline methods; the floating point ones use just two flops.

clampInPlace() [18/21]

long& SimTK::clampInPlace ( long  low, long &  v, long  high  )

inline

Check that low <= v <= high and modify v in place if necessary to bring it into that range.

Parameters

[in]	low	The lower bound; must be <= high.
[in,out]	v	The variable whose value is changed if necessary.
[in]	high	The upper bound; must be >= low.

Returns

A writable reference to the now-possibly-modified input variable v.

This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.

Cost: These are very fast inline methods; the floating point ones use just two flops.

clampInPlace() [19/21]

long long& SimTK::clampInPlace ( long long  low, long long &  v, long long  high  )

inline

Check that low <= v <= high and modify v in place if necessary to bring it into that range.

Parameters

[in]	low	The lower bound; must be <= high.
[in,out]	v	The variable whose value is changed if necessary.
[in]	high	The upper bound; must be >= low.

Returns

A writable reference to the now-possibly-modified input variable v.

This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.

Cost: These are very fast inline methods; the floating point ones use just two flops.

clampInPlace() [20/21]

negator<float>& SimTK::clampInPlace ( float  low, negator< float > &  v, float  high  )

inline

Check that low <= v <= high and modify v in place if necessary to bring it into that range.

Parameters

[in]	low	The lower bound; must be <= high.
[in,out]	v	The variable whose value is changed if necessary.
[in]	high	The upper bound; must be >= low.

Returns

A writable reference to the now-possibly-modified input variable v.

This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.

Cost: These are very fast inline methods; the floating point ones use just two flops.

clampInPlace() [21/21]

negator<double>& SimTK::clampInPlace ( double  low, negator< double > &  v, double  high  )

inline

Check that low <= v <= high and modify v in place if necessary to bring it into that range.

Parameters

[in]	low	The lower bound; must be <= high.
[in,out]	v	The variable whose value is changed if necessary.
[in]	high	The upper bound; must be >= low.

Returns

A writable reference to the now-possibly-modified input variable v.

This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.

Cost: These are very fast inline methods; the floating point ones use just two flops.

clamp() [1/21]

double SimTK::clamp ( double  low, double  v, double  high  )

inline

If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v.

Parameters

[in]	low	The lower bound; must be <= high.
[in]	v	The value to be put into range [low,high].
[in]	high	The upper bound; must be >= low.

Returns

Either the value v or one of the bounds.

This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.

Warning

Viewed as a function of the input value v, clamp(v) is not very smooth – it is continuous (C0) but even its first derivative is infinite at the bounds.

Cost: These are very fast, inline methods; the floating point ones use just two flops.

See also

clampInPlace()

clamp() [2/21]

float SimTK::clamp ( float  low, float  v, float  high  )

inline

If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v.

Parameters

[in]	low	The lower bound; must be <= high.
[in]	v	The value to be put into range [low,high].
[in]	high	The upper bound; must be >= low.

Returns

Either the value v or one of the bounds.

This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.

Warning

Viewed as a function of the input value v, clamp(v) is not very smooth – it is continuous (C0) but even its first derivative is infinite at the bounds.

Cost: These are very fast, inline methods; the floating point ones use just two flops.

See also

clampInPlace()

clamp() [3/21]

double SimTK::clamp ( int  low, double  v, int  high  )

inline

If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v.

Parameters

[in]	low	The lower bound; must be <= high.
[in]	v	The value to be put into range [low,high].
[in]	high	The upper bound; must be >= low.

Returns

Either the value v or one of the bounds.

This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.

Warning

Viewed as a function of the input value v, clamp(v) is not very smooth – it is continuous (C0) but even its first derivative is infinite at the bounds.

Cost: These are very fast, inline methods; the floating point ones use just two flops.

See also

clampInPlace() Takes integer bounds to avoid need for explicit casts.

clamp() [4/21]

float SimTK::clamp ( int  low, float  v, int  high  )

inline

If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v.

Parameters

[in]	low	The lower bound; must be <= high.
[in]	v	The value to be put into range [low,high].
[in]	high	The upper bound; must be >= low.

Returns

Either the value v or one of the bounds.

This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.

Warning

Viewed as a function of the input value v, clamp(v) is not very smooth – it is continuous (C0) but even its first derivative is infinite at the bounds.

Cost: These are very fast, inline methods; the floating point ones use just two flops.

See also

clampInPlace() Takes integer bounds to avoid need for explicit casts.

clamp() [5/21]

double SimTK::clamp ( int  low, double  v, double  high  )

inline

If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v.

Parameters

[in]	low	The lower bound; must be <= high.
[in]	v	The value to be put into range [low,high].
[in]	high	The upper bound; must be >= low.

Returns

Either the value v or one of the bounds.

This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.

Warning

Viewed as a function of the input value v, clamp(v) is not very smooth – it is continuous (C0) but even its first derivative is infinite at the bounds.

Cost: These are very fast, inline methods; the floating point ones use just two flops.

See also

clampInPlace() Takes an integer bound to avoid need for explicit casts.

clamp() [6/21]

float SimTK::clamp ( int  low, float  v, float  high  )

inline

If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v.

Parameters

[in]	low	The lower bound; must be <= high.
[in]	v	The value to be put into range [low,high].
[in]	high	The upper bound; must be >= low.

Returns

Either the value v or one of the bounds.

This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.

Warning

Viewed as a function of the input value v, clamp(v) is not very smooth – it is continuous (C0) but even its first derivative is infinite at the bounds.

Cost: These are very fast, inline methods; the floating point ones use just two flops.

See also

clampInPlace() Takes an integer bound to avoid need for explicit casts.

clamp() [7/21]

double SimTK::clamp ( double  low, double  v, int  high  )

inline

If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v.

Parameters

[in]	low	The lower bound; must be <= high.
[in]	v	The value to be put into range [low,high].
[in]	high	The upper bound; must be >= low.

Returns

Either the value v or one of the bounds.

This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.

Warning

Viewed as a function of the input value v, clamp(v) is not very smooth – it is continuous (C0) but even its first derivative is infinite at the bounds.

Cost: These are very fast, inline methods; the floating point ones use just two flops.

See also

clampInPlace() Takes an integer bound to avoid need for explicit casts.

clamp() [8/21]

float SimTK::clamp ( float  low, float  v, int  high  )

inline

If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v.

Parameters

[in]	low	The lower bound; must be <= high.
[in]	v	The value to be put into range [low,high].
[in]	high	The upper bound; must be >= low.

Returns

Either the value v or one of the bounds.

This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.

Warning

Viewed as a function of the input value v, clamp(v) is not very smooth – it is continuous (C0) but even its first derivative is infinite at the bounds.

Cost: These are very fast, inline methods; the floating point ones use just two flops.

See also

clampInPlace() Takes an integer bound to avoid need for explicit casts.

clamp() [9/21]

unsigned char SimTK::clamp ( unsigned char  low, unsigned char  v, unsigned char  high  )

inline

If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v.

Parameters

[in]	low	The lower bound; must be <= high.
[in]	v	The value to be put into range [low,high].
[in]	high	The upper bound; must be >= low.

Returns

Either the value v or one of the bounds.

This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.

Warning

Viewed as a function of the input value v, clamp(v) is not very smooth – it is continuous (C0) but even its first derivative is infinite at the bounds.

Cost: These are very fast, inline methods; the floating point ones use just two flops.

See also

clampInPlace()

clamp() [10/21]

unsigned short SimTK::clamp ( unsigned short  low, unsigned short  v, unsigned short  high  )

inline

If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v.

Parameters

[in]	low	The lower bound; must be <= high.
[in]	v	The value to be put into range [low,high].
[in]	high	The upper bound; must be >= low.

Returns

Either the value v or one of the bounds.

This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.

Warning

Viewed as a function of the input value v, clamp(v) is not very smooth – it is continuous (C0) but even its first derivative is infinite at the bounds.

Cost: These are very fast, inline methods; the floating point ones use just two flops.

See also

clampInPlace()

clamp() [11/21]

unsigned int SimTK::clamp ( unsigned int  low, unsigned int  v, unsigned int  high  )

inline

If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v.

Parameters

[in]	low	The lower bound; must be <= high.
[in]	v	The value to be put into range [low,high].
[in]	high	The upper bound; must be >= low.

Returns

Either the value v or one of the bounds.

This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.

Warning

Viewed as a function of the input value v, clamp(v) is not very smooth – it is continuous (C0) but even its first derivative is infinite at the bounds.

Cost: These are very fast, inline methods; the floating point ones use just two flops.

See also

clampInPlace()

clamp() [12/21]

unsigned long SimTK::clamp ( unsigned long  low, unsigned long  v, unsigned long  high  )

inline

If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v.

Parameters

[in]	low	The lower bound; must be <= high.
[in]	v	The value to be put into range [low,high].
[in]	high	The upper bound; must be >= low.

Returns

Either the value v or one of the bounds.

This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.

Warning

Viewed as a function of the input value v, clamp(v) is not very smooth – it is continuous (C0) but even its first derivative is infinite at the bounds.

Cost: These are very fast, inline methods; the floating point ones use just two flops.

See also

clampInPlace()

clamp() [13/21]

unsigned long long SimTK::clamp ( unsigned long long  low, unsigned long long  v, unsigned long long  high  )

inline

If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v.

Parameters

[in]	low	The lower bound; must be <= high.
[in]	v	The value to be put into range [low,high].
[in]	high	The upper bound; must be >= low.

Returns

Either the value v or one of the bounds.

This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.

Warning

Viewed as a function of the input value v, clamp(v) is not very smooth – it is continuous (C0) but even its first derivative is infinite at the bounds.

Cost: These are very fast, inline methods; the floating point ones use just two flops.

See also

clampInPlace()

clamp() [14/21]

char SimTK::clamp ( char  low, char  v, char  high  )

inline

If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v.

Parameters

[in]	low	The lower bound; must be <= high.
[in]	v	The value to be put into range [low,high].
[in]	high	The upper bound; must be >= low.

Returns

Either the value v or one of the bounds.

This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.

Warning

Viewed as a function of the input value v, clamp(v) is not very smooth – it is continuous (C0) but even its first derivative is infinite at the bounds.

Cost: These are very fast, inline methods; the floating point ones use just two flops.

See also

clampInPlace()

clamp() [15/21]

signed char SimTK::clamp ( signed char  low, signed char  v, signed char  high  )

inline

If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v.

Parameters

[in]	low	The lower bound; must be <= high.
[in]	v	The value to be put into range [low,high].
[in]	high	The upper bound; must be >= low.

Returns

Either the value v or one of the bounds.

This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.

Warning

Viewed as a function of the input value v, clamp(v) is not very smooth – it is continuous (C0) but even its first derivative is infinite at the bounds.

Cost: These are very fast, inline methods; the floating point ones use just two flops.

See also

clampInPlace()

clamp() [16/21]

short SimTK::clamp ( short  low, short  v, short  high  )

inline

If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v.

Parameters

[in]	low	The lower bound; must be <= high.
[in]	v	The value to be put into range [low,high].
[in]	high	The upper bound; must be >= low.

Returns

Either the value v or one of the bounds.

This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.

Warning

Viewed as a function of the input value v, clamp(v) is not very smooth – it is continuous (C0) but even its first derivative is infinite at the bounds.

Cost: These are very fast, inline methods; the floating point ones use just two flops.

See also

clampInPlace()

clamp() [17/21]

int SimTK::clamp ( int  low, int  v, int  high  )

inline

If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v.

Parameters

[in]	low	The lower bound; must be <= high.
[in]	v	The value to be put into range [low,high].
[in]	high	The upper bound; must be >= low.

Returns

Either the value v or one of the bounds.

This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.

Warning

Viewed as a function of the input value v, clamp(v) is not very smooth – it is continuous (C0) but even its first derivative is infinite at the bounds.

Cost: These are very fast, inline methods; the floating point ones use just two flops.

See also

clampInPlace()

clamp() [18/21]

long SimTK::clamp ( long  low, long  v, long  high  )

inline

If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v.

Parameters

[in]	low	The lower bound; must be <= high.
[in]	v	The value to be put into range [low,high].
[in]	high	The upper bound; must be >= low.

Returns

Either the value v or one of the bounds.

This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.

Warning

Viewed as a function of the input value v, clamp(v) is not very smooth – it is continuous (C0) but even its first derivative is infinite at the bounds.

Cost: These are very fast, inline methods; the floating point ones use just two flops.

See also

clampInPlace()

clamp() [19/21]

long long SimTK::clamp ( long long  low, long long  v, long long  high  )

inline

If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v.

Parameters

[in]	low	The lower bound; must be <= high.
[in]	v	The value to be put into range [low,high].
[in]	high	The upper bound; must be >= low.

Returns

Either the value v or one of the bounds.

This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.

Warning

Viewed as a function of the input value v, clamp(v) is not very smooth – it is continuous (C0) but even its first derivative is infinite at the bounds.

Cost: These are very fast, inline methods; the floating point ones use just two flops.

See also

clampInPlace()

clamp() [20/21]

float SimTK::clamp ( float  low, negator< float >  v, float  high  )

inline

If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v.

Parameters

[in]	low	The lower bound; must be <= high.
[in]	v	The value to be put into range [low,high].
[in]	high	The upper bound; must be >= low.

Returns

Either the value v or one of the bounds.

This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.

Warning

Viewed as a function of the input value v, clamp(v) is not very smooth – it is continuous (C0) but even its first derivative is infinite at the bounds.

Cost: These are very fast, inline methods; the floating point ones use just two flops.

See also

clampInPlace() Explicitly takes a negator<float> argument to help the compiler find the right overload, but the negation is performed (1 extra flop) and the result type is an ordinary float.

clamp() [21/21]

double SimTK::clamp ( double  low, negator< double >  v, double  high  )

inline

If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v.

Parameters

[in]	low	The lower bound; must be <= high.
[in]	v	The value to be put into range [low,high].
[in]	high	The upper bound; must be >= low.

Returns

Either the value v or one of the bounds.

This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.

Warning

Viewed as a function of the input value v, clamp(v) is not very smooth – it is continuous (C0) but even its first derivative is infinite at the bounds.

Cost: These are very fast, inline methods; the floating point ones use just two flops.

See also

clampInPlace() Explicitly takes a negator<double> argument to help the compiler find the right overload, but the negation is performed (1 extra flop) and the result type is an ordinary double.

stepUp() [1/3]

double SimTK::stepUp ( double  x )

inline

Interpolate smoothly from 0 up to 1 as the input argument goes from 0 to 1, with first and second derivatives zero at either end of the interval.

Parameters

[in]

x

The control parameter, in range [0,1].

Returns

The smoothed output value, in range [0,1] but with first and second derivatives smoothly approaching zero as x approaches either end of its interval.

See the documentation for stepAny() for a discussion about how to shift and scale this function to produce arbitrary steps.

This function is overloaded for all the floating point precisions. Cost is 7 flops.

See also

stepDown(), stepAny()

stepDown() [1/3]

double SimTK::stepDown ( double  x )

inline

Interpolate smoothly from 1 down to 0 as the input argument goes from 0 to 1, with first and second derivatives zero at either end of the interval.

Parameters

[in]

x

The control parameter, in range [0,1].

Returns

The smoothed output value, in range [1,0] but with first and second derivatives smoothly approaching zero as x approaches either end of its interval.

See the documentation for stepAny() for a discussion about how to shift and scale this function to produce arbitrary steps.

This function is overloaded for all the floating point precisions. Cost is 8 flops.

See also

stepUp(), stepAny()

stepAny() [1/2]

double SimTK::stepAny ( double  y0, double  yRange, double  x0, double  oneOverXRange, double  x  )

inline

Interpolate smoothly from y0 to y1 as the input argument goes from x0 to x1, with first and second derivatives zero at either end of the interval.

Parameters

[in]	y0	The output value when x=x0.
[in]	yRange	The amount by which the output can change over the full interval, that is, yRange=(y1-y0) where y1 is the value of the output when x=x1.
[in]	x0	The minimum allowable value for x.
[in]	oneOverXRange	1/xRange, where xRange is the amount by which the input variable x can change over its full interval, that is, xRange=(x1-x0) where x1 is the maximum allowable value for x.
[in]	x	The control parameter, in range [x0,x1]. This is often a time over which the output transition from y0 to y1 is to occur.

Returns

The smoothed output value, in range [y0,y1] (where y1=y0+yRange) but with first and second derivatives smoothly approaching zero as x approaches either end of its interval.

Note that the desired curve is defined in terms of y0 and (y1-y0), and x0 and 1/(x1-x0), rather than y0,y1,x0,x1 which would make for a nicer calling signature. This is a concession to efficiency since the two ranges are likely to be unchanged during many calls to this function and can thus be precalculated. It wouldn't matter except that division is so expensive (equivalent to 15-20 floating point operations). If you aren't concerned about that (and in most cases it won't matter), you can call this function using y0,y1,x0,x1 like this:

y = stepAny(y0,y1-y0,x0,1/(x1-x0), x);

Not counting the cost of calculating the ranges, each call to this function requires 13 flops. Calculating the ranges in the argument list as shown above raises the per-call cost to about 30 flops. However, there are many common special cases that are much simpler. For example, if y is to go from -1 to 1 while x goes from 0 to 1, then you can write:

y = stepAny(-1,2,0,1, x);

which is still only 13 flops despite the lack of pre-calculation.

Theory

stepUp() and stepDown() and their derivatives are defined only for arguments in the range 0 to 1. To create a general step function that smoothly interpolates from y=y0 to y1 while x goes from x0 to x1, and three derivatives, we use the stepUp() functions like this:

ooxr = 1/(x1-x0);      // one over x range (signed)
yr   = y1-y0;          // y range (signed)
xadj = (x-x0)*ooxr     // x adjusted into 0:1 range (watch for roundoff)
y    = y0 + yr * stepUp(xadj);
dy   = yr*ooxr   * dstepUp(xadj);
d2y  = yr*ooxr^2 * d2stepUp(xadj);
d3y  = yr*ooxr^3 * d3stepUp(xadj);

As a common special case, note that when y has a general range but x is still in [0,1], the above simplifies considerably and you can save a few flops if you want by working with stepUp() or stepDown() directly. For example, in the common case where you want y to go from -1 to 1 as x goes from 0 to 1:

y   = stepAny(-1,2,0,1, x);  // y in [-1,1]; 13 flops
y   = -1 + 2*stepUp(x);      // equivalent, saves 4 flops
dy  = 2*dstepUp(x);          // these save 5 flops over dstepAny(), etc.
d2y = 2*d2stepUp(x);
d3y = 2*d3stepUp(x);

It would be extremely rare for these few flops to matter at all; you should almost always choose based on what looks better and/or is less error prone instead.

dstepUp() [1/2]

double SimTK::dstepUp ( double  x )

inline

First derivative of stepUp(): d/dx stepUp(x).

Parameters

[in]

x

Control parameter in range [0,1].

Returns

First derivative of stepUp() at x.

dstepDown() [1/2]

double SimTK::dstepDown ( double  x )

inline

First derivative of stepDown(): d/dx stepDown(x).

Parameters

[in]

x

Control parameter in range [0,1].

Returns

First derivative of stepDown() at x.

dstepAny() [1/2]

double SimTK::dstepAny ( double  yRange, double  x0, double  oneOverXRange, double  x  )

inline

First derivative of stepAny(): d/dx stepAny(x).

See stepAny() for parameter documentation.

Returns

First derivative of stepAny() at x.

d2stepUp() [1/2]

double SimTK::d2stepUp ( double  x )

inline

Second derivative of stepUp(): d^2/dx^2 stepUp(x).

Parameters

[in]

x

Control parameter in range [0,1].

Returns

Second derivative of stepUp() at x.

d2stepDown() [1/2]

double SimTK::d2stepDown ( double  x )

inline

Second derivative of stepDown(): d^2/dx^2 stepDown(x).

Parameters

[in]

x

Control parameter in range [0,1].

Returns

Second derivative of stepDown() at x.

d2stepAny() [1/2]

double SimTK::d2stepAny ( double  yRange, double  x0, double  oneOverXRange, double  x  )

inline

Second derivative of stepAny(): d^2/dx^2 stepAny(x).

See stepAny() for parameter documentation.

Returns

Second derivative of stepAny() at x.

d3stepUp() [1/2]

double SimTK::d3stepUp ( double  x )

inline

Third derivative of stepUp(): d^3/dx^3 stepUp(x).

Parameters

[in]

x

Control parameter in range [0,1].

Returns

Third derivative of stepUp() at x.

d3stepDown() [1/2]

double SimTK::d3stepDown ( double  x )

inline

Third derivative of stepDown(): d^3/dx^3 stepDown(x).

Parameters

[in]

x

Control parameter in range [0,1].

Returns

Third derivative of stepDown() at x.

d3stepAny() [1/2]

double SimTK::d3stepAny ( double  yRange, double  x0, double  oneOverXRange, double  x  )

inline

Third derivative of stepAny(): d^3/dx^3 stepAny(x).

See stepAny() for parameter documentation.

Returns

Third derivative of stepAny() at x.

stepUp() [2/3]

float SimTK::stepUp ( float  x )

inline

Interpolate smoothly from 0 up to 1 as the input argument goes from 0 to 1, with first and second derivatives zero at either end of the interval.

Parameters

[in]

x

The control parameter, in range [0,1].

Returns

The smoothed output value, in range [0,1] but with first and second derivatives smoothly approaching zero as x approaches either end of its interval.

See the documentation for stepAny() for a discussion about how to shift and scale this function to produce arbitrary steps.

This function is overloaded for all the floating point precisions. Cost is 7 flops.

See also

stepDown(), stepAny()

stepDown() [2/3]

float SimTK::stepDown ( float  x )

inline

Interpolate smoothly from 1 down to 0 as the input argument goes from 0 to 1, with first and second derivatives zero at either end of the interval.

Parameters

[in]

x

The control parameter, in range [0,1].

Returns

The smoothed output value, in range [1,0] but with first and second derivatives smoothly approaching zero as x approaches either end of its interval.

See the documentation for stepAny() for a discussion about how to shift and scale this function to produce arbitrary steps.

This function is overloaded for all the floating point precisions. Cost is 8 flops.

See also

stepUp(), stepAny()

stepAny() [2/2]

float SimTK::stepAny ( float  y0, float  yRange, float  x0, float  oneOverXRange, float  x  )

inline

Interpolate smoothly from y0 to y1 as the input argument goes from x0 to x1, with first and second derivatives zero at either end of the interval.

Parameters

[in]	y0	The output value when x=x0.
[in]	yRange	The amount by which the output can change over the full interval, that is, yRange=(y1-y0) where y1 is the value of the output when x=x1.
[in]	x0	The minimum allowable value for x.
[in]	oneOverXRange	1/xRange, where xRange is the amount by which the input variable x can change over its full interval, that is, xRange=(x1-x0) where x1 is the maximum allowable value for x.
[in]	x	The control parameter, in range [x0,x1]. This is often a time over which the output transition from y0 to y1 is to occur.

Returns

The smoothed output value, in range [y0,y1] (where y1=y0+yRange) but with first and second derivatives smoothly approaching zero as x approaches either end of its interval.

Note that the desired curve is defined in terms of y0 and (y1-y0), and x0 and 1/(x1-x0), rather than y0,y1,x0,x1 which would make for a nicer calling signature. This is a concession to efficiency since the two ranges are likely to be unchanged during many calls to this function and can thus be precalculated. It wouldn't matter except that division is so expensive (equivalent to 15-20 floating point operations). If you aren't concerned about that (and in most cases it won't matter), you can call this function using y0,y1,x0,x1 like this:

y = stepAny(y0,y1-y0,x0,1/(x1-x0), x);

Not counting the cost of calculating the ranges, each call to this function requires 13 flops. Calculating the ranges in the argument list as shown above raises the per-call cost to about 30 flops. However, there are many common special cases that are much simpler. For example, if y is to go from -1 to 1 while x goes from 0 to 1, then you can write:

y = stepAny(-1,2,0,1, x);

which is still only 13 flops despite the lack of pre-calculation.

Theory

stepUp() and stepDown() and their derivatives are defined only for arguments in the range 0 to 1. To create a general step function that smoothly interpolates from y=y0 to y1 while x goes from x0 to x1, and three derivatives, we use the stepUp() functions like this:

ooxr = 1/(x1-x0);      // one over x range (signed)
yr   = y1-y0;          // y range (signed)
xadj = (x-x0)*ooxr     // x adjusted into 0:1 range (watch for roundoff)
y    = y0 + yr * stepUp(xadj);
dy   = yr*ooxr   * dstepUp(xadj);
d2y  = yr*ooxr^2 * d2stepUp(xadj);
d3y  = yr*ooxr^3 * d3stepUp(xadj);

As a common special case, note that when y has a general range but x is still in [0,1], the above simplifies considerably and you can save a few flops if you want by working with stepUp() or stepDown() directly. For example, in the common case where you want y to go from -1 to 1 as x goes from 0 to 1:

y   = stepAny(-1,2,0,1, x);  // y in [-1,1]; 13 flops
y   = -1 + 2*stepUp(x);      // equivalent, saves 4 flops
dy  = 2*dstepUp(x);          // these save 5 flops over dstepAny(), etc.
d2y = 2*d2stepUp(x);
d3y = 2*d3stepUp(x);

It would be extremely rare for these few flops to matter at all; you should almost always choose based on what looks better and/or is less error prone instead.

dstepUp() [2/2]

float SimTK::dstepUp ( float  x )

inline

First derivative of stepUp(): d/dx stepUp(x).

Parameters

[in]

x

Control parameter in range [0,1].

Returns

First derivative of stepUp() at x.

dstepDown() [2/2]

float SimTK::dstepDown ( float  x )

inline

First derivative of stepDown(): d/dx stepDown(x).

Parameters

[in]

x

Control parameter in range [0,1].

Returns

First derivative of stepDown() at x.

dstepAny() [2/2]

float SimTK::dstepAny ( float  yRange, float  x0, float  oneOverXRange, float  x  )

inline

First derivative of stepAny(): d/dx stepAny(x).

See stepAny() for parameter documentation.

Returns

First derivative of stepAny() at x.

d2stepUp() [2/2]

float SimTK::d2stepUp ( float  x )

inline

Second derivative of stepUp(): d^2/dx^2 stepUp(x).

Parameters

[in]

x

Control parameter in range [0,1].

Returns

Second derivative of stepUp() at x.

d2stepDown() [2/2]

float SimTK::d2stepDown ( float  x )

inline

Second derivative of stepDown(): d^2/dx^2 stepDown(x).

Parameters

[in]

x

Control parameter in range [0,1].

Returns

Second derivative of stepDown() at x.

d2stepAny() [2/2]

float SimTK::d2stepAny ( float  yRange, float  x0, float  oneOverXRange, float  x  )

inline

Second derivative of stepAny(): d^2/dx^2 stepAny(x).

See stepAny() for parameter documentation.

Returns

Second derivative of stepAny() at x.

d3stepUp() [2/2]

float SimTK::d3stepUp ( float  x )

inline

Third derivative of stepUp(): d^3/dx^3 stepUp(x).

Parameters

[in]

x

Control parameter in range [0,1].

Returns

Third derivative of stepUp() at x.

d3stepDown() [2/2]

float SimTK::d3stepDown ( float  x )

inline

Third derivative of stepDown(): d^3/dx^3 stepDown(x).

Parameters

[in]

x

Control parameter in range [0,1].

Returns

Third derivative of stepDown() at x.

d3stepAny() [2/2]

float SimTK::d3stepAny ( float  yRange, float  x0, float  oneOverXRange, float  x  )

inline

Third derivative of stepAny(): d^3/dx^3 stepAny(x).

See stepAny() for parameter documentation.

Returns

Third derivative of stepAny() at x.

stepUp() [3/3]

double SimTK::stepUp ( int  x )

inline

Interpolate smoothly from 0 up to 1 as the input argument goes from 0 to 1, with first and second derivatives zero at either end of the interval.

Parameters

[in]

x

The control parameter, in range [0,1].

Returns

The smoothed output value, in range [0,1] but with first and second derivatives smoothly approaching zero as x approaches either end of its interval.

See the documentation for stepAny() for a discussion about how to shift and scale this function to produce arbitrary steps.

This function is overloaded for all the floating point precisions. Cost is 7 flops.

See also

stepDown(), stepAny() Treats int argument as a double (avoids ambiguity).

stepDown() [3/3]

double SimTK::stepDown ( int  x )

inline

Interpolate smoothly from 1 down to 0 as the input argument goes from 0 to 1, with first and second derivatives zero at either end of the interval.

Parameters

[in]

x

The control parameter, in range [0,1].

Returns

The smoothed output value, in range [1,0] but with first and second derivatives smoothly approaching zero as x approaches either end of its interval.

See the documentation for stepAny() for a discussion about how to shift and scale this function to produce arbitrary steps.

This function is overloaded for all the floating point precisions. Cost is 8 flops.

See also

stepUp(), stepAny() Treats int argument as a double (avoids ambiguity).

approxCompleteEllipticIntegralsKE() [1/3]

std::pair<double,double> SimTK::approxCompleteEllipticIntegralsKE ( double  m )

inline

Given 0<=m<=1, return complete elliptic integrals of the first and second kinds, K(m) and E(m), approximated but with a maximum error of 2e-8 so at least 7 digits are correct (same in float or double precision). See Elliptic integrals for a discussion.

Note that a full-precision computation of these integrals is also available; see completeEllipticIntegralsKE(). However, if you are using float precision there is no point in using the exact computation since this approximation is just as good and much faster.

Parameters

[in]

m

The argument to the elliptic integrals. Must be in range [0,1] although we allow for a very small amount of numerical error (see SignificantReal) that might put m outside that range.

Returns

A std::pair p from which K(m)=p.first and E(m)=p.second.

You can find the approximating formula we're using in ref. 2, sections 17.3.34 and 17.3.36, pp. 591-2, or you can look at the code for this function (in the header file). The formulas are accurate to 2e-8 over the full [0-1] argument range, according to the authors. I checked our implementation against Matlab's ellipke() function and the results are very good, providing at least 7 correct digits for a range of sample values.

The cost is about 90 flops.

See also

completeEllipticIntegralsKE()

Elliptic integrals

References

(1) Antoine, Visa, Sauvey, Abba. "Approximate analytical model for Hertzian Elliptical Contact Problems", ASME J. Tribology 128:660, 2006.

(2) Abramovitz, Stegun, eds. Handbook of Mathematical Functions with Formulas, Graphs, and Mathematical Tables, Dover, NY, 1972.

approxCompleteEllipticIntegralsKE() [2/3]

std::pair<float,float> SimTK::approxCompleteEllipticIntegralsKE ( float  m )

inline

This is the single precision (float) version of the approximate calculation of elliptic integrals, still yielding about 7 digits of accuracy even though all calculations are done in float precision.

See also

approxCompleteEllipticIntegralsKE(double)

Elliptic integrals

approxCompleteEllipticIntegralsKE() [3/3]

std::pair<double,double> SimTK::approxCompleteEllipticIntegralsKE ( int  m )

inline

This integer overload is present to prevent ambiguity; it converts its argument to double precision and then calls approxCompleteEllipticIntegralsKE(double).

Note that the only legal values here are 0 and 1.

See also

approxCompleteEllipticIntegralsKE(double)

Elliptic integrals

completeEllipticIntegralsKE() [1/3]

std::pair<double,double> SimTK::completeEllipticIntegralsKE ( double  m )

inline

Given 0<=m<=1, return complete elliptic integrals of the first and second kinds, K(m) and E(m), calculated to (roughly) machine precision (float or double). See Elliptic integrals for a discussion.

Note that we also provide a faster approximate method for calculating these functions (see approxCompleteEllipticIntegralsKE()). The approximate method is good enough for many scientific and engineering applications and is always preferred if you are using float precision.

Parameters

[in]

m

The argument to the elliptic integrals. Must be in range [0,1] although we allow for a very small amount of numerical error (see SignificantReal) that might put m outside that range.

Returns

A std::pair p from which K(m)=p.first and E(m)=p.second.

Cost here is about 50 + 50*n flops, where n is the number of iterations required. The number of iterations n you can expect to get a double-precision result is 4 for a:b < 2, 5 for a:b < 20, 6 for a:b < 1000, 7 after that; for single-precision it will take one fewer iterations. In flops that's 250, 300, 350, 400 – 300 will be typical for double, 250 for float.

See also

approxCompleteEllipticIntegralsKE()

Elliptic integrals

completeEllipticIntegralsKE() [2/3]

std::pair<float,float> SimTK::completeEllipticIntegralsKE ( float  m )

inline

This is the single precision (float) version of the machine-precision calculation of elliptic integrals, providing accuracy to float precision (about 7 digits) which is no better than you'll get with the much faster approximate version, so use that instead!

See also

approxCompleteEllipticIntegralsKE()

completeEllipticIntegralsKE(double)

Elliptic integrals

completeEllipticIntegralsKE() [3/3]

std::pair<double,double> SimTK::completeEllipticIntegralsKE ( int  m )

inline

This integer overload is present to prevent ambiguity; it converts its argument to double precision and then calls completeEllipticIntegralsKE(double).

Note that the only legal values here are 0 and 1.

See also

completeEllipticIntegralsKE(double)

Elliptic integrals

SimTK_DEFINE_UNIQUE_INDEX_TYPE() [36/63]

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

EventId

)

SimTK_DEFINE_UNIQUE_INDEX_TYPE() [37/63]

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

SystemEventTriggerIndex

)

SimTK_DEFINE_UNIQUE_INDEX_TYPE() [38/63]

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

SystemEventTriggerByStageIndex

)

SimTK_DEFINE_UNIQUE_INDEX_TYPE() [39/63]

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

EventTriggerByStageIndex

)

SimTK_DEFINE_UNIQUE_INDEX_TYPE() [40/63]

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

MeasureIndex

)

Define a unique integral type for safe indexing of Measures.

operator<<() [12/18]

std::ostream& SimTK::operator<< ( std::ostream &  o, Stage  g  )

inline

SimTK_DEFINE_UNIQUE_INDEX_TYPE() [41/63]

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

SubsystemIndex

)

SimTK_DEFINE_UNIQUE_INDEX_TYPE() [42/63]

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

SystemYIndex

)

SimTK_DEFINE_UNIQUE_INDEX_TYPE() [43/63]

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

SystemQIndex

)

SimTK_DEFINE_UNIQUE_INDEX_TYPE() [44/63]

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

QIndex

)

SimTK_DEFINE_UNIQUE_INDEX_TYPE() [45/63]

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

SystemUIndex

)

SimTK_DEFINE_UNIQUE_INDEX_TYPE() [46/63]

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

UIndex

)

SimTK_DEFINE_UNIQUE_INDEX_TYPE() [47/63]

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

SystemZIndex

)

SimTK_DEFINE_UNIQUE_INDEX_TYPE() [48/63]

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

ZIndex

)

SimTK_DEFINE_UNIQUE_INDEX_TYPE() [49/63]

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

DiscreteVariableIndex

)

SimTK_DEFINE_UNIQUE_INDEX_TYPE() [50/63]

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

CacheEntryIndex

)

SimTK_DEFINE_UNIQUE_INDEX_TYPE() [51/63]

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

SystemYErrIndex

)

SimTK_DEFINE_UNIQUE_INDEX_TYPE() [52/63]

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

SystemQErrIndex

)

SimTK_DEFINE_UNIQUE_INDEX_TYPE() [53/63]

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

QErrIndex

)

SimTK_DEFINE_UNIQUE_INDEX_TYPE() [54/63]

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

SystemUErrIndex

)

SimTK_DEFINE_UNIQUE_INDEX_TYPE() [55/63]

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

UErrIndex

)

SimTK_DEFINE_UNIQUE_INDEX_TYPE() [56/63]

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

SystemUDotErrIndex

)

SimTK_DEFINE_UNIQUE_INDEX_TYPE() [57/63]

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

UDotErrIndex

)

SimTK_DEFINE_UNIQUE_INDEX_TYPE() [58/63]

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

SystemMultiplierIndex

)

SimTK_DEFINE_UNIQUE_INDEX_TYPE() [59/63]

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

MultiplierIndex

)

operator<<() [13/18]

std::ostream& SimTK::operator<<	(	std::ostream &	o,
		const State &	s
	)

operator+() [28/79]

template<int M, int N, class EL , int CSL, int RSL, class ER , int CSR, int RSR>

Mat<M,N,EL,CSL,RSL>::template Result<Mat<M,N,ER,CSR,RSR> >::Add SimTK::operator+ ( const Mat< M, N, EL, CSL, RSL > &  l, const Mat< M, N, ER, CSR, RSR > &  r  )

inline

operator-() [28/79]

template<int M, int N, class EL , int CSL, int RSL, class ER , int CSR, int RSR>

Mat<M,N,EL,CSL,RSL>::template Result<Mat<M,N,ER,CSR,RSR> >::Sub SimTK::operator- ( const Mat< M, N, EL, CSL, RSL > &  l, const Mat< M, N, ER, CSR, RSR > &  r  )

inline

operator*() [87/161]

template<int M, int N, class EL , int CSL, int RSL, int P, class ER , int CSR, int RSR>

Mat<M,N,EL,CSL,RSL>::template Result<Mat<N,P,ER,CSR,RSR> >::Mul SimTK::operator* ( const Mat< M, N, EL, CSL, RSL > &  l, const Mat< N, P, ER, CSR, RSR > &  r  )

inline

operator*() [88/161]

template<int M, int N, class EL , int CSL, int RSL, int MM, int NN, class ER , int CSR, int RSR>

Mat<M,N,EL,CSL,RSL>::template Result<Mat<MM,NN,ER,CSR,RSR> >::MulNon SimTK::operator* ( const Mat< M, N, EL, CSL, RSL > &  l, const Mat< MM, NN, ER, CSR, RSR > &  r  )

inline

operator==() [16/22]

template<int M, int N, class EL , int CSL, int RSL, class ER , int CSR, int RSR>

bool SimTK::operator== ( const Mat< M, N, EL, CSL, RSL > &  l, const Mat< M, N, ER, CSR, RSR > &  r  )

inline

operator!=() [12/18]

template<int M, int N, class EL , int CSL, int RSL, class ER , int CSR, int RSR>

bool SimTK::operator!= ( const Mat< M, N, EL, CSL, RSL > &  l, const Mat< M, N, ER, CSR, RSR > &  r  )

inline

operator*() [89/161]

template<int M, int N, class E , int CS, int RS>

Mat<M,N,E,CS,RS>::template Result<float>::Mul SimTK::operator* ( const Mat< M, N, E, CS, RS > &  l, const float &  r  )

inline

operator*() [90/161]

template<int M, int N, class E , int CS, int RS>

Mat<M,N,E,CS,RS>::template Result<float>::Mul SimTK::operator* ( const float &  l, const Mat< M, N, E, CS, RS > &  r  )

inline

operator*() [91/161]

template<int M, int N, class E , int CS, int RS>

Mat<M,N,E,CS,RS>::template Result<double>::Mul SimTK::operator* ( const Mat< M, N, E, CS, RS > &  l, const double &  r  )

inline

operator*() [92/161]

template<int M, int N, class E , int CS, int RS>

Mat<M,N,E,CS,RS>::template Result<double>::Mul SimTK::operator* ( const double &  l, const Mat< M, N, E, CS, RS > &  r  )

inline

operator*() [93/161]

template<int M, int N, class E , int CS, int RS>

Mat<M,N,E,CS,RS>::template Result<typename CNT<E>::Precision>::Mul SimTK::operator* ( const Mat< M, N, E, CS, RS > &  l, int  r  )

inline

operator*() [94/161]

template<int M, int N, class E , int CS, int RS>

Mat<M,N,E,CS,RS>::template Result<typename CNT<E>::Precision>::Mul SimTK::operator* ( int  l, const Mat< M, N, E, CS, RS > &  r  )

inline

operator*() [95/161]

template<int M, int N, class E , int CS, int RS, class R >

Mat<M,N,E,CS,RS>::template Result<std::complex<R> >::Mul SimTK::operator* ( const Mat< M, N, E, CS, RS > &  l, const std::complex< R > &  r  )

inline

operator*() [96/161]

template<int M, int N, class E , int CS, int RS, class R >

Mat<M,N,E,CS,RS>::template Result<std::complex<R> >::Mul SimTK::operator* ( const std::complex< R > &  l, const Mat< M, N, E, CS, RS > &  r  )

inline

operator*() [97/161]

template<int M, int N, class E , int CS, int RS, class R >

Mat<M,N,E,CS,RS>::template Result<std::complex<R> >::Mul SimTK::operator* ( const Mat< M, N, E, CS, RS > &  l, const conjugate< R > &  r  )

inline

operator*() [98/161]

template<int M, int N, class E , int CS, int RS, class R >

Mat<M,N,E,CS,RS>::template Result<std::complex<R> >::Mul SimTK::operator* ( const conjugate< R > &  l, const Mat< M, N, E, CS, RS > &  r  )

inline

operator*() [99/161]

template<int M, int N, class E , int CS, int RS, class R >

Mat<M,N,E,CS,RS>::template Result<typename negator<R>::StdNumber>::Mul SimTK::operator* ( const Mat< M, N, E, CS, RS > &  l, const negator< R > &  r  )

inline

operator*() [100/161]

template<int M, int N, class E , int CS, int RS, class R >

Mat<M,N,E,CS,RS>::template Result<typename negator<R>::StdNumber>::Mul SimTK::operator* ( const negator< R > &  l, const Mat< M, N, E, CS, RS > &  r  )

inline

operator/() [29/76]

template<int M, int N, class E , int CS, int RS>

Mat<M,N,E,CS,RS>::template Result<float>::Dvd SimTK::operator/ ( const Mat< M, N, E, CS, RS > &  l, const float &  r  )

inline

operator/() [30/76]

template<int M, int N, class E , int CS, int RS>

CNT<float>::template Result<Mat<M,N,E,CS,RS> >::Dvd SimTK::operator/ ( const float &  l, const Mat< M, N, E, CS, RS > &  r  )

inline

operator/() [31/76]

template<int M, int N, class E , int CS, int RS>

Mat<M,N,E,CS,RS>::template Result<double>::Dvd SimTK::operator/ ( const Mat< M, N, E, CS, RS > &  l, const double &  r  )

inline

operator/() [32/76]

template<int M, int N, class E , int CS, int RS>

CNT<double>::template Result<Mat<M,N,E,CS,RS> >::Dvd SimTK::operator/ ( const double &  l, const Mat< M, N, E, CS, RS > &  r  )

inline

operator/() [33/76]

template<int M, int N, class E , int CS, int RS>

Mat<M,N,E,CS,RS>::template Result<typename CNT<E>::Precision>::Dvd SimTK::operator/ ( const Mat< M, N, E, CS, RS > &  l, int  r  )

inline

operator/() [34/76]

template<int M, int N, class E , int CS, int RS>

CNT<typename CNT<E>::Precision>::template Result<Mat<M,N,E,CS,RS> >::Dvd SimTK::operator/ ( int  l, const Mat< M, N, E, CS, RS > &  r  )

inline

operator/() [35/76]

template<int M, int N, class E , int CS, int RS, class R >

Mat<M,N,E,CS,RS>::template Result<std::complex<R> >::Dvd SimTK::operator/ ( const Mat< M, N, E, CS, RS > &  l, const std::complex< R > &  r  )

inline

operator/() [36/76]

template<int M, int N, class E , int CS, int RS, class R >

CNT<std::complex<R> >::template Result<Mat<M,N,E,CS,RS> >::Dvd SimTK::operator/ ( const std::complex< R > &  l, const Mat< M, N, E, CS, RS > &  r  )

inline

operator/() [37/76]

template<int M, int N, class E , int CS, int RS, class R >

Mat<M,N,E,CS,RS>::template Result<std::complex<R> >::Dvd SimTK::operator/ ( const Mat< M, N, E, CS, RS > &  l, const conjugate< R > &  r  )

inline

operator/() [38/76]

template<int M, int N, class E , int CS, int RS, class R >

CNT<std::complex<R> >::template Result<Mat<M,N,E,CS,RS> >::Dvd SimTK::operator/ ( const conjugate< R > &  l, const Mat< M, N, E, CS, RS > &  r  )

inline

operator/() [39/76]

template<int M, int N, class E , int CS, int RS, class R >

Mat<M,N,E,CS,RS>::template Result<typename negator<R>::StdNumber>::Dvd SimTK::operator/ ( const Mat< M, N, E, CS, RS > &  l, const negator< R > &  r  )

inline

operator/() [40/76]

template<int M, int N, class E , int CS, int RS, class R >

CNT<R>::template Result<Mat<M,N,E,CS,RS> >::Dvd SimTK::operator/ ( const negator< R > &  l, const Mat< M, N, E, CS, RS > &  r  )

inline

operator+() [29/79]

template<int M, int N, class E , int CS, int RS>

Mat<M,N,E,CS,RS>::template Result<float>::Add SimTK::operator+ ( const Mat< M, N, E, CS, RS > &  l, const float &  r  )

inline

operator+() [30/79]

template<int M, int N, class E , int CS, int RS>

Mat<M,N,E,CS,RS>::template Result<float>::Add SimTK::operator+ ( const float &  l, const Mat< M, N, E, CS, RS > &  r  )

inline

operator+() [31/79]

template<int M, int N, class E , int CS, int RS>

Mat<M,N,E,CS,RS>::template Result<double>::Add SimTK::operator+ ( const Mat< M, N, E, CS, RS > &  l, const double &  r  )

inline

operator+() [32/79]

template<int M, int N, class E , int CS, int RS>

Mat<M,N,E,CS,RS>::template Result<double>::Add SimTK::operator+ ( const double &  l, const Mat< M, N, E, CS, RS > &  r  )

inline

operator+() [33/79]

template<int M, int N, class E , int CS, int RS>

Mat<M,N,E,CS,RS>::template Result<typename CNT<E>::Precision>::Add SimTK::operator+ ( const Mat< M, N, E, CS, RS > &  l, int  r  )

inline

operator+() [34/79]

template<int M, int N, class E , int CS, int RS>

Mat<M,N,E,CS,RS>::template Result<typename CNT<E>::Precision>::Add SimTK::operator+ ( int  l, const Mat< M, N, E, CS, RS > &  r  )

inline

operator+() [35/79]

template<int M, int N, class E , int CS, int RS, class R >

Mat<M,N,E,CS,RS>::template Result<std::complex<R> >::Add SimTK::operator+ ( const Mat< M, N, E, CS, RS > &  l, const std::complex< R > &  r  )

inline

operator+() [36/79]

template<int M, int N, class E , int CS, int RS, class R >

Mat<M,N,E,CS,RS>::template Result<std::complex<R> >::Add SimTK::operator+ ( const std::complex< R > &  l, const Mat< M, N, E, CS, RS > &  r  )

inline

operator+() [37/79]

template<int M, int N, class E , int CS, int RS, class R >

Mat<M,N,E,CS,RS>::template Result<std::complex<R> >::Add SimTK::operator+ ( const Mat< M, N, E, CS, RS > &  l, const conjugate< R > &  r  )

inline

operator+() [38/79]

template<int M, int N, class E , int CS, int RS, class R >

Mat<M,N,E,CS,RS>::template Result<std::complex<R> >::Add SimTK::operator+ ( const conjugate< R > &  l, const Mat< M, N, E, CS, RS > &  r  )

inline

operator+() [39/79]

template<int M, int N, class E , int CS, int RS, class R >

Mat<M,N,E,CS,RS>::template Result<typename negator<R>::StdNumber>::Add SimTK::operator+ ( const Mat< M, N, E, CS, RS > &  l, const negator< R > &  r  )

inline

operator+() [40/79]

template<int M, int N, class E , int CS, int RS, class R >

Mat<M,N,E,CS,RS>::template Result<typename negator<R>::StdNumber>::Add SimTK::operator+ ( const negator< R > &  l, const Mat< M, N, E, CS, RS > &  r  )

inline

operator-() [29/79]

template<int M, int N, class E , int CS, int RS>

Mat<M,N,E,CS,RS>::template Result<float>::Sub SimTK::operator- ( const Mat< M, N, E, CS, RS > &  l, const float &  r  )

inline

operator-() [30/79]

template<int M, int N, class E , int CS, int RS>

CNT<float>::template Result<Mat<M,N,E,CS,RS> >::Sub SimTK::operator- ( const float &  l, const Mat< M, N, E, CS, RS > &  r  )

inline

operator-() [31/79]

template<int M, int N, class E , int CS, int RS>

Mat<M,N,E,CS,RS>::template Result<double>::Sub SimTK::operator- ( const Mat< M, N, E, CS, RS > &  l, const double &  r  )

inline

operator-() [32/79]

template<int M, int N, class E , int CS, int RS>

CNT<double>::template Result<Mat<M,N,E,CS,RS> >::Sub SimTK::operator- ( const double &  l, const Mat< M, N, E, CS, RS > &  r  )

inline

operator-() [33/79]

template<int M, int N, class E , int CS, int RS>

Mat<M,N,E,CS,RS>::template Result<typename CNT<E>::Precision>::Sub SimTK::operator- ( const Mat< M, N, E, CS, RS > &  l, int  r  )

inline

operator-() [34/79]

template<int M, int N, class E , int CS, int RS>

CNT<typename CNT<E>::Precision>::template Result<Mat<M,N,E,CS,RS> >::Sub SimTK::operator- ( int  l, const Mat< M, N, E, CS, RS > &  r  )

inline

operator-() [35/79]

template<int M, int N, class E , int CS, int RS, class R >

Mat<M,N,E,CS,RS>::template Result<std::complex<R> >::Sub SimTK::operator- ( const Mat< M, N, E, CS, RS > &  l, const std::complex< R > &  r  )

inline

operator-() [36/79]

template<int M, int N, class E , int CS, int RS, class R >

CNT<std::complex<R> >::template Result<Mat<M,N,E,CS,RS> >::Sub SimTK::operator- ( const std::complex< R > &  l, const Mat< M, N, E, CS, RS > &  r  )

inline

operator-() [37/79]

template<int M, int N, class E , int CS, int RS, class R >

Mat<M,N,E,CS,RS>::template Result<std::complex<R> >::Sub SimTK::operator- ( const Mat< M, N, E, CS, RS > &  l, const conjugate< R > &  r  )

inline

operator-() [38/79]

template<int M, int N, class E , int CS, int RS, class R >

CNT<std::complex<R> >::template Result<Mat<M,N,E,CS,RS> >::Sub SimTK::operator- ( const conjugate< R > &  l, const Mat< M, N, E, CS, RS > &  r  )

inline

operator-() [39/79]

template<int M, int N, class E , int CS, int RS, class R >

Mat<M,N,E,CS,RS>::template Result<typename negator<R>::StdNumber>::Sub SimTK::operator- ( const Mat< M, N, E, CS, RS > &  l, const negator< R > &  r  )

inline

operator-() [40/79]

template<int M, int N, class E , int CS, int RS, class R >

CNT<R>::template Result<Mat<M,N,E,CS,RS> >::Sub SimTK::operator- ( const negator< R > &  l, const Mat< M, N, E, CS, RS > &  r  )

inline

operator<<() [14/18]

template<int M, int N, class E , int CS, int RS, class CHAR , class TRAITS >

std::basic_ostream<CHAR,TRAITS>& SimTK::operator<< ( std::basic_ostream< CHAR, TRAITS > &  o, const Mat< M, N, E, CS, RS > &  m  )

inline

operator>>() [3/6]

template<int M, int N, class E , int CS, int RS, class CHAR , class TRAITS >

std::basic_istream<CHAR,TRAITS>& SimTK::operator>> ( std::basic_istream< CHAR, TRAITS > &  is, Mat< M, N, E, CS, RS > &  m  )

inline

operator+() [41/79]

template<int N, class E1 , int S1, class E2 , int S2>

Row<N,E1,S1>::template Result< Row<N,E2,S2> >::Add SimTK::operator+ ( const Row< N, E1, S1 > &  l, const Row< N, E2, S2 > &  r  )

inline

operator-() [41/79]

template<int N, class E1 , int S1, class E2 , int S2>

Row<N,E1,S1>::template Result< Row<N,E2,S2> >::Sub SimTK::operator- ( const Row< N, E1, S1 > &  l, const Row< N, E2, S2 > &  r  )

inline

operator==() [17/22]

template<int N, class E1 , int S1, class E2 , int S2>

bool SimTK::operator== ( const Row< N, E1, S1 > &  l, const Row< N, E2, S2 > &  r  )

inline

bool = v1[i] == v2[i], for all elements i

operator!=() [13/18]

template<int N, class E1 , int S1, class E2 , int S2>

bool SimTK::operator!= ( const Row< N, E1, S1 > &  l, const Row< N, E2, S2 > &  r  )

inline

bool = v1[i] != v2[i], for any element i

operator<() [1/4]

template<int N, class E1 , int S1, class E2 , int S2>

bool SimTK::operator< ( const Row< N, E1, S1 > &  l, const Row< N, E2, S2 > &  r  )

inline

bool = v1[i] < v2[i], for all elements i

operator<() [2/4]

template<int N, class E1 , int S1, class E2 >

bool SimTK::operator< ( const Row< N, E1, S1 > &  v, const E2 &  e  )

inline

bool = v[i] < e, for all elements v[i] and element e

operator>() [2/5]

template<int N, class E1 , int S1, class E2 , int S2>

bool SimTK::operator> ( const Row< N, E1, S1 > &  l, const Row< N, E2, S2 > &  r  )

inline

bool = v1[i] > v2[i], for all elements i

operator>() [3/5]

template<int N, class E1 , int S1, class E2 >

bool SimTK::operator> ( const Row< N, E1, S1 > &  v, const E2 &  e  )

inline

bool = v[i] > e, for all elements v[i] and element e

operator<=() [2/5]

template<int N, class E1 , int S1, class E2 , int S2>

bool SimTK::operator<= ( const Row< N, E1, S1 > &  l, const Row< N, E2, S2 > &  r  )

inline

bool = v1[i] <= v2[i], for all elements i.

This is not the same as !(v1>v2).

operator<=() [3/5]

template<int N, class E1 , int S1, class E2 >

bool SimTK::operator<= ( const Row< N, E1, S1 > &  v, const E2 &  e  )

inline

bool = v[i] <= e, for all elements v[i] and element e.

This is not the same as !(v1>e).

operator>=() [2/5]

template<int N, class E1 , int S1, class E2 , int S2>

bool SimTK::operator>= ( const Row< N, E1, S1 > &  l, const Row< N, E2, S2 > &  r  )

inline

bool = v1[i] >= v2[i], for all elements i This is not the same as !(v1<v2).

operator>=() [3/5]

template<int N, class E1 , int S1, class E2 >

bool SimTK::operator>= ( const Row< N, E1, S1 > &  v, const E2 &  e  )

inline

bool = v[i] >= e, for all elements v[i] and element e.

This is not the same as !(v1<e).

operator*() [101/161]

template<int N, class E , int S>

Row<N,E,S>::template Result<float>::Mul SimTK::operator* ( const Row< N, E, S > &  l, const float &  r  )

inline

operator*() [102/161]

template<int N, class E , int S>

Row<N,E,S>::template Result<float>::Mul SimTK::operator* ( const float &  l, const Row< N, E, S > &  r  )

inline

operator*() [103/161]

template<int N, class E , int S>

Row<N,E,S>::template Result<double>::Mul SimTK::operator* ( const Row< N, E, S > &  l, const double &  r  )

inline

operator*() [104/161]

template<int N, class E , int S>

Row<N,E,S>::template Result<double>::Mul SimTK::operator* ( const double &  l, const Row< N, E, S > &  r  )

inline

operator*() [105/161]

template<int N, class E , int S>

Row<N,E,S>::template Result<typename CNT<E>::Precision>::Mul SimTK::operator* ( const Row< N, E, S > &  l, int  r  )

inline

operator*() [106/161]

template<int N, class E , int S>

Row<N,E,S>::template Result<typename CNT<E>::Precision>::Mul SimTK::operator* ( int  l, const Row< N, E, S > &  r  )

inline

operator*() [107/161]

template<int N, class E , int S, class R >

Row<N,E,S>::template Result<std::complex<R> >::Mul SimTK::operator* ( const Row< N, E, S > &  l, const std::complex< R > &  r  )

inline

operator*() [108/161]

template<int N, class E , int S, class R >

Row<N,E,S>::template Result<std::complex<R> >::Mul SimTK::operator* ( const std::complex< R > &  l, const Row< N, E, S > &  r  )

inline

operator*() [109/161]

template<int N, class E , int S, class R >

Row<N,E,S>::template Result<std::complex<R> >::Mul SimTK::operator* ( const Row< N, E, S > &  l, const conjugate< R > &  r  )

inline

operator*() [110/161]

template<int N, class E , int S, class R >

Row<N,E,S>::template Result<std::complex<R> >::Mul SimTK::operator* ( const conjugate< R > &  l, const Row< N, E, S > &  r  )

inline

operator*() [111/161]

template<int N, class E , int S, class R >

Row<N,E,S>::template Result<typename negator<R>::StdNumber>::Mul SimTK::operator* ( const Row< N, E, S > &  l, const negator< R > &  r  )

inline

operator*() [112/161]

template<int N, class E , int S, class R >

Row<N,E,S>::template Result<typename negator<R>::StdNumber>::Mul SimTK::operator* ( const negator< R > &  l, const Row< N, E, S > &  r  )

inline

operator/() [41/76]

template<int N, class E , int S>

Row<N,E,S>::template Result<float>::Dvd SimTK::operator/ ( const Row< N, E, S > &  l, const float &  r  )

inline

operator/() [42/76]

template<int N, class E , int S>

CNT<float>::template Result<Row<N,E,S> >::Dvd SimTK::operator/ ( const float &  l, const Row< N, E, S > &  r  )

inline

operator/() [43/76]

template<int N, class E , int S>

Row<N,E,S>::template Result<double>::Dvd SimTK::operator/ ( const Row< N, E, S > &  l, const double &  r  )

inline

operator/() [44/76]

template<int N, class E , int S>

CNT<double>::template Result<Row<N,E,S> >::Dvd SimTK::operator/ ( const double &  l, const Row< N, E, S > &  r  )

inline

operator/() [45/76]

template<int N, class E , int S>

Row<N,E,S>::template Result<typename CNT<E>::Precision>::Dvd SimTK::operator/ ( const Row< N, E, S > &  l, int  r  )

inline

operator/() [46/76]

template<int N, class E , int S>

CNT<typename CNT<E>::Precision>::template Result<Row<N,E,S> >::Dvd SimTK::operator/ ( int  l, const Row< N, E, S > &  r  )

inline

operator/() [47/76]

template<int N, class E , int S, class R >

Row<N,E,S>::template Result<std::complex<R> >::Dvd SimTK::operator/ ( const Row< N, E, S > &  l, const std::complex< R > &  r  )

inline

operator/() [48/76]

template<int N, class E , int S, class R >

CNT<std::complex<R> >::template Result<Row<N,E,S> >::Dvd SimTK::operator/ ( const std::complex< R > &  l, const Row< N, E, S > &  r  )

inline

operator/() [49/76]

template<int N, class E , int S, class R >

Row<N,E,S>::template Result<std::complex<R> >::Dvd SimTK::operator/ ( const Row< N, E, S > &  l, const conjugate< R > &  r  )

inline

operator/() [50/76]

template<int N, class E , int S, class R >

CNT<std::complex<R> >::template Result<Row<N,E,S> >::Dvd SimTK::operator/ ( const conjugate< R > &  l, const Row< N, E, S > &  r  )

inline

operator/() [51/76]

template<int N, class E , int S, class R >

Row<N,E,S>::template Result<typename negator<R>::StdNumber>::Dvd SimTK::operator/ ( const Row< N, E, S > &  l, const negator< R > &  r  )

inline

operator/() [52/76]

template<int N, class E , int S, class R >

CNT<R>::template Result<Row<N,E,S> >::Dvd SimTK::operator/ ( const negator< R > &  l, const Row< N, E, S > &  r  )

inline

operator+() [42/79]

template<int N, class E , int S>

Row<N,E,S>::template Result<float>::Add SimTK::operator+ ( const Row< N, E, S > &  l, const float &  r  )

inline

operator+() [43/79]

template<int N, class E , int S>

Row<N,E,S>::template Result<float>::Add SimTK::operator+ ( const float &  l, const Row< N, E, S > &  r  )

inline

operator+() [44/79]

template<int N, class E , int S>

Row<N,E,S>::template Result<double>::Add SimTK::operator+ ( const Row< N, E, S > &  l, const double &  r  )

inline

operator+() [45/79]

template<int N, class E , int S>

Row<N,E,S>::template Result<double>::Add SimTK::operator+ ( const double &  l, const Row< N, E, S > &  r  )

inline

operator+() [46/79]

template<int N, class E , int S>

Row<N,E,S>::template Result<typename CNT<E>::Precision>::Add SimTK::operator+ ( const Row< N, E, S > &  l, int  r  )

inline

operator+() [47/79]

template<int N, class E , int S>

Row<N,E,S>::template Result<typename CNT<E>::Precision>::Add SimTK::operator+ ( int  l, const Row< N, E, S > &  r  )

inline

operator+() [48/79]

template<int N, class E , int S, class R >

Row<N,E,S>::template Result<std::complex<R> >::Add SimTK::operator+ ( const Row< N, E, S > &  l, const std::complex< R > &  r  )

inline

operator+() [49/79]

template<int N, class E , int S, class R >

Row<N,E,S>::template Result<std::complex<R> >::Add SimTK::operator+ ( const std::complex< R > &  l, const Row< N, E, S > &  r  )

inline

operator+() [50/79]

template<int N, class E , int S, class R >

Row<N,E,S>::template Result<std::complex<R> >::Add SimTK::operator+ ( const Row< N, E, S > &  l, const conjugate< R > &  r  )

inline

operator+() [51/79]

template<int N, class E , int S, class R >

Row<N,E,S>::template Result<std::complex<R> >::Add SimTK::operator+ ( const conjugate< R > &  l, const Row< N, E, S > &  r  )

inline

operator+() [52/79]

template<int N, class E , int S, class R >

Row<N,E,S>::template Result<typename negator<R>::StdNumber>::Add SimTK::operator+ ( const Row< N, E, S > &  l, const negator< R > &  r  )

inline

operator+() [53/79]

template<int N, class E , int S, class R >

Row<N,E,S>::template Result<typename negator<R>::StdNumber>::Add SimTK::operator+ ( const negator< R > &  l, const Row< N, E, S > &  r  )

inline

operator-() [42/79]

template<int N, class E , int S>

Row<N,E,S>::template Result<float>::Sub SimTK::operator- ( const Row< N, E, S > &  l, const float &  r  )

inline

operator-() [43/79]

template<int N, class E , int S>

CNT<float>::template Result<Row<N,E,S> >::Sub SimTK::operator- ( const float &  l, const Row< N, E, S > &  r  )

inline

operator-() [44/79]

template<int N, class E , int S>

Row<N,E,S>::template Result<double>::Sub SimTK::operator- ( const Row< N, E, S > &  l, const double &  r  )

inline

operator-() [45/79]

template<int N, class E , int S>

CNT<double>::template Result<Row<N,E,S> >::Sub SimTK::operator- ( const double &  l, const Row< N, E, S > &  r  )

inline

operator-() [46/79]

template<int N, class E , int S>

Row<N,E,S>::template Result<typename CNT<E>::Precision>::Sub SimTK::operator- ( const Row< N, E, S > &  l, int  r  )

inline

operator-() [47/79]

template<int N, class E , int S>

CNT<typename CNT<E>::Precision>::template Result<Row<N,E,S> >::Sub SimTK::operator- ( int  l, const Row< N, E, S > &  r  )

inline

operator-() [48/79]

template<int N, class E , int S, class R >

Row<N,E,S>::template Result<std::complex<R> >::Sub SimTK::operator- ( const Row< N, E, S > &  l, const std::complex< R > &  r  )

inline

operator-() [49/79]

template<int N, class E , int S, class R >

CNT<std::complex<R> >::template Result<Row<N,E,S> >::Sub SimTK::operator- ( const std::complex< R > &  l, const Row< N, E, S > &  r  )

inline

operator-() [50/79]

template<int N, class E , int S, class R >

Row<N,E,S>::template Result<std::complex<R> >::Sub SimTK::operator- ( const Row< N, E, S > &  l, const conjugate< R > &  r  )

inline

operator-() [51/79]

template<int N, class E , int S, class R >

CNT<std::complex<R> >::template Result<Row<N,E,S> >::Sub SimTK::operator- ( const conjugate< R > &  l, const Row< N, E, S > &  r  )

inline

operator-() [52/79]

template<int N, class E , int S, class R >

Row<N,E,S>::template Result<typename negator<R>::StdNumber>::Sub SimTK::operator- ( const Row< N, E, S > &  l, const negator< R > &  r  )

inline

operator-() [53/79]

template<int N, class E , int S, class R >

CNT<R>::template Result<Row<N,E,S> >::Sub SimTK::operator- ( const negator< R > &  l, const Row< N, E, S > &  r  )

inline

operator<<() [15/18]

template<int N, class E , int S, class CHAR , class TRAITS >

std::basic_ostream<CHAR,TRAITS>& SimTK::operator<< ( std::basic_ostream< CHAR, TRAITS > &  o, const Row< N, E, S > &  v  )

inline

operator>>() [4/6]

template<int N, class E , int S, class CHAR , class TRAITS >

std::basic_istream<CHAR,TRAITS>& SimTK::operator>> ( std::basic_istream< CHAR, TRAITS > &  is, Row< N, E, S > &  v  )

inline

Read a Row from a stream as M elements separated by white space or by commas, optionally enclosed in () or [] (but no leading "~").

operator==() [18/22]

template<int M, class EL , int CSL, int RSL, class ER , int RSR>

bool SimTK::operator== ( const Mat< M, M, EL, CSL, RSL > &  l, const SymMat< M, ER, RSR > &  r  )

inline

operator!=() [14/18]

template<int M, class EL , int CSL, int RSL, class ER , int RSR>

bool SimTK::operator!= ( const Mat< M, M, EL, CSL, RSL > &  l, const SymMat< M, ER, RSR > &  r  )

inline

operator==() [19/22]

template<int M, class EL , int RSL, class ER , int CSR, int RSR>

bool SimTK::operator== ( const SymMat< M, EL, RSL > &  l, const Mat< M, M, ER, CSR, RSR > &  r  )

inline

operator!=() [15/18]

template<int M, class EL , int RSL, class ER , int CSR, int RSR>

bool SimTK::operator!= ( const SymMat< M, EL, RSL > &  l, const Mat< M, M, ER, CSR, RSR > &  r  )

inline

dot() [1/5]

template<int M, class E1 , int S1, class E2 , int S2>

CNT<typename CNT<E1>::THerm>::template Result<E2>::Mul SimTK::dot ( const Vec< M, E1, S1 > &  r, const Vec< M, E2, S2 > &  v  )

inline

dot() [2/5]

template<class E1 , int S1, class E2 , int S2>

CNT<typename CNT<E1>::THerm>::template Result<E2>::Mul SimTK::dot ( const Vec< 1, E1, S1 > &  r, const Vec< 1, E2, S2 > &  v  )

inline

operator*() [113/161]

template<int N, class E1 , int S1, class E2 , int S2>

CNT<E1>::template Result<E2>::Mul SimTK::operator* ( const Row< N, E1, S1 > &  r, const Vec< N, E2, S2 > &  v  )

inline

operator*() [114/161]

template<class E1 , int S1, class E2 , int S2>

CNT<E1>::template Result<E2>::Mul SimTK::operator* ( const Row< 1, E1, S1 > &  r, const Vec< 1, E2, S2 > &  v  )

inline

dot() [3/5]

template<int N, class E1 , int S1, class E2 , int S2>

CNT<E1>::template Result<E2>::Mul SimTK::dot ( const Row< N, E1, S1 > &  r, const Vec< N, E2, S2 > &  v  )

inline

dot() [4/5]

template<int M, class E1 , int S1, class E2 , int S2>

CNT<E1>::template Result<E2>::Mul SimTK::dot ( const Vec< M, E1, S1 > &  v, const Row< M, E2, S2 > &  r  )

inline

dot() [5/5]

template<int N, class E1 , int S1, class E2 , int S2>

CNT<E1>::template Result<E2>::Mul SimTK::dot ( const Row< N, E1, S1 > &  r, const Row< N, E2, S2 > &  s  )

inline

outer() [1/4]

template<int M, class E1 , int S1, class E2 , int S2>

Mat<M,M, typename CNT<E1>::template Result<typename CNT<E2>::THerm>::Mul> SimTK::outer ( const Vec< M, E1, S1 > &  v, const Vec< M, E2, S2 > &  w  )

inline

operator*() [115/161]

template<int M, class E1 , int S1, class E2 , int S2>

Vec<M,E1,S1>::template Result<Row<M,E2,S2> >::Mul SimTK::operator* ( const Vec< M, E1, S1 > &  v, const Row< M, E2, S2 > &  r  )

inline

outer() [2/4]

template<int M, class E1 , int S1, class E2 , int S2>

Mat<M,M, typename CNT<E1>::template Result<E2>::Mul> SimTK::outer ( const Vec< M, E1, S1 > &  v, const Row< M, E2, S2 > &  r  )

inline

outer() [3/4]

template<int M, class E1 , int S1, class E2 , int S2>

Mat<M,M, typename CNT<E1>::template Result<E2>::Mul> SimTK::outer ( const Row< M, E1, S1 > &  r, const Vec< M, E2, S2 > &  v  )

inline

outer() [4/4]

template<int M, class E1 , int S1, class E2 , int S2>

Mat<M,M, typename CNT<E1>::template Result<E2>::Mul> SimTK::outer ( const Row< M, E1, S1 > &  r, const Row< M, E2, S2 > &  s  )

inline

operator*() [116/161]

template<int M, int N, class ME , int CS, int RS, class E , int S>

Mat<M,N,ME,CS,RS>::template Result<Vec<N,E,S> >::Mul SimTK::operator* ( const Mat< M, N, ME, CS, RS > &  m, const Vec< N, E, S > &  v  )

inline

operator*() [117/161]

template<int M, class E , int S, int N, class ME , int CS, int RS>

Row<M,E,S>::template Result<Mat<M,N,ME,CS,RS> >::Mul SimTK::operator* ( const Row< M, E, S > &  r, const Mat< M, N, ME, CS, RS > &  m  )

inline

operator*() [118/161]

template<int N, class ME , int RS, class E , int S>

SymMat<N,ME,RS>::template Result<Vec<N,E,S> >::Mul SimTK::operator* ( const SymMat< N, ME, RS > &  m, const Vec< N, E, S > &  v  )

inline

operator*() [119/161]

template<class ME , int RS, class E , int S>

SymMat<1,ME,RS>::template Result<Vec<1,E,S> >::Mul SimTK::operator* ( const SymMat< 1, ME, RS > &  m, const Vec< 1, E, S > &  v  )

inline

operator*() [120/161]

template<class ME , int RS, class E , int S>

SymMat<2,ME,RS>::template Result<Vec<2,E,S> >::Mul SimTK::operator* ( const SymMat< 2, ME, RS > &  m, const Vec< 2, E, S > &  v  )

inline

operator*() [121/161]

template<class ME , int RS, class E , int S>

SymMat<3,ME,RS>::template Result<Vec<3,E,S> >::Mul SimTK::operator* ( const SymMat< 3, ME, RS > &  m, const Vec< 3, E, S > &  v  )

inline

operator*() [122/161]

template<int M, class E , int S, class ME , int RS>

Row<M,E,S>::template Result<SymMat<M,ME,RS> >::Mul SimTK::operator* ( const Row< M, E, S > &  r, const SymMat< M, ME, RS > &  m  )

inline

operator*() [123/161]

template<class E , int S, class ME , int RS>

Row<1,E,S>::template Result<SymMat<1,ME,RS> >::Mul SimTK::operator* ( const Row< 1, E, S > &  r, const SymMat< 1, ME, RS > &  m  )

inline

operator*() [124/161]

template<class E , int S, class ME , int RS>

Row<2,E,S>::template Result<SymMat<2,ME,RS> >::Mul SimTK::operator* ( const Row< 2, E, S > &  r, const SymMat< 2, ME, RS > &  m  )

inline

operator*() [125/161]

template<class E , int S, class ME , int RS>

Row<3,E,S>::template Result<SymMat<3,ME,RS> >::Mul SimTK::operator* ( const Row< 3, E, S > &  r, const SymMat< 3, ME, RS > &  m  )

inline

operator*() [126/161]

template<int M, class E1 , int S1, int N, class E2 , int S2>

Vec<M,E1,S1>::template Result<Row<N,E2,S2> >::MulNon SimTK::operator* ( const Vec< M, E1, S1 > &  v, const Row< N, E2, S2 > &  r  )

inline

operator*() [127/161]

template<int M, class E1 , int S1, int MM, int NN, class E2 , int CS2, int RS2>

Vec<M,E1,S1>::template Result<Mat<MM,NN,E2,CS2,RS2> >::MulNon SimTK::operator* ( const Vec< M, E1, S1 > &  v, const Mat< MM, NN, E2, CS2, RS2 > &  m  )

inline

operator*() [128/161]

template<int M, class E1 , int S1, int MM, class E2 , int RS2>

Vec<M,E1,S1>::template Result<SymMat<MM,E2,RS2> >::MulNon SimTK::operator* ( const Vec< M, E1, S1 > &  v, const SymMat< MM, E2, RS2 > &  m  )

inline

operator*() [129/161]

template<int M, class E1 , int S1, int MM, class E2 , int S2>

Vec<M,E1,S1>::template Result<Vec<MM,E2,S2> >::MulNon SimTK::operator* ( const Vec< M, E1, S1 > &  v1, const Vec< MM, E2, S2 > &  v2  )

inline

operator*() [130/161]

template<int M, class E , int S, int MM, int NN, class ME , int CS, int RS>

Row<M,E,S>::template Result<Mat<MM,NN,ME,CS,RS> >::MulNon SimTK::operator* ( const Row< M, E, S > &  r, const Mat< MM, NN, ME, CS, RS > &  m  )

inline

operator*() [131/161]

template<int N, class E1 , int S1, int M, class E2 , int S2>

Row<N,E1,S1>::template Result<Vec<M,E2,S2> >::MulNon SimTK::operator* ( const Row< N, E1, S1 > &  r, const Vec< M, E2, S2 > &  v  )

inline

operator*() [132/161]

template<int N1, class E1 , int S1, int N2, class E2 , int S2>

Row<N1,E1,S1>::template Result<Row<N2,E2,S2> >::MulNon SimTK::operator* ( const Row< N1, E1, S1 > &  r1, const Row< N2, E2, S2 > &  r2  )

inline

operator*() [133/161]

template<int M, int N, class ME , int CS, int RS, int MM, class E , int S>

Mat<M,N,ME,CS,RS>::template Result<Vec<MM,E,S> >::MulNon SimTK::operator* ( const Mat< M, N, ME, CS, RS > &  m, const Vec< MM, E, S > &  v  )

inline

operator*() [134/161]

template<int M, int N, class ME , int CS, int RS, int NN, class E , int S>

Mat<M,N,ME,CS,RS>::template Result<Row<NN,E,S> >::MulNon SimTK::operator* ( const Mat< M, N, ME, CS, RS > &  m, const Row< NN, E, S > &  r  )

inline

operator*() [135/161]

template<int M, int N, class ME , int CS, int RS, int Dim, class E , int S>

Mat<M,N,ME,CS,RS>::template Result<SymMat<Dim,E,S> >::MulNon SimTK::operator* ( const Mat< M, N, ME, CS, RS > &  m, const SymMat< Dim, E, S > &  sy  )

inline

cross() [1/18]

template<class E1 , int S1, class E2 , int S2>

Vec<3,typename CNT<E1>::template Result<E2>::Mul> SimTK::cross ( const Vec< 3, E1, S1 > &  a, const Vec< 3, E2, S2 > &  b  )

inline

operator%() [1/18]

template<class E1 , int S1, class E2 , int S2>

Vec<3,typename CNT<E1>::template Result<E2>::Mul> SimTK::operator% ( const Vec< 3, E1, S1 > &  a, const Vec< 3, E2, S2 > &  b  )

inline

cross() [2/18]

template<class E1 , int S1, class E2 , int S2>

Row<3,typename CNT<E1>::template Result<E2>::Mul> SimTK::cross ( const Vec< 3, E1, S1 > &  a, const Row< 3, E2, S2 > &  b  )

inline

operator%() [2/18]

template<class E1 , int S1, class E2 , int S2>

Row<3,typename CNT<E1>::template Result<E2>::Mul> SimTK::operator% ( const Vec< 3, E1, S1 > &  a, const Row< 3, E2, S2 > &  b  )

inline

cross() [3/18]

template<class E1 , int S1, class E2 , int S2>

Row<3,typename CNT<E1>::template Result<E2>::Mul> SimTK::cross ( const Row< 3, E1, S1 > &  a, const Vec< 3, E2, S2 > &  b  )

inline

operator%() [3/18]

template<class E1 , int S1, class E2 , int S2>

Row<3,typename CNT<E1>::template Result<E2>::Mul> SimTK::operator% ( const Row< 3, E1, S1 > &  a, const Vec< 3, E2, S2 > &  b  )

inline

cross() [4/18]

template<class E1 , int S1, class E2 , int S2>

Row<3,typename CNT<E1>::template Result<E2>::Mul> SimTK::cross ( const Row< 3, E1, S1 > &  a, const Row< 3, E2, S2 > &  b  )

inline

operator%() [4/18]

template<class E1 , int S1, class E2 , int S2>

Row<3,typename CNT<E1>::template Result<E2>::Mul> SimTK::operator% ( const Row< 3, E1, S1 > &  a, const Row< 3, E2, S2 > &  b  )

inline

cross() [5/18]

template<class E1 , int S1, int N, class E2 , int CS, int RS>

Mat<3,N,typename CNT<E1>::template Result<E2>::Mul> SimTK::cross ( const Vec< 3, E1, S1 > &  v, const Mat< 3, N, E2, CS, RS > &  m  )

inline

operator%() [5/18]

template<class E1 , int S1, int N, class E2 , int CS, int RS>

Mat<3,N,typename CNT<E1>::template Result<E2>::Mul> SimTK::operator% ( const Vec< 3, E1, S1 > &  v, const Mat< 3, N, E2, CS, RS > &  m  )

inline

cross() [6/18]

template<class E1 , int S1, int N, class E2 , int S2, int S3>

Row< N,Vec<3,typename CNT<E1>::template Result<E2>::Mul> > SimTK::cross ( const Vec< 3, E1, S1 > &  v, const Row< N, Vec< 3, E2, S2 >, S3 > &  m  )

inline

cross() [7/18]

template<class E1 , int S1, class E2 , int S2, int S3>

Row< 3,Vec<3,typename CNT<E1>::template Result<E2>::Mul> > SimTK::cross ( const Vec< 3, E1, S1 > &  v, const Row< 3, Vec< 3, E2, S2 >, S3 > &  m  )

inline

operator%() [6/18]

template<class E1 , int S1, int N, class E2 , int S2, int S3>

Row< N,Vec<3,typename CNT<E1>::template Result<E2>::Mul> > SimTK::operator% ( const Vec< 3, E1, S1 > &  v, const Row< N, Vec< 3, E2, S2 >, S3 > &  m  )

inline

operator%() [7/18]

template<class E1 , int S1, class E2 , int S2, int S3>

Row< 3,Vec<3,typename CNT<E1>::template Result<E2>::Mul> > SimTK::operator% ( const Vec< 3, E1, S1 > &  v, const Row< 3, Vec< 3, E2, S2 >, S3 > &  m  )

inline

cross() [8/18]

template<class EV , int SV, class EM , int RS>

Mat<3,3,typename CNT<EV>::template Result<EM>::Mul> SimTK::cross ( const Vec< 3, EV, SV > &  v, const SymMat< 3, EM, RS > &  s  )

inline

operator%() [8/18]

template<class EV , int SV, class EM , int RS>

Mat<3,3,typename CNT<EV>::template Result<EM>::Mul> SimTK::operator% ( const Vec< 3, EV, SV > &  v, const SymMat< 3, EM, RS > &  s  )

inline

cross() [9/18]

template<class E1 , int S1, int N, class E2 , int CS, int RS>

Mat<3,N,typename CNT<E1>::template Result<E2>::Mul> SimTK::cross ( const Row< 3, E1, S1 > &  r, const Mat< 3, N, E2, CS, RS > &  m  )

inline

operator%() [9/18]

template<class E1 , int S1, int N, class E2 , int CS, int RS>

Mat<3,N,typename CNT<E1>::template Result<E2>::Mul> SimTK::operator% ( const Row< 3, E1, S1 > &  r, const Mat< 3, N, E2, CS, RS > &  m  )

inline

cross() [10/18]

template<class EV , int SV, class EM , int RS>

Mat<3,3,typename CNT<EV>::template Result<EM>::Mul> SimTK::cross ( const Row< 3, EV, SV > &  r, const SymMat< 3, EM, RS > &  s  )

inline

operator%() [10/18]

template<class EV , int SV, class EM , int RS>

Mat<3,3,typename CNT<EV>::template Result<EM>::Mul> SimTK::operator% ( const Row< 3, EV, SV > &  r, const SymMat< 3, EM, RS > &  s  )

inline

cross() [11/18]

template<int M, class EM , int CS, int RS, class EV , int S>

Mat<M,3,typename CNT<EM>::template Result<EV>::Mul> SimTK::cross ( const Mat< M, 3, EM, CS, RS > &  m, const Vec< 3, EV, S > &  v  )

inline

operator%() [11/18]

template<int M, class EM , int CS, int RS, class EV , int S>

Mat<M,3,typename CNT<EM>::template Result<EV>::Mul> SimTK::operator% ( const Mat< M, 3, EM, CS, RS > &  m, const Vec< 3, EV, S > &  v  )

inline

cross() [12/18]

template<class EM , int RS, class EV , int SV>

Mat<3,3,typename CNT<EM>::template Result<EV>::Mul> SimTK::cross ( const SymMat< 3, EM, RS > &  s, const Vec< 3, EV, SV > &  v  )

inline

operator%() [12/18]

template<class EM , int RS, class EV , int SV>

Mat<3,3,typename CNT<EM>::template Result<EV>::Mul> SimTK::operator% ( const SymMat< 3, EM, RS > &  s, const Vec< 3, EV, SV > &  v  )

inline

cross() [13/18]

template<int M, class EM , int CS, int RS, class ER , int S>

Mat<M,3,typename CNT<EM>::template Result<ER>::Mul> SimTK::cross ( const Mat< M, 3, EM, CS, RS > &  m, const Row< 3, ER, S > &  r  )

inline

operator%() [13/18]

template<int M, class EM , int CS, int RS, class ER , int S>

Mat<M,3,typename CNT<EM>::template Result<ER>::Mul> SimTK::operator% ( const Mat< M, 3, EM, CS, RS > &  m, const Row< 3, ER, S > &  r  )

inline

cross() [14/18]

template<class EM , int RS, class EV , int SV>

Mat<3,3,typename CNT<EM>::template Result<EV>::Mul> SimTK::cross ( const SymMat< 3, EM, RS > &  s, const Row< 3, EV, SV > &  r  )

inline

operator%() [14/18]

template<class EM , int RS, class EV , int SV>

Mat<3,3,typename CNT<EM>::template Result<EV>::Mul> SimTK::operator% ( const SymMat< 3, EM, RS > &  s, const Row< 3, EV, SV > &  r  )

inline

cross() [15/18]

template<class E1 , int S1, class E2 , int S2>

CNT<E1>::template Result<E2>::Mul SimTK::cross ( const Vec< 2, E1, S1 > &  a, const Vec< 2, E2, S2 > &  b  )

inline

operator%() [15/18]

template<class E1 , int S1, class E2 , int S2>

CNT<E1>::template Result<E2>::Mul SimTK::operator% ( const Vec< 2, E1, S1 > &  a, const Vec< 2, E2, S2 > &  b  )

inline

cross() [16/18]

template<class E1 , int S1, class E2 , int S2>

CNT<E1>::template Result<E2>::Mul SimTK::cross ( const Row< 2, E1, S1 > &  a, const Vec< 2, E2, S2 > &  b  )

inline

operator%() [16/18]

template<class E1 , int S1, class E2 , int S2>

CNT<E1>::template Result<E2>::Mul SimTK::operator% ( const Row< 2, E1, S1 > &  a, const Vec< 2, E2, S2 > &  b  )

inline

cross() [17/18]

template<class E1 , int S1, class E2 , int S2>

CNT<E1>::template Result<E2>::Mul SimTK::cross ( const Vec< 2, E1, S1 > &  a, const Row< 2, E2, S2 > &  b  )

inline

operator%() [17/18]

template<class E1 , int S1, class E2 , int S2>

CNT<E1>::template Result<E2>::Mul SimTK::operator% ( const Vec< 2, E1, S1 > &  a, const Row< 2, E2, S2 > &  b  )

inline

cross() [18/18]

template<class E1 , int S1, class E2 , int S2>

CNT<E1>::template Result<E2>::Mul SimTK::cross ( const Row< 2, E1, S1 > &  a, const Row< 2, E2, S2 > &  b  )

inline

operator%() [18/18]

template<class E1 , int S1, class E2 , int S2>

CNT<E1>::template Result<E2>::Mul SimTK::operator% ( const Row< 2, E1, S1 > &  a, const Row< 2, E2, S2 > &  b  )

inline

crossMat() [1/8]

template<class E , int S>

Mat<3,3,E> SimTK::crossMat ( const Vec< 3, E, S > &  v )

inline

Calculate matrix M(v) such that M(v)*w = v % w.

We produce the same M regardless of whether v is a column or row. Requires 3 flops to form.

crossMat() [2/8]

template<class E , int S>

Mat<3,3,E> SimTK::crossMat ( const Vec< 3, negator< E >, S > &  v )

inline

Specialize crossMat() for negated scalar types.

Returned matrix loses negator. Requires 3 flops to form.

crossMat() [3/8]

template<class E , int S>

Mat<3,3,E> SimTK::crossMat ( const Row< 3, E, S > &  r )

inline

Form cross product matrix from a Row vector; 3 flops.

crossMat() [4/8]

template<class E , int S>

Mat<3,3,E> SimTK::crossMat ( const Row< 3, negator< E >, S > &  r )

inline

Form cross product matrix from a Row vector whose elements are negated scalars; 3 flops.

crossMat() [5/8]

template<class E , int S>

Row<2,E> SimTK::crossMat ( const Vec< 2, E, S > &  v )

inline

Calculate 2D cross product matrix M(v) such that M(v)*w = v0*w1-v1*w0 = v % w (a scalar).

Whether v is a Vec<2> or Row<2> we create the same M, which will be a 2-element Row. Requires 1 flop to form.

crossMat() [6/8]

template<class E , int S>

Row<2,E> SimTK::crossMat ( const Vec< 2, negator< E >, S > &  v )

inline

Specialize 2D cross product matrix for negated scalar types; 1 flop.

crossMat() [7/8]

template<class E , int S>

Row<2,E> SimTK::crossMat ( const Row< 2, E, S > &  r )

inline

Form 2D cross product matrix from a Row<2>; 1 flop.

crossMat() [8/8]

template<class E , int S>

Row<2,E> SimTK::crossMat ( const Row< 2, negator< E >, S > &  r )

inline

Form 2D cross product matrix from a Row<2> with negated scalar elements; 1 flop.

crossMatSq() [1/4]

template<class E , int S>

SymMat<3,E> SimTK::crossMatSq ( const Vec< 3, E, S > &  v )

inline

Calculate matrix S(v) such that S(v)*w = -v % (v % w) = (v % w) % v.

S is a symmetric, 3x3 matrix with nonnegative diagonals that obey the triangle inequality. If M(v) = crossMat(v), then S(v) = square(M(v)) = ~M(v)*M(v) = -M(v)*M(v) since M is skew symmetric.

Also, S(v) = dot(v,v)*I - outer(v,v) = ~v*v*I - v*~v, where I is the identity matrix. This is the form necessary for shifting inertia matrices using the parallel axis theorem, something we do a lot of in multibody dynamics. Consequently we want to calculate S very efficiently, which we can do because it has the following very simple form. Assume v=[x y z]. Then

         y^2+z^2      T         T
 S(v) =    -xy     x^2+z^2      T
           -xz       -yz     x^2+y^2

where "T" indicates that the element is identical to the symmetric one. Note that S(-v)=S(v). This requires 11 flops to form. We produce the same S(v) regardless of whether v is a column or row. There is no 2D equivalent of this operator.

crossMatSq() [2/4]

template<class E , int S>

SymMat<3,E> SimTK::crossMatSq ( const Vec< 3, negator< E >, S > &  v )

inline

crossMatSq() [3/4]

template<class E , int S>

SymMat<3,E> SimTK::crossMatSq ( const Row< 3, E, S > &  r )

inline

crossMatSq() [4/4]

template<class E , int S>

SymMat<3,E> SimTK::crossMatSq ( const Row< 3, negator< E >, S > &  r )

inline

det() [1/8]

template<class E , int CS, int RS>

E SimTK::det ( const Mat< 1, 1, E, CS, RS > &  m )

inline

Special case Mat 1x1 determinant. No computation.

det() [2/8]

template<class E , int RS>

E SimTK::det ( const SymMat< 1, E, RS > &  s )

inline

Special case SymMat 1x1 determinant. No computation.

det() [3/8]

template<class E , int CS, int RS>

E SimTK::det ( const Mat< 2, 2, E, CS, RS > &  m )

inline

Special case Mat 2x2 determinant. 3 flops (if elements are Real).

det() [4/8]

template<class E , int RS>

E SimTK::det ( const SymMat< 2, E, RS > &  s )

inline

Special case 2x2 SymMat determinant. 3 flops (if elements are Real).

det() [5/8]

template<class E , int CS, int RS>

E SimTK::det ( const Mat< 3, 3, E, CS, RS > &  m )

inline

Special case Mat 3x3 determinant. 14 flops (if elements are Real).

det() [6/8]

template<class E , int RS>

E SimTK::det ( const SymMat< 3, E, RS > &  s )

inline

Special case SymMat 3x3 determinant. 14 flops (if elements are Real).

det() [7/8]

template<int M, class E , int CS, int RS>

E SimTK::det ( const Mat< M, M, E, CS, RS > &  m )

inline

Calculate the determinant of a square matrix larger than 3x3 by recursive template expansion.

The matrix elements must be multiplication compatible for this to compile successfully. All scalar element types are acceptable; some composite types will also work but the result is probably meaningless. The determinant suffers from increasingly bad scaling as the matrices get bigger; you should consider an alternative if possible (see Golub and van Loan, "Matrix Computations"). This uses M*det(M-1) + 4*M flops. For 4x4 that's 60 flops, for 5x5 it's 320, and it grows really fast from there! TODO: this is not the right way to calculate determinant – should calculate LU factorization at 2/3 n^3 flops, then determinant is product of LU's diagonals.

det() [8/8]

template<int M, class E , int RS>

E SimTK::det ( const SymMat< M, E, RS > &  s )

inline

Determinant of SymMat larger than 3x3.

TODO: This should be done instead with a symmetric factorization; the determinant will be calculable as a product of some diagonal in the factorization. For now we'll punt to the really bad Mat determinant above.

lapackInverse() [1/2]

template<class E , int CS, int RS>

Mat<1,1,E,CS,RS>::TInvert SimTK::lapackInverse ( const Mat< 1, 1, E, CS, RS > &  m )

inline

Specialized 1x1 lapackInverse(): costs one divide.

lapackInverse() [2/2]

template<int M, class E , int CS, int RS>

Mat<M,M,E,CS,RS>::TInvert SimTK::lapackInverse ( const Mat< M, M, E, CS, RS > &  m )

inline

General inverse of small, fixed-size, square (mXm), non-singular matrix with scalar elements: use Lapack's LU routine with pivoting.

This will only work if the element type E is a scalar type, although negator<> and conjugate<> are OK. This routine is not specialized for small matrix sizes other than 1x1, while the inverse() method is specialized for other small sizes for speed, possibly losing some numerical stability. The inverse() function ends up calling this one at sizes for which it has no specialization. Normally you should call inverse(), but you can call lapackInverse() explicitly if you want to ensure that the most stable algorithm is used.

See also

inverse()

inverse() [1/7]

template<class E , int CS, int RS>

Mat<1,1,E,CS,RS>::TInvert SimTK::inverse ( const Mat< 1, 1, E, CS, RS > &  m )

inline

Specialized 1x1 Mat inverse: costs one divide.

inverse() [2/7]

template<class E , int RS>

SymMat<1,E,RS>::TInvert SimTK::inverse ( const SymMat< 1, E, RS > &  s )

inline

Specialized 1x1 SymMat inverse: costs one divide.

inverse() [3/7]

template<class E , int CS, int RS>

Mat<2,2,E,CS,RS>::TInvert SimTK::inverse ( const Mat< 2, 2, E, CS, RS > &  m )

inline

Specialized 2x2 Mat inverse: costs one divide plus 9 flops.

inverse() [4/7]

template<class E , int RS>

SymMat<2,E,RS>::TInvert SimTK::inverse ( const SymMat< 2, E, RS > &  s )

inline

Specialized 2x2 SymMat inverse: costs one divide plus 7 flops.

inverse() [5/7]

template<class E , int CS, int RS>

Mat<3,3,E,CS,RS>::TInvert SimTK::inverse ( const Mat< 3, 3, E, CS, RS > &  m )

inline

Specialized 3x3 inverse: costs one divide plus 41 flops (for real-valued matrices).

No pivoting done here so this may be subject to numerical errors that Lapack would avoid. Call lapackInverse() instead if you're worried.

See also

lapackInverse()

inverse() [6/7]

template<class E , int RS>

SymMat<3,E,RS>::TInvert SimTK::inverse ( const SymMat< 3, E, RS > &  s )

inline

Specialized 3x3 inverse for symmetric or Hermitian: costs one divide plus 29 flops (for real-valued matrices).

No pivoting done here so this may be subject to numerical errors that Lapack would avoid. Call lapackSymInverse() instead if you're worried.

See also

lapackSymInverse()

inverse() [7/7]

template<int M, class E , int CS, int RS>

Mat<M,M,E,CS,RS>::TInvert SimTK::inverse ( const Mat< M, M, E, CS, RS > &  m )

inline

For any matrix larger than 3x3, we just punt to the Lapack implementation.

See also

lapackInverse()

operator+() [54/79]

template<int M, class E1 , int S1, class E2 , int S2>

SymMat<M,E1,S1>::template Result< SymMat<M,E2,S2> >::Add SimTK::operator+ ( const SymMat< M, E1, S1 > &  l, const SymMat< M, E2, S2 > &  r  )

inline

operator-() [54/79]

template<int M, class E1 , int S1, class E2 , int S2>

SymMat<M,E1,S1>::template Result< SymMat<M,E2,S2> >::Sub SimTK::operator- ( const SymMat< M, E1, S1 > &  l, const SymMat< M, E2, S2 > &  r  )

inline

operator*() [136/161]

template<int M, class E1 , int S1, class E2 , int S2>

SymMat<M,E1,S1>::template Result< SymMat<M,E2,S2> >::Mul SimTK::operator* ( const SymMat< M, E1, S1 > &  l, const SymMat< M, E2, S2 > &  r  )

inline

operator==() [20/22]

template<int M, class E1 , int S1, class E2 , int S2>

bool SimTK::operator== ( const SymMat< M, E1, S1 > &  l, const SymMat< M, E2, S2 > &  r  )

inline

operator!=() [16/18]

template<int M, class E1 , int S1, class E2 , int S2>

bool SimTK::operator!= ( const SymMat< M, E1, S1 > &  l, const SymMat< M, E2, S2 > &  r  )

inline

operator*() [137/161]

template<int M, class E , int S>

SymMat<M,E,S>::template Result<float>::Mul SimTK::operator* ( const SymMat< M, E, S > &  l, const float &  r  )

inline

operator*() [138/161]

template<int M, class E , int S>

SymMat<M,E,S>::template Result<float>::Mul SimTK::operator* ( const float &  l, const SymMat< M, E, S > &  r  )

inline

operator*() [139/161]

template<int M, class E , int S>

SymMat<M,E,S>::template Result<double>::Mul SimTK::operator* ( const SymMat< M, E, S > &  l, const double &  r  )

inline

operator*() [140/161]

template<int M, class E , int S>

SymMat<M,E,S>::template Result<double>::Mul SimTK::operator* ( const double &  l, const SymMat< M, E, S > &  r  )

inline

operator*() [141/161]

template<int M, class E , int S>

SymMat<M,E,S>::template Result<typename CNT<E>::Precision>::Mul SimTK::operator* ( const SymMat< M, E, S > &  l, int  r  )

inline

operator*() [142/161]

template<int M, class E , int S>

SymMat<M,E,S>::template Result<typename CNT<E>::Precision>::Mul SimTK::operator* ( int  l, const SymMat< M, E, S > &  r  )

inline

operator*() [143/161]

template<int M, class E , int S, class R >

SymMat<M,E,S>::template Result<std::complex<R> >::Mul SimTK::operator* ( const SymMat< M, E, S > &  l, const std::complex< R > &  r  )

inline

operator*() [144/161]

template<int M, class E , int S, class R >

SymMat<M,E,S>::template Result<std::complex<R> >::Mul SimTK::operator* ( const std::complex< R > &  l, const SymMat< M, E, S > &  r  )

inline

operator*() [145/161]

template<int M, class E , int S, class R >

SymMat<M,E,S>::template Result<std::complex<R> >::Mul SimTK::operator* ( const SymMat< M, E, S > &  l, const conjugate< R > &  r  )

inline

operator*() [146/161]

template<int M, class E , int S, class R >

SymMat<M,E,S>::template Result<std::complex<R> >::Mul SimTK::operator* ( const conjugate< R > &  l, const SymMat< M, E, S > &  r  )

inline

operator*() [147/161]

template<int M, class E , int S, class R >

SymMat<M,E,S>::template Result<typename negator<R>::StdNumber>::Mul SimTK::operator* ( const SymMat< M, E, S > &  l, const negator< R > &  r  )

inline

operator*() [148/161]

template<int M, class E , int S, class R >

SymMat<M,E,S>::template Result<typename negator<R>::StdNumber>::Mul SimTK::operator* ( const negator< R > &  l, const SymMat< M, E, S > &  r  )

inline

operator/() [53/76]

template<int M, class E , int S>

SymMat<M,E,S>::template Result<float>::Dvd SimTK::operator/ ( const SymMat< M, E, S > &  l, const float &  r  )

inline

operator/() [54/76]

template<int M, class E , int S>

CNT<float>::template Result<SymMat<M,E,S> >::Dvd SimTK::operator/ ( const float &  l, const SymMat< M, E, S > &  r  )

inline

operator/() [55/76]

template<int M, class E , int S>

SymMat<M,E,S>::template Result<double>::Dvd SimTK::operator/ ( const SymMat< M, E, S > &  l, const double &  r  )

inline

operator/() [56/76]

template<int M, class E , int S>

CNT<double>::template Result<SymMat<M,E,S> >::Dvd SimTK::operator/ ( const double &  l, const SymMat< M, E, S > &  r  )

inline

operator/() [57/76]

template<int M, class E , int S>

SymMat<M,E,S>::template Result<typename CNT<E>::Precision>::Dvd SimTK::operator/ ( const SymMat< M, E, S > &  l, int  r  )

inline

operator/() [58/76]

template<int M, class E , int S>

CNT<typename CNT<E>::Precision>::template Result<SymMat<M,E,S> >::Dvd SimTK::operator/ ( int  l, const SymMat< M, E, S > &  r  )

inline

operator/() [59/76]

template<int M, class E , int S, class R >

SymMat<M,E,S>::template Result<std::complex<R> >::Dvd SimTK::operator/ ( const SymMat< M, E, S > &  l, const std::complex< R > &  r  )

inline

operator/() [60/76]

template<int M, class E , int S, class R >

CNT<std::complex<R> >::template Result<SymMat<M,E,S> >::Dvd SimTK::operator/ ( const std::complex< R > &  l, const SymMat< M, E, S > &  r  )

inline

operator/() [61/76]

template<int M, class E , int S, class R >

SymMat<M,E,S>::template Result<std::complex<R> >::Dvd SimTK::operator/ ( const SymMat< M, E, S > &  l, const conjugate< R > &  r  )

inline

operator/() [62/76]

template<int M, class E , int S, class R >

CNT<std::complex<R> >::template Result<SymMat<M,E,S> >::Dvd SimTK::operator/ ( const conjugate< R > &  l, const SymMat< M, E, S > &  r  )

inline

operator/() [63/76]

template<int M, class E , int S, class R >

SymMat<M,E,S>::template Result<typename negator<R>::StdNumber>::Dvd SimTK::operator/ ( const SymMat< M, E, S > &  l, const negator< R > &  r  )

inline

operator/() [64/76]

template<int M, class E , int S, class R >

CNT<R>::template Result<SymMat<M,E,S> >::Dvd SimTK::operator/ ( const negator< R > &  l, const SymMat< M, E, S > &  r  )

inline

operator+() [55/79]

template<int M, class E , int S>

SymMat<M,E,S>::template Result<float>::Add SimTK::operator+ ( const SymMat< M, E, S > &  l, const float &  r  )

inline

operator+() [56/79]

template<int M, class E , int S>

SymMat<M,E,S>::template Result<float>::Add SimTK::operator+ ( const float &  l, const SymMat< M, E, S > &  r  )

inline

operator+() [57/79]

template<int M, class E , int S>

SymMat<M,E,S>::template Result<double>::Add SimTK::operator+ ( const SymMat< M, E, S > &  l, const double &  r  )

inline

operator+() [58/79]

template<int M, class E , int S>

SymMat<M,E,S>::template Result<double>::Add SimTK::operator+ ( const double &  l, const SymMat< M, E, S > &  r  )

inline

operator+() [59/79]

template<int M, class E , int S>

SymMat<M,E,S>::template Result<typename CNT<E>::Precision>::Add SimTK::operator+ ( const SymMat< M, E, S > &  l, int  r  )

inline

operator+() [60/79]

template<int M, class E , int S>

SymMat<M,E,S>::template Result<typename CNT<E>::Precision>::Add SimTK::operator+ ( int  l, const SymMat< M, E, S > &  r  )

inline

operator+() [61/79]

template<int M, class E , int S, class R >

SymMat<M,E,S>::template Result<std::complex<R> >::Add SimTK::operator+ ( const SymMat< M, E, S > &  l, const std::complex< R > &  r  )

inline

operator+() [62/79]

template<int M, class E , int S, class R >

SymMat<M,E,S>::template Result<std::complex<R> >::Add SimTK::operator+ ( const std::complex< R > &  l, const SymMat< M, E, S > &  r  )

inline

operator+() [63/79]

template<int M, class E , int S, class R >

SymMat<M,E,S>::template Result<std::complex<R> >::Add SimTK::operator+ ( const SymMat< M, E, S > &  l, const conjugate< R > &  r  )

inline

operator+() [64/79]

template<int M, class E , int S, class R >

SymMat<M,E,S>::template Result<std::complex<R> >::Add SimTK::operator+ ( const conjugate< R > &  l, const SymMat< M, E, S > &  r  )

inline

operator+() [65/79]

template<int M, class E , int S, class R >

SymMat<M,E,S>::template Result<typename negator<R>::StdNumber>::Add SimTK::operator+ ( const SymMat< M, E, S > &  l, const negator< R > &  r  )

inline

operator+() [66/79]

template<int M, class E , int S, class R >

SymMat<M,E,S>::template Result<typename negator<R>::StdNumber>::Add SimTK::operator+ ( const negator< R > &  l, const SymMat< M, E, S > &  r  )

inline

operator-() [55/79]

template<int M, class E , int S>

SymMat<M,E,S>::template Result<float>::Sub SimTK::operator- ( const SymMat< M, E, S > &  l, const float &  r  )

inline

operator-() [56/79]

template<int M, class E , int S>

CNT<float>::template Result<SymMat<M,E,S> >::Sub SimTK::operator- ( const float &  l, const SymMat< M, E, S > &  r  )

inline

operator-() [57/79]

template<int M, class E , int S>

SymMat<M,E,S>::template Result<double>::Sub SimTK::operator- ( const SymMat< M, E, S > &  l, const double &  r  )

inline

operator-() [58/79]

template<int M, class E , int S>

CNT<double>::template Result<SymMat<M,E,S> >::Sub SimTK::operator- ( const double &  l, const SymMat< M, E, S > &  r  )

inline

operator-() [59/79]

template<int M, class E , int S>

SymMat<M,E,S>::template Result<typename CNT<E>::Precision>::Sub SimTK::operator- ( const SymMat< M, E, S > &  l, int  r  )

inline

operator-() [60/79]

template<int M, class E , int S>

CNT<typename CNT<E>::Precision>::template Result<SymMat<M,E,S> >::Sub SimTK::operator- ( int  l, const SymMat< M, E, S > &  r  )

inline

operator-() [61/79]

template<int M, class E , int S, class R >

SymMat<M,E,S>::template Result<std::complex<R> >::Sub SimTK::operator- ( const SymMat< M, E, S > &  l, const std::complex< R > &  r  )

inline

operator-() [62/79]

template<int M, class E , int S, class R >

CNT<std::complex<R> >::template Result<SymMat<M,E,S> >::Sub SimTK::operator- ( const std::complex< R > &  l, const SymMat< M, E, S > &  r  )

inline

operator-() [63/79]

template<int M, class E , int S, class R >

SymMat<M,E,S>::template Result<std::complex<R> >::Sub SimTK::operator- ( const SymMat< M, E, S > &  l, const conjugate< R > &  r  )

inline

operator-() [64/79]

template<int M, class E , int S, class R >

CNT<std::complex<R> >::template Result<SymMat<M,E,S> >::Sub SimTK::operator- ( const conjugate< R > &  l, const SymMat< M, E, S > &  r  )

inline

operator-() [65/79]

template<int M, class E , int S, class R >

SymMat<M,E,S>::template Result<typename negator<R>::StdNumber>::Sub SimTK::operator- ( const SymMat< M, E, S > &  l, const negator< R > &  r  )

inline

operator-() [66/79]

template<int M, class E , int S, class R >

CNT<R>::template Result<SymMat<M,E,S> >::Sub SimTK::operator- ( const negator< R > &  l, const SymMat< M, E, S > &  r  )

inline

operator<<() [16/18]

template<int M, class E , int RS, class CHAR , class TRAITS >

std::basic_ostream<CHAR,TRAITS>& SimTK::operator<< ( std::basic_ostream< CHAR, TRAITS > &  o, const SymMat< M, E, RS > &  m  )

inline

operator>>() [5/6]

template<int M, class E , int RS, class CHAR , class TRAITS >

std::basic_istream<CHAR,TRAITS>& SimTK::operator>> ( std::basic_istream< CHAR, TRAITS > &  is, SymMat< M, E, RS > &  m  )

inline

operator+() [67/79]

template<int M, class E1 , int S1, class E2 , int S2>

Vec<M,E1,S1>::template Result< Vec<M,E2,S2> >::Add SimTK::operator+ ( const Vec< M, E1, S1 > &  l, const Vec< M, E2, S2 > &  r  )

inline

operator-() [67/79]

template<int M, class E1 , int S1, class E2 , int S2>

Vec<M,E1,S1>::template Result< Vec<M,E2,S2> >::Sub SimTK::operator- ( const Vec< M, E1, S1 > &  l, const Vec< M, E2, S2 > &  r  )

inline

operator==() [21/22]

template<int M, class E1 , int S1, class E2 , int S2>

bool SimTK::operator== ( const Vec< M, E1, S1 > &  l, const Vec< M, E2, S2 > &  r  )

inline

bool = v1[i] == v2[i], for all elements i

operator!=() [17/18]

template<int M, class E1 , int S1, class E2 , int S2>

bool SimTK::operator!= ( const Vec< M, E1, S1 > &  l, const Vec< M, E2, S2 > &  r  )

inline

bool = v1[i] != v2[i], for any element i

operator==() [22/22]

template<int M, class E1 , int S1, class E2 >

bool SimTK::operator== ( const Vec< M, E1, S1 > &  v, const E2 &  e  )

inline

bool = v[i] == e, for all elements v[i] and element e

operator!=() [18/18]

template<int M, class E1 , int S1, class E2 >

bool SimTK::operator!= ( const Vec< M, E1, S1 > &  v, const E2 &  e  )

inline

bool = v[i] != e, for any element v[i] and element e

operator<() [3/4]

template<int M, class E1 , int S1, class E2 , int S2>

bool SimTK::operator< ( const Vec< M, E1, S1 > &  l, const Vec< M, E2, S2 > &  r  )

inline

bool = v1[i] < v2[i], for all elements i

operator<() [4/4]

template<int M, class E1 , int S1, class E2 >

bool SimTK::operator< ( const Vec< M, E1, S1 > &  v, const E2 &  e  )

inline

bool = v[i] < e, for all elements v[i] and element e

operator>() [4/5]

template<int M, class E1 , int S1, class E2 , int S2>

bool SimTK::operator> ( const Vec< M, E1, S1 > &  l, const Vec< M, E2, S2 > &  r  )

inline

bool = v1[i] > v2[i], for all elements i

operator>() [5/5]

template<int M, class E1 , int S1, class E2 >

bool SimTK::operator> ( const Vec< M, E1, S1 > &  v, const E2 &  e  )

inline

bool = v[i] > e, for all elements v[i] and element e

operator<=() [4/5]

template<int M, class E1 , int S1, class E2 , int S2>

bool SimTK::operator<= ( const Vec< M, E1, S1 > &  l, const Vec< M, E2, S2 > &  r  )

inline

bool = v1[i] <= v2[i], for all elements i.

This is not the same as !(v1>v2).

operator<=() [5/5]

template<int M, class E1 , int S1, class E2 >

bool SimTK::operator<= ( const Vec< M, E1, S1 > &  v, const E2 &  e  )

inline

bool = v[i] <= e, for all elements v[i] and element e.

This is not the same as !(v1>e).

operator>=() [4/5]

template<int M, class E1 , int S1, class E2 , int S2>

bool SimTK::operator>= ( const Vec< M, E1, S1 > &  l, const Vec< M, E2, S2 > &  r  )

inline

bool = v1[i] >= v2[i], for all elements i This is not the same as !(v1<v2).

operator>=() [5/5]

template<int M, class E1 , int S1, class E2 >

bool SimTK::operator>= ( const Vec< M, E1, S1 > &  v, const E2 &  e  )

inline

bool = v[i] >= e, for all elements v[i] and element e.

This is not the same as !(v1<e).

operator*() [149/161]

template<int M, class E , int S>

Vec<M,E,S>::template Result<float>::Mul SimTK::operator* ( const Vec< M, E, S > &  l, const float &  r  )

inline

operator*() [150/161]

template<int M, class E , int S>

Vec<M,E,S>::template Result<float>::Mul SimTK::operator* ( const float &  l, const Vec< M, E, S > &  r  )

inline

operator*() [151/161]

template<int M, class E , int S>

Vec<M,E,S>::template Result<double>::Mul SimTK::operator* ( const Vec< M, E, S > &  l, const double &  r  )

inline

operator*() [152/161]

template<int M, class E , int S>

Vec<M,E,S>::template Result<double>::Mul SimTK::operator* ( const double &  l, const Vec< M, E, S > &  r  )

inline

operator*() [153/161]

template<int M, class E , int S>

Vec<M,E,S>::template Result<typename CNT<E>::Precision>::Mul SimTK::operator* ( const Vec< M, E, S > &  l, int  r  )

inline

operator*() [154/161]

template<int M, class E , int S>

Vec<M,E,S>::template Result<typename CNT<E>::Precision>::Mul SimTK::operator* ( int  l, const Vec< M, E, S > &  r  )

inline

operator*() [155/161]

template<int M, class E , int S, class R >

Vec<M,E,S>::template Result<std::complex<R> >::Mul SimTK::operator* ( const Vec< M, E, S > &  l, const std::complex< R > &  r  )

inline

operator*() [156/161]

template<int M, class E , int S, class R >

Vec<M,E,S>::template Result<std::complex<R> >::Mul SimTK::operator* ( const std::complex< R > &  l, const Vec< M, E, S > &  r  )

inline

operator*() [157/161]

template<int M, class E , int S, class R >

Vec<M,E,S>::template Result<std::complex<R> >::Mul SimTK::operator* ( const Vec< M, E, S > &  l, const conjugate< R > &  r  )

inline

operator*() [158/161]

template<int M, class E , int S, class R >

Vec<M,E,S>::template Result<std::complex<R> >::Mul SimTK::operator* ( const conjugate< R > &  l, const Vec< M, E, S > &  r  )

inline

operator*() [159/161]

template<int M, class E , int S, class R >

Vec<M,E,S>::template Result<typename negator<R>::StdNumber>::Mul SimTK::operator* ( const Vec< M, E, S > &  l, const negator< R > &  r  )

inline

operator*() [160/161]

template<int M, class E , int S, class R >

Vec<M,E,S>::template Result<typename negator<R>::StdNumber>::Mul SimTK::operator* ( const negator< R > &  l, const Vec< M, E, S > &  r  )

inline

operator/() [65/76]

template<int M, class E , int S>

Vec<M,E,S>::template Result<float>::Dvd SimTK::operator/ ( const Vec< M, E, S > &  l, const float &  r  )

inline

operator/() [66/76]

template<int M, class E , int S>

CNT<float>::template Result<Vec<M,E,S> >::Dvd SimTK::operator/ ( const float &  l, const Vec< M, E, S > &  r  )

inline

operator/() [67/76]

template<int M, class E , int S>

Vec<M,E,S>::template Result<double>::Dvd SimTK::operator/ ( const Vec< M, E, S > &  l, const double &  r  )

inline

operator/() [68/76]

template<int M, class E , int S>

CNT<double>::template Result<Vec<M,E,S> >::Dvd SimTK::operator/ ( const double &  l, const Vec< M, E, S > &  r  )

inline

operator/() [69/76]

template<int M, class E , int S>

Vec<M,E,S>::template Result<typename CNT<E>::Precision>::Dvd SimTK::operator/ ( const Vec< M, E, S > &  l, int  r  )

inline

operator/() [70/76]

template<int M, class E , int S>

CNT<typename CNT<E>::Precision>::template Result<Vec<M,E,S> >::Dvd SimTK::operator/ ( int  l, const Vec< M, E, S > &  r  )

inline

operator/() [71/76]

template<int M, class E , int S, class R >

Vec<M,E,S>::template Result<std::complex<R> >::Dvd SimTK::operator/ ( const Vec< M, E, S > &  l, const std::complex< R > &  r  )

inline

operator/() [72/76]

template<int M, class E , int S, class R >

CNT<std::complex<R> >::template Result<Vec<M,E,S> >::Dvd SimTK::operator/ ( const std::complex< R > &  l, const Vec< M, E, S > &  r  )

inline

operator/() [73/76]

template<int M, class E , int S, class R >

Vec<M,E,S>::template Result<std::complex<R> >::Dvd SimTK::operator/ ( const Vec< M, E, S > &  l, const conjugate< R > &  r  )

inline

operator/() [74/76]

template<int M, class E , int S, class R >

CNT<std::complex<R> >::template Result<Vec<M,E,S> >::Dvd SimTK::operator/ ( const conjugate< R > &  l, const Vec< M, E, S > &  r  )

inline

operator/() [75/76]

template<int M, class E , int S, class R >

Vec<M,E,S>::template Result<typename negator<R>::StdNumber>::Dvd SimTK::operator/ ( const Vec< M, E, S > &  l, const negator< R > &  r  )

inline

operator/() [76/76]

template<int M, class E , int S, class R >

CNT<R>::template Result<Vec<M,E,S> >::Dvd SimTK::operator/ ( const negator< R > &  l, const Vec< M, E, S > &  r  )

inline

operator+() [68/79]

template<int M, class E , int S>

Vec<M,E,S>::template Result<float>::Add SimTK::operator+ ( const Vec< M, E, S > &  l, const float &  r  )

inline

operator+() [69/79]

template<int M, class E , int S>

Vec<M,E,S>::template Result<float>::Add SimTK::operator+ ( const float &  l, const Vec< M, E, S > &  r  )

inline

operator+() [70/79]

template<int M, class E , int S>

Vec<M,E,S>::template Result<double>::Add SimTK::operator+ ( const Vec< M, E, S > &  l, const double &  r  )

inline

operator+() [71/79]

template<int M, class E , int S>

Vec<M,E,S>::template Result<double>::Add SimTK::operator+ ( const double &  l, const Vec< M, E, S > &  r  )

inline

operator+() [72/79]

template<int M, class E , int S>

Vec<M,E,S>::template Result<typename CNT<E>::Precision>::Add SimTK::operator+ ( const Vec< M, E, S > &  l, int  r  )

inline

operator+() [73/79]

template<int M, class E , int S>

Vec<M,E,S>::template Result<typename CNT<E>::Precision>::Add SimTK::operator+ ( int  l, const Vec< M, E, S > &  r  )

inline

operator+() [74/79]

template<int M, class E , int S, class R >

Vec<M,E,S>::template Result<std::complex<R> >::Add SimTK::operator+ ( const Vec< M, E, S > &  l, const std::complex< R > &  r  )

inline

operator+() [75/79]

template<int M, class E , int S, class R >

Vec<M,E,S>::template Result<std::complex<R> >::Add SimTK::operator+ ( const std::complex< R > &  l, const Vec< M, E, S > &  r  )

inline

operator+() [76/79]

template<int M, class E , int S, class R >

Vec<M,E,S>::template Result<std::complex<R> >::Add SimTK::operator+ ( const Vec< M, E, S > &  l, const conjugate< R > &  r  )

inline

operator+() [77/79]

template<int M, class E , int S, class R >

Vec<M,E,S>::template Result<std::complex<R> >::Add SimTK::operator+ ( const conjugate< R > &  l, const Vec< M, E, S > &  r  )

inline

operator+() [78/79]

template<int M, class E , int S, class R >

Vec<M,E,S>::template Result<typename negator<R>::StdNumber>::Add SimTK::operator+ ( const Vec< M, E, S > &  l, const negator< R > &  r  )

inline

operator+() [79/79]

template<int M, class E , int S, class R >

Vec<M,E,S>::template Result<typename negator<R>::StdNumber>::Add SimTK::operator+ ( const negator< R > &  l, const Vec< M, E, S > &  r  )

inline

operator-() [68/79]

template<int M, class E , int S>

Vec<M,E,S>::template Result<float>::Sub SimTK::operator- ( const Vec< M, E, S > &  l, const float &  r  )

inline

operator-() [69/79]

template<int M, class E , int S>

CNT<float>::template Result<Vec<M,E,S> >::Sub SimTK::operator- ( const float &  l, const Vec< M, E, S > &  r  )

inline

operator-() [70/79]

template<int M, class E , int S>

Vec<M,E,S>::template Result<double>::Sub SimTK::operator- ( const Vec< M, E, S > &  l, const double &  r  )

inline

operator-() [71/79]

template<int M, class E , int S>

CNT<double>::template Result<Vec<M,E,S> >::Sub SimTK::operator- ( const double &  l, const Vec< M, E, S > &  r  )

inline

operator-() [72/79]

template<int M, class E , int S>

Vec<M,E,S>::template Result<typename CNT<E>::Precision>::Sub SimTK::operator- ( const Vec< M, E, S > &  l, int  r  )

inline

operator-() [73/79]

template<int M, class E , int S>

CNT<typename CNT<E>::Precision>::template Result<Vec<M,E,S> >::Sub SimTK::operator- ( int  l, const Vec< M, E, S > &  r  )

inline

operator-() [74/79]

template<int M, class E , int S, class R >

Vec<M,E,S>::template Result<std::complex<R> >::Sub SimTK::operator- ( const Vec< M, E, S > &  l, const std::complex< R > &  r  )

inline

operator-() [75/79]

template<int M, class E , int S, class R >

CNT<std::complex<R> >::template Result<Vec<M,E,S> >::Sub SimTK::operator- ( const std::complex< R > &  l, const Vec< M, E, S > &  r  )

inline

operator-() [76/79]

template<int M, class E , int S, class R >

Vec<M,E,S>::template Result<std::complex<R> >::Sub SimTK::operator- ( const Vec< M, E, S > &  l, const conjugate< R > &  r  )

inline

operator-() [77/79]

template<int M, class E , int S, class R >

CNT<std::complex<R> >::template Result<Vec<M,E,S> >::Sub SimTK::operator- ( const conjugate< R > &  l, const Vec< M, E, S > &  r  )

inline

operator-() [78/79]

template<int M, class E , int S, class R >

Vec<M,E,S>::template Result<typename negator<R>::StdNumber>::Sub SimTK::operator- ( const Vec< M, E, S > &  l, const negator< R > &  r  )

inline

operator-() [79/79]

template<int M, class E , int S, class R >

CNT<R>::template Result<Vec<M,E,S> >::Sub SimTK::operator- ( const negator< R > &  l, const Vec< M, E, S > &  r  )

inline

operator<<() [17/18]

template<int M, class E , int S, class CHAR , class TRAITS >

std::basic_ostream<CHAR,TRAITS>& SimTK::operator<< ( std::basic_ostream< CHAR, TRAITS > &  o, const Vec< M, E, S > &  v  )

inline

operator>>() [6/6]

template<int M, class E , int S, class CHAR , class TRAITS >

std::basic_istream<CHAR,TRAITS>& SimTK::operator>> ( std::basic_istream< CHAR, TRAITS > &  is, Vec< M, E, S > &  v  )

inline

Read a Vec from a stream as M elements separated by white space or by commas, optionally enclosed in () [] ~() or ~[].

SimTK_DEFINE_UNIQUE_INDEX_TYPE() [60/63]

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

ContactSurfaceIndex

)

SimTK_DEFINE_UNIQUE_INDEX_TYPE() [61/63]

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

ContactId

)

SimTK_DEFINE_UNIQUE_INDEX_TYPE() [62/63]

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

ContactTypeId

)

operator<<() [18/18]

std::ostream& SimTK::operator<< ( std::ostream &  o, const Contact &  c  )

inline

SimTK_DEFINE_UNIQUE_INDEX_TYPE() [63/63]

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

ContactGeometryTypeId

)

operator*() [161/161]

OrientedBoundingBox SimTK::operator*	(	const Transform &	t,
		const OrientedBoundingBox &	box
	)

explicitODE_static()

static int SimTK::explicitODE_static ( const CPodesSystem &  sys, Real  t, const Vector &  y, Vector &  fout  )

static

implicitODE_static()

static int SimTK::implicitODE_static ( const CPodesSystem &  sys, Real  t, const Vector &  y, const Vector &  yp, Vector &  fout  )

static

constraint_static()

static int SimTK::constraint_static ( const CPodesSystem &  sys, Real  t, const Vector &  y, Vector &  cout  )

static

project_static()

static int SimTK::project_static ( const CPodesSystem &  sys, Real  t, const Vector &  ycur, Vector &  corr, Real  epsProj, Vector &  err  )

static

quadrature_static()

static int SimTK::quadrature_static ( const CPodesSystem &  sys, Real  t, const Vector &  y, Vector &  qout  )

static

root_static()

static int SimTK::root_static ( const CPodesSystem &  sys, Real  t, const Vector &  y, const Vector &  yp, Vector &  gout  )

static

weight_static()

static int SimTK::weight_static ( const CPodesSystem &  sys, const Vector &  y, Vector &  weights  )

static

errorHandler_static()

static void SimTK::errorHandler_static ( const CPodesSystem &  sys, int  error_code, const char *  module, const char *  function, char *  msg  )

static

Variable Documentation

Black

const Vec3 SimTK::Black

extern

RGB=( 0, 0, 0)

Gray

const Vec3 SimTK::Gray

extern

RGB=(.5,.5,.5)

Red

const Vec3 SimTK::Red

extern

RGB=( 1, 0, 0)

Green

const Vec3 SimTK::Green

extern

RGB=( 0, 1, 0)

Blue

const Vec3 SimTK::Blue

extern

RGB=( 0, 0, 1)

Yellow

const Vec3 SimTK::Yellow

extern

RGB=( 1, 1, 0)

Orange

const Vec3 SimTK::Orange

extern

RGB=( 1,.5, 0)

Magenta

const Vec3 SimTK::Magenta

extern

RGB=( 1, 0, 1)

Purple

const Vec3 SimTK::Purple

extern

RGB=(.5, 0,.5)

Cyan

const Vec3 SimTK::Cyan

extern

RGB=( 0, 1, 1)

White

const Vec3 SimTK::White

extern

RGB=( 1, 1, 1)

InvalidIndex

const int SimTK::InvalidIndex = -1111111111

static

Is64BitPlatform

const bool SimTK::Is64BitPlatform = detect64BitPlatform()

static

XAxis

const CoordinateAxis::XCoordinateAxis SimTK::XAxis

extern

Constant representing the X coordinate axis; will implicitly convert to the integer 0 when used in a context requiring an integer.

YAxis

const CoordinateAxis::YCoordinateAxis SimTK::YAxis

extern

Constant representing the Y coordinate axis; will implicitly convert to the integer 1 when used in a context requiring an integer.

ZAxis

const CoordinateAxis::ZCoordinateAxis SimTK::ZAxis

extern

Constant representing the Z coordinate axis; will implicitly convert to the integer 2 when used in a context requiring an integer.

NegXAxis

const CoordinateDirection::NegXDirection SimTK::NegXAxis

extern

Global constant indicating -X coordinate direction.

NegYAxis

const CoordinateDirection::NegYDirection SimTK::NegYAxis

extern

Global constant indicating -Y coordinate direction.

NegZAxis

const CoordinateDirection::NegZDirection SimTK::NegZAxis

extern

Global constant indicating -Z coordinate direction.

DefaultRecpCondition

const double SimTK::DefaultRecpCondition = 1e-12

static