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
namespace	BondMobility
	Namespace for description of allowed bond motions.
namespace	DuMM
	This namespace is used for symbols which are useful in conjunction with Molmodel's DuMMForceFieldSubsystem.
namespace	Exception
namespace	Impl
namespace	md
namespace	mdunits
namespace	Ordinality
namespace	Pdb
namespace	units
Classes
class	AtomSubsystem
class	Biotype
class	Clonable
class	Compound
	The base class for atoms, molecules, and chemical groups. More...
class	UnivalentAtom
	Base class for atoms with exaclty one covalent bond partner. More...
class	BivalentAtom
	Base class for atoms having exactly two covalent bonds. More...
class	TrivalentAtom
	Base class for atoms having exactly three covalent bonds. More...
class	QuadrivalentAtom
	Base class for atoms having exactly four covalent bonds. More...
class	AliphaticHydrogen
	AliphaticHydrogen is a hydrogen atom for bonding to AliphaticCarbon atoms (see below). More...
class	AliphaticCarbon
	AliphaticCarbon is a tetrahedral sp3 carbon atom for bonding to four other things. More...
class	MethyleneGroup
	MethyleneGroup is -CH2- group for bonding to aliphatic carbon and a second something. More...
class	MethylGroup
	MethylGroup is CH3 for attaching to aliphatic carbon. More...
class	AromaticSixMemberedCHGroup
	Two atom C-H group in six membered aromatic rings. More...
class	AlcoholOHGroup
	AlcoholOHGroup is OH group for attachment to aliphatic carbon. More...
class	PrimaryAmineGroup
	PrimaryAmineGroup is NH3+ for attachment to tetrahedral carbon. More...
class	CarboxylateGroup
	CaboxylateGroup is COO- for attachment to tetrahedral carbon. More...
class	Molecule
	Base class for complete covalently connected molecules. More...
class	Argon
	The noble gas argon, which does not bond with other atoms. More...
class	Methane
	The simplest hydrocarbon methane, CH4. More...
class	Ethane
	The small hydrocarbon ethane, C2H6, which has a single torsion degree of freedom. More...
class	BiopolymerResidue
class	ResidueInfo
class	Biopolymer
	The base class for DNA, RNA, and Protein molecules. More...
class	CompoundModeler
	Turns a compound into a multibody system. More...
class	CompoundSystem
	Derived class of MolecularMechanicsSystem that knows how to model molmodel Compounds. More...
class	DuMMForceFieldSubsystem
	This is a concrete subsystem that provides basic molecular mechanics functionality for coarse-grained molecules built in the SimTK framework. More...
class	Amber99ForceSubsystem
	This class is just a DuMMForceFieldSubsystem for which the constructor pre-loads the definitions of the Amber99 force field. More...
class	Element
class	GrinPointer
class	LithiumIon
	Li+ lithium ion with +1 charge. More...
class	SodiumIon
	Na+ sodium ion with +1 charge. More...
class	PotassiumIon
	K+ potassium ion with +1 charge. More...
class	RubidiumIon
	Rb+ rubidium ion with +1 charge. More...
class	CesiumIon
	Cs+ cesium ion with +1 charge. More...
class	MagnesiumIon
	Mg2+ magnesium ion with +2 charge. More...
class	CalciumIon
	Ca2+ calcium ion with +2 charge. More...
class	ZincIon
	Zn2+ zinc ion with +2 charge. More...
class	ChlorideIon
	Cl- chloride ion with -1 charge. More...
class	LigandDroplet
class	P12
class	MassCenterMotionRemover
	This is an event handler that can remove from a molecular system any unwanted "rigid body" motion of the sytem as a whole. More...
class	MolecularMechanicsSystem
	This is a particular kind of MultibodySystem, one intended for use in molecular mechanics (MM). More...
class	NoseHooverThermostat
class	PdbResidueId
	Composite key for residue within a chain, composed of residue number and insertion code. More...
class	PdbAtomLocation
	Location information for a PdbAtom, corresponding to one altLoc for a PdbAtom. More...
class	PdbAtom
	One atom, which may have more than one location, in the case of static or dynamic disorder in an X-ray structure. More...
class	PdbResidue
	One residue in a protein or nucleic acid, or a single molecule in the case of non-polymer structures. More...
class	PdbChain
	One molecule in a PDB structure. More...
class	PdbModel
	PDB structure containing one or more molecules (chains), corresponding to one member of an NMR ensemble of alternate structures, or to one frame of a molecular dynamics simulation. More...
class	PdbStructure
	Complete PDB file, possibly including multiple MODELS, in the case of NMR structures or molecular dynamics trajectories. More...
class	PDBReader
	This class parses PDB files, then constructs Systems and States based on them for use in Simbody. More...
class	PeriodicPdbWriter
	Writes atomic coordinates in PDB format to a file stream at specified intervals during a simulation. More...
class	PeriodicVmdReporter
	Writes atomic coordinates in PDB format to a file stream at specified intervals during a simulation. More...
class	AcetylResidue
	Widely used acetyl protein N-terminal end cap. More...
class	NMethylAmideResidue
	Neutral C-terminal protein cap. More...
class	AminoAcidResidue
	amino acid residue building block for protein polypeptide chain molecules More...
class	HNAminoAcidResidue
	AminoAcidResidue differs from HNAminoAcidResidue in lacking "HN" proton, so Proline can be derived. More...
class	BetaUnbranchedAminoAcidResidue
class	BetaBranchedAminoAcidResidue
class	Protein
class	ZeroFunction
	Function f(x) = 0 for all x. More...
class	SinusoidFunction
	Implements a simple functional relationship, y = amplitude * sin(x - phase). More...
class	PseudorotationMobilizer
class	RiboseNu3Mobilizer
class	RiboseCore
class	FivePrimeRnaHydroxylGroup
	Phosphate group at 5' end (beginning) of RNA. More...
class	FivePrimeRnaPhosphateGroup
	Phosphate group at 5' end (beginning) of RNA. More...
class	RnaPhosphodiesterLinkage
class	ThreePrimeRnaHydroxylGroup
	Phosphate group at 3' end (beginning) of RNA. More...
class	ThreePrimeRnaPhosphateGroup
	Phosphate group at 3' end (end) of RNA. More...
class	RibonucleosideResidue
class	RibonucleotideResidue
class	PurineBaseCore
class	AdenineBase
class	GuanineBase
class	TwoNMethylGuanineBaseGroup
class	PyrimidineBaseCore
class	CytosineBase
class	UracilBase
class	TwoNMethylGuanidineGroup
class	RNA
class	Vec3Pair
	Matched pair of 3D vectors to be used in least-squares superposition. More...
class	TransformAndResidual
class	Kabsch78
class	VanDerWaalsForce
class	VanderWallSphere
class	VelocityRescalingThermostat
	This is an event handler that acts as a thermostat for controlling the temperature of a simulation efficiently, and in a qualitatively reasonable manner although not with the correct statistical temperature distribution. More...
class	VmdFloat3
class	VmdConnection
class	VoxelHash
class	Water
class	WaterDroplet
class	Body
class	CollisionDetectionAlgorithm
	A CollisionDetectionAlgorithm implements an algorithm for detecting overlaps between pairs of ContactGeometry objects, and creating Contact objects based on them. More...
class	Constraint
	This is the base class for all Constraint classes, which is just a handle for the underlying hidden implementation. More...
class	Contact
	A Contact contains information about two bodies that are in contact with each other. More...
class	PointContact
	This subclass of Contact represents a symmetric contact centered at a single point, such as between two spheres or a sphere and a half space. More...
class	TriangleMeshContact
	This subclass of Contact is used when one or both of the ContactGeometry objects is a TriangleMesh. More...
class	ContactGeometry
	A ContactGeometry object describes the physical shape of a body. More...
class	ContactGeometryImpl
class	OBBTreeNodeImpl
class	ContactImpl
	This is the internal implementation class for Contact. More...
class	PointContactImpl
	This is the internal implementation class for PointContact. More...
class	TriangleMeshContactImpl
	This is the internal implementation class for TriangleMeshContact. 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	Force
	A Force object applies forces to the bodies in a system. 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: K. 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	LocalEnergyMinimizer
	This class performs local potential energy minimization of a MultibodySystem. More...
class	MobilizedBody
	This is the base class for all MobilizedBody classes, just a handle for the underlying hidden implementation. 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	MultibodyDynamicsStudy
class	ObservedPointFitter
	This class attempts to find the configuration of an internal coordinate model which best fits a set of observed data. More...
class	OrientedBoundingBox
	This class represents a rectangular box with arbitrary position and orientation. More...
class	SimbodyMatterSubsystem
	The Simbody low-level multibody tree interface. 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	TextDataEventReporter
	This is an EventReporter which prints out numeric data at regular intervals in tabular form. More...
class	VTKEventReporter
	This is an EventReporter that makes it easy to generate on-screen movies of any simulation. More...
class	VTKVisualizer
class	CPodesIntegrator
	This is an Integrator based on the CPODES library. 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	ExplicitEulerIntegrator
	This is an Integrator based on the explicit Euler algorithm. More...
class	Integrator
	An Integrator is an object that can simulate the behavior of a System through time. More...
class	Function_
	This abstract class represents a mathematical function that calculates a value of arbitrary type based on M real arguments. More...
class	GCVSPLUtil
	This class provides entry points for using the GCVSPL algorithm in terms of SimTK data types. More...
class	Spline_
	This class implements a non-uniform B-spline curve. More...
class	SplineFitter
	Given a set of data points, this class creates a Spline_ which interpolates or approximates them. More...
class	Factor
	Abstract class for performing 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	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	RungeKuttaFeldbergIntegrator
class	RungeKuttaMersonIntegrator
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...
class	AnalyticGeometry
	This abstract class represents a piece of high-quality geometry that can be used for valid physical simulation. More...
class	AnalyticCurve
class	AnalyticSurface
class	AnalyticVolume
class	AnalyticLine
	An analytic line has only a length. More...
class	AnalyticCircle
	An analytic circle has only a radius. More...
class	AnalyticSphere
class	AnalyticCylinder
	The coordinate frame of the central cross section is the same as for a circle; that is, x and z are radial and y points along the cylinder's axis. More...
class	AnalyticBrick
	This is a rectangular solid. More...
class	ArrayBase
class	ArrayView
	This class is a duplicate of Array and can be cast to an Array with no harm. More...
class	Array
	Container class like std::vector<T> but with hidden implementation. More...
class	AtomicInteger
	This class functions exactly like an int, except that the following operators are atomic: ++, --, +=, -=, *=, /=, =, &=, |=, ^=, <<=, and >>=. More...
class	MatrixBase
	Variable-size 2d matrix of Composite Numerical Type (ELT) elements. 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_
	This class is identical to a Matrix_; it is used only to manage the C++ rules for when copy constructors are called by introducing a separate type to prevent certain allowed optimizations from occuring when we don't want them. More...
class	DeadMatrixView_
	This is a MatrixView_ with the additional property that we are about to delete it. More...
class	Matrix_
	This is the Matrix class intended to appear in user code. More...
class	VectorView_
	This class is identical to a Vector_; it is used only to manage the C++ rules for when copy constructors are called by introducing a separate type to prevent certain allowed optimizations from occuring when we don't want them. More...
class	Vector_
	This is the Vector class intended to appear in user code. More...
class	RowVectorView_
	This class is identical to a RowVector_; it is used only to manage the C++ rules for when copy constructors are called by introducing a separate type to prevent certain allowed optimizations from occuring when we don't want them. More...
class	RowVector_
	RowVectors are much less common than Vectors. More...
class	VectorIterator
	This is an iterator for iterating over the elements of a Vector. More...
class	CNT
	Specialized information about Composite Numerical Types which allows us to define appropriate templatized classes using them. More...
class	Concretize
	Wrap a pointer to an abstract base class in a way that makes it behave like a concrete class (sometimes called a "ClonePtr"). More...
struct	Wider
struct	Wider< float, float >
struct	Wider< float, double >
struct	Wider< double, float >
struct	Wider< double, double >
struct	Wider< float, long double >
struct	Wider< double, long double >
struct	Wider< long double, float >
struct	Wider< long double, double >
struct	Wider< long double, long double >
class	conjugate
	SimTK::conjugate<R> should be instantiated only for float, double, long double. More...
class	conjugate< float >
class	conjugate< double >
class	conjugate< long double >
class	CoordinateAxis
class	DecorativeGeometry
	This is an abstract handle class using the PIMPL design pattern to hide the private implementation. 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 polygonal mesh. More...
class	DecorativeGeometryImplementation
	Use this abstract class to connect your implementation of decorative geometry to the implementation-independent classes above. More...
class	Enumeration
	This class defines an enumerated type. More...
class	EnumerationSet
	This class provides an efficient implementation of a set for storing values of an enumerated type defined with Enumeration. More...
class	Event
	An Event is "something that happens" during a Study that is advancing through time. 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	ListBase
class	ListBase< T * >
class	ListView
	ListView is a 'dummy' class which is completely interchangeable with List. More...
class	List
	Container class with hidden implementation. More...
class	Inertia
	The physical meaning of an inertia is the distribution of a rigid body's mass about a *particular* point. More...
class	MassProperties
	This class contains the mass, center of mass, and inertia of a rigid body B. More...
class	Mat
	CS is total spacing between columns in memory (default M) RS is total spacing between rows in memory (default 1). 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	MatrixHelper
	Here we define class MatrixHelper<S>, the scalar-type templatized helper class for the more general, composite numerical type-templatized class MatrixBase<ELT>. More...
class	Measure
	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. 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...
struct	Widest
	This class is specialized for all 36 combinations of standard types (that is, real and complex types in each of three 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,long double). More...
struct	Widest< float, float >
struct	Widest< float, double >
struct	Widest< float, long double >
struct	Widest< double, float >
struct	Widest< double, double >
struct	Widest< double, long double >
struct	Widest< long double, float >
struct	Widest< long double, double >
struct	Widest< long double, long 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 36 combinations of standard types (that is, real and complex types in each of three 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, long double). More...
struct	Narrowest< float, float >
struct	Narrowest< float, double >
struct	Narrowest< float, long double >
struct	Narrowest< double, float >
struct	Narrowest< double, double >
struct	Narrowest< double, long double >
struct	Narrowest< long double, float >
struct	Narrowest< long double, double >
struct	Narrowest< long double, long 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	RTraits< long double >
class	NTraits
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	CNT< long double >
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	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	PolygonalMesh
	This class provides a description of a mesh made of polygonal faces. More...
class	PolynomialRootFinder
	This class provides static methods for finding the roots of polynomials. 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	Quaternion
	A Quaternion is a Vec4 with the following behavior: its length is always 1 (or else it is all NaN) it is equivalent to an angle/axis rotation for angle a, axis unit vector v, as: q = [ cos(a/2) sin(a/2)*v ] A quaternion is in "canonical form" when its first element is nonnegative. More...
class	Random
	This class defines the interface for pseudo-random number generators. More...
class	Rotation
	The Rotation class is a Mat33 that guarantees that the matrix is a legitimate 3x3 array associated with the relative orientation of two right-handed, orthogonal, unit vector bases. More...
class	InverseRotation
	----------------------------------------------------------------------------- This InverseRotation class is the inverse of a Rotation See the Rotation class for information. More...
class	Row
	Generic Row. More...
class	PhiMatrix
class	PhiMatrixTranspose
class	StableArray
	StableArray<T> is like std::vector<T> but more stable in two ways: the addresses of the inserted items never change, even if the array has to be resized, and the index of an inserted item never changes either. 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 is the handle class for the hidden State implementation. More...
class	String
	SimTK::String is just an std::string with some additional methods defined. More...
class	Study
class	Subsystem
	The abstract parent of all Subsystems. More...
class	DefaultSystemSubsystem
	This is a concrete Subsystem that is part of every System. More...
class	SymMat
	RS is total spacing between rows in memory (default 1). More...
class	System
	The handle class which serves as the abstract parent of all Systems. More...
class	ThreadLocal
	This class represents a "thread local" variable: one which has a different value on each thread. More...
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: the length is one (to within a very small tolerance), or all components are NaN. More...
class	UnitRow
	This type is used for the transpose of UnitVec, and as the returned row type of a Rotation. More...
class	UserFunction
class	AbstractValue
	Abstract base class representing an arbitrary value of self-describing type. More...
class	Value
	Templatized version of the abstract class, providing generic type-specific functionality that does not require specialization, with automatic conversion to the underlying type. More...
class	Vec
	Generic Vec. More...
class	Lapack
class	Test
	This is the main class to support testing. More...
class	N_VectorContent_SimTK
class	N_Vector_Ops_SimTK
class	N_Vector_SimTK
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...
Typedefs
typedef Real	Angle
	angle in radians
typedef Real	LineAngle
typedef Real	CircleAngle
typedef Real	WindingAngle
typedef ForceSubsystem::Guts	ForceSubsystemRep
typedef Function_< Real >	Function
typedef Spline_< Real >	Spline
typedef Vector_< Real >	Vector
typedef Vector_< Complex >	ComplexVector
typedef VectorView_< Real >	VectorView
typedef VectorView_< Complex >	ComplexVectorView
typedef RowVector_< Real >	RowVector
typedef RowVector_< Complex >	ComplexRowVector
typedef RowVectorView_< Real >	RowVectorView
typedef RowVectorView_< Complex >	ComplexRowVectorView
typedef Matrix_< Real >	Matrix
typedef Matrix_< Complex >	ComplexMatrix
typedef MatrixView_< Real >	MatrixView
typedef MatrixView_< Complex >	ComplexMatrixView
typedef Mat< 2, 2, Mat33 >	SpatialMat
typedef Vec< 2, Vec3 >	SpatialVec
typedef Row< 2, Row3 >	SpatialRow
typedef int	StageVersion
	This is the type to use for Stage version numbers.
typedef UnitVec< 1 >	UnitVec3
typedef conjugate< Real >	Conjugate
typedef Vec< 1 >	Vec1
typedef Vec< 2 >	Vec2
typedef Vec< 3 >	Vec3
typedef Vec< 4 >	Vec4
typedef Vec< 5 >	Vec5
typedef Vec< 6 >	Vec6
typedef Vec< 7 >	Vec7
typedef Vec< 8 >	Vec8
typedef Vec< 9 >	Vec9
typedef Row< 1 >	Row1
typedef Row< 2 >	Row2
typedef Row< 3 >	Row3
typedef Row< 4 >	Row4
typedef Row< 5 >	Row5
typedef Row< 6 >	Row6
typedef Row< 7 >	Row7
typedef Row< 8 >	Row8
typedef Row< 9 >	Row9
typedef SymMat< 1 >	SymMat11
typedef SymMat< 2 >	SymMat22
typedef SymMat< 3 >	SymMat33
typedef SymMat< 4 >	SymMat44
typedef SymMat< 5 >	SymMat55
typedef SymMat< 6 >	SymMat66
typedef SymMat< 7 >	SymMat77
typedef SymMat< 8 >	SymMat88
typedef SymMat< 9 >	SymMat99
typedef Mat< 1, 1 >	Mat11
typedef Mat< 1, 2 >	Mat12
typedef Mat< 1, 3 >	Mat13
typedef Mat< 1, 4 >	Mat14
typedef Mat< 1, 5 >	Mat15
typedef Mat< 1, 6 >	Mat16
typedef Mat< 1, 7 >	Mat17
typedef Mat< 1, 8 >	Mat18
typedef Mat< 1, 9 >	Mat19
typedef Mat< 2, 1 >	Mat21
typedef Mat< 2, 2 >	Mat22
typedef Mat< 2, 3 >	Mat23
typedef Mat< 2, 4 >	Mat24
typedef Mat< 2, 5 >	Mat25
typedef Mat< 2, 6 >	Mat26
typedef Mat< 2, 7 >	Mat27
typedef Mat< 2, 8 >	Mat28
typedef Mat< 2, 9 >	Mat29
typedef Mat< 3, 1 >	Mat31
typedef Mat< 3, 2 >	Mat32
typedef Mat< 3, 3 >	Mat33
typedef Mat< 3, 4 >	Mat34
typedef Mat< 3, 5 >	Mat35
typedef Mat< 3, 6 >	Mat36
typedef Mat< 3, 7 >	Mat37
typedef Mat< 3, 8 >	Mat38
typedef Mat< 3, 9 >	Mat39
typedef Mat< 4, 1 >	Mat41
typedef Mat< 4, 2 >	Mat42
typedef Mat< 4, 3 >	Mat43
typedef Mat< 4, 4 >	Mat44
typedef Mat< 4, 5 >	Mat45
typedef Mat< 4, 6 >	Mat46
typedef Mat< 4, 7 >	Mat47
typedef Mat< 4, 8 >	Mat48
typedef Mat< 4, 9 >	Mat49
typedef Mat< 5, 1 >	Mat51
typedef Mat< 5, 2 >	Mat52
typedef Mat< 5, 3 >	Mat53
typedef Mat< 5, 4 >	Mat54
typedef Mat< 5, 5 >	Mat55
typedef Mat< 5, 6 >	Mat56
typedef Mat< 5, 7 >	Mat57
typedef Mat< 5, 8 >	Mat58
typedef Mat< 5, 9 >	Mat59
typedef Mat< 6, 1 >	Mat61
typedef Mat< 6, 2 >	Mat62
typedef Mat< 6, 3 >	Mat63
typedef Mat< 6, 4 >	Mat64
typedef Mat< 6, 5 >	Mat65
typedef Mat< 6, 6 >	Mat66
typedef Mat< 6, 7 >	Mat67
typedef Mat< 6, 8 >	Mat68
typedef Mat< 6, 9 >	Mat69
typedef Mat< 7, 1 >	Mat71
typedef Mat< 7, 2 >	Mat72
typedef Mat< 7, 3 >	Mat73
typedef Mat< 7, 4 >	Mat74
typedef Mat< 7, 5 >	Mat75
typedef Mat< 7, 6 >	Mat76
typedef Mat< 7, 7 >	Mat77
typedef Mat< 7, 8 >	Mat78
typedef Mat< 7, 9 >	Mat79
typedef Mat< 8, 1 >	Mat81
typedef Mat< 8, 2 >	Mat82
typedef Mat< 8, 3 >	Mat83
typedef Mat< 8, 4 >	Mat84
typedef Mat< 8, 5 >	Mat85
typedef Mat< 8, 6 >	Mat86
typedef Mat< 8, 7 >	Mat87
typedef Mat< 8, 8 >	Mat88
typedef Mat< 8, 9 >	Mat89
typedef Mat< 9, 1 >	Mat91
typedef Mat< 9, 2 >	Mat92
typedef Mat< 9, 3 >	Mat93
typedef Mat< 9, 4 >	Mat94
typedef Mat< 9, 5 >	Mat95
typedef Mat< 9, 6 >	Mat96
typedef Mat< 9, 7 >	Mat97
typedef Mat< 9, 8 >	Mat98
typedef Mat< 9, 9 >	Mat99
Enumerations
enum	OptimizerAlgorithm {   BestAvailiable = 0, InteriorPoint = 1, LBFGS = 2, LBFGSB = 3,   CFSQP = 4 }
enum	{   SCALAR_DEPTH = 0, SCALAR_COMPOSITE_DEPTH = 1, COMPOSITE_COMPOSITE_DEPTH = 2, COMPOSITE_3_DEPTH = 3,   MAX_RESOLVED_DEPTH = COMPOSITE_3_DEPTH }
enum	BodyOrSpaceType { BodyRotationSequence = 0, SpaceRotationSequence = 1 }
Functions
	SimTK_DEFINE_AND_EXPORT_UNIQUE_INDEX_TYPE (, BiotypeIndex)
	SimTK_DEFINE_AND_EXPORT_UNIQUE_INDEX_TYPE (, TinkerBiotypeIndex)
Angle	calcDihedralAngle (const Vec3 &atomPos1, const Vec3 &atomPos2, const Vec3 &atomPos3, const Vec3 &atomPos4)
	Dihedral angle in radians in the range (-Pi, Pi].
Angle	calcDihedralAngle (const UnitVec3 &bond12, const UnitVec3 &bond23, const UnitVec3 &bond34)
	Dihedral angle in radians in the range (-Pi, Pi].
std::ostream &	operator<< (std::ostream &o, const Compound &c)
	Dump debugging information about compound structure to a stream.
std::ostream &	operator<< (std::ostream &, const Element &)
template<class PointeeType >
PointeeType *	deepCopy (const PointeeType *ptr, const void *)
template<class PointeeType >
PointeeType *	deepCopy (const PointeeType *ptr, const Clonable *)
template<class PointeeType >
PointeeType *	deepCopy (const PointeeType *ptr)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (MobilizedBodyIndex) static const MobilizedBodyIndex GroundIndex(0)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (ConstraintIndex) 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(AnglePoolIndex) 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) namespace Exception
OrientedBoundingBox	operator* (const Transform &t, const OrientedBoundingBox &box)
std::ostream &	operator<< (std::ostream &, const SimbodyMatterSubsystem &)
std::ostream &	operator<< (std::ostream &, const SimbodyMatterSubtree &)
std::ostream &	operator<< (std::ostream &, const SimbodyMatterSubtreeResults &)
template<class T >
int	findFirstOf (const Array< T > &a, const T &test)
	If the type T supports an "==" operator, you can instantiate this method to find the first element of an Array<T> which matches the supplied test element.
template<class T >
int	findFirstOf (const ArrayView< T > &a, const T &test)
template<class T >
Array< int >	findAllOf (const Array< T > &a, const T &test)
	If the type T supports an "==" operator, you can instantiate this method to find the indices of all elements of an Array<T> at which the elements match the supplied test element.
template<class T >
Array< int >	findAllOf (const ArrayView< T > &a, const T &test)
template<class T >
bool	contains (const Array< T > &a, const T &test)
	If the type T supports an "==" operator, you can instantiate this method to find out if an Array<T> contains a particular test element.
template<class T >
bool	contains (const ArrayView< T > &a, const T &test)
template<class T >
std::ostream &	operator<< (std::ostream &s, const Array< T > &a)
template<class T >
std::ostream &	operator<< (std::ostream &s, const ArrayView< T > &a)
std::ostream &	operator<< (std::ostream &stream, const AtomicInteger &value)
template<class T >
std::ostream &	operator<< (std::ostream &o, const VectorBase< T > &v)
template<class T >
std::ostream &	operator<< (std::ostream &o, const RowVectorBase< T > &v)
template<class T >
std::ostream &	operator<< (std::ostream &o, const MatrixBase< T > &m)
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< long double >	operator* (const complex< float > &c, const long double &r)
complex< long double >	operator* (const long 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< long double >	operator/ (const complex< float > &c, const long double &r)
complex< long double >	operator/ (const long 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< long double >	operator+ (const complex< float > &c, const long double &r)
complex< long double >	operator+ (const long 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< long double >	operator- (const complex< float > &c, const long double &r)
complex< long double >	operator- (const long 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< long double >	operator* (const complex< double > &c, const long double &r)
complex< long double >	operator* (const long double &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< long double >	operator/ (const complex< double > &c, const long double &r)
complex< long double >	operator/ (const long double &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< long double >	operator+ (const complex< double > &c, const long double &r)
complex< long double >	operator+ (const long double &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< long double >	operator- (const complex< double > &c, const long double &r)
complex< long double >	operator- (const long double &r, const complex< double > &c)
complex< long double >	operator* (const complex< long double > &c, int r)
complex< long double >	operator* (int r, const complex< long double > &c)
complex< long double >	operator* (const complex< long double > &c, const float &r)
complex< long double >	operator* (const float &r, const complex< long double > &c)
complex< long double >	operator* (const complex< long double > &c, const double &r)
complex< long double >	operator* (const double &r, const complex< long double > &c)
complex< long double >	operator/ (const complex< long double > &c, int r)
complex< long double >	operator/ (int r, const complex< long double > &c)
complex< long double >	operator/ (const complex< long double > &c, const float &r)
complex< long double >	operator/ (const float &r, const complex< long double > &c)
complex< long double >	operator/ (const complex< long double > &c, const double &r)
complex< long double >	operator/ (const double &r, const complex< long double > &c)
complex< long double >	operator+ (const complex< long double > &c, int r)
complex< long double >	operator+ (int r, const complex< long double > &c)
complex< long double >	operator+ (const complex< long double > &c, const float &r)
complex< long double >	operator+ (const float &r, const complex< long double > &c)
complex< long double >	operator+ (const complex< long double > &c, const double &r)
complex< long double >	operator+ (const double &r, const complex< long double > &c)
complex< long double >	operator- (const complex< long double > &c, int r)
complex< long double >	operator- (int r, const complex< long double > &c)
complex< long double >	operator- (const complex< long double > &c, const float &r)
complex< long double >	operator- (const float &r, const complex< long double > &c)
complex< long double >	operator- (const complex< long double > &c, const double &r)
complex< long double >	operator- (const double &r, const complex< long 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)
const long double &	real (const conjugate< long double > &c)
const negator< long double > &	imag (const conjugate< long double > &c)
const complex< long double > &	conj (const conjugate< long double > &c)
long double	abs (const conjugate< long double > &c)
long double	norm (const conjugate< long 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 >
conjugate< long double >	operator+ (const conjugate< R > &a, const long double &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 >
conjugate< long double >	operator+ (const long double &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 >
conjugate< long double >	operator* (const conjugate< R > &a, const long double &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 >
conjugate< long double >	operator* (const long double &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 long double &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 long double &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 long double &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 long double &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 >
conjugate< long double >	operator- (const conjugate< R > &a, const long double &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 >
complex< long double >	operator- (const long double &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 >
conjugate< long double >	operator/ (const conjugate< R > &a, const long double &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 >
complex< long double >	operator/ (const long double &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)
template<class T >
std::ostream &	operator<< (std::ostream &stream, const Enumeration< T > &value)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (SystemEventIndex)
	This unique integer type is for identifying an event in the full System-level view of the State.
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (EventIndex)
	Unique integer type for Subsystem-local event indexing.
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (SystemEventTriggerIndex)
	This unique integer type is for identifying a triggered event in the full System-level view of the State.
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (EventTriggerIndex)
	Unique integer type for Subsystem-local event indexing.
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (SystemEventTriggerByStageIndex)
	This unique integer type is for identifying a triggered event within a particular Stage of the full System-level view of the State.
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (EventTriggerByStageIndex)
	Unique integer type for Subsystem-local, per-stage event indexing.
	SimTK_LIST_SPECIALIZE (bool)
	SimTK_LIST_SPECIALIZE (signed char)
	SimTK_LIST_SPECIALIZE (char)
	SimTK_LIST_SPECIALIZE (unsigned char)
	SimTK_LIST_SPECIALIZE (short)
	SimTK_LIST_SPECIALIZE (int)
	SimTK_LIST_SPECIALIZE (long)
	SimTK_LIST_SPECIALIZE (float)
	SimTK_LIST_SPECIALIZE (double)
	SimTK_LIST_SPECIALIZE (std::complex< float >)
	SimTK_LIST_SPECIALIZE (std::complex< double >)
	SimTK_LIST_SPECIALIZE (std::complex< long double >)
template<class T >
int	findFirstOf (const List< T > &l, const T &test)
	If the type T supports an "==" operator, you can instantiate this method to find the first element of an List<T> which matches the supplied test element.
template<class T >
int	findFirstOf (const ListView< T > &lv, const T &test)
template<class T >
Array< int >	findAllOf (const List< T > &l, const T &test)
	If the type T supports an "==" operator, you can instantiate this method to find the indices of all elements of an List<T> at which the elements match the supplied test element.
template<class T >
Array< int >	findAllOf (const ListView< T > &lv, const T &test)
template<class T >
bool	contains (const List< T > &l, const T &test)
	If the type T supports an "==" operator, you can instantiate this method to find out if an List<T> contains a particular test element.
template<class T >
bool	contains (const ListView< T > &lv, const T &test)
Inertia	operator+ (const Inertia &l, const Inertia &r)
Inertia	operator- (const Inertia &l, const Inertia &r)
Inertia	operator* (const Inertia &i, const Real &r)
Inertia	operator* (const Real &r, const Inertia &i)
Vec3	operator* (const Inertia &i, const Vec3 &w)
Inertia	operator/ (const Inertia &i, const Real &r)
bool	operator== (const Inertia &i1, const Inertia &i2)
std::ostream &	operator<< (std::ostream &o, const Inertia &)
std::ostream &	operator<< (std::ostream &o, const MassProperties &)
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< long double > ::Mul	operator* (const Mat< M, N, E, CS, RS > &l, const long double &r)
template<int M, int N, class E , int CS, int RS>
Mat< M, N, E, CS, RS > ::template Result< long double > ::Mul	operator* (const long 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< long double > ::Dvd	operator/ (const Mat< M, N, E, CS, RS > &l, const long double &r)
template<int M, int N, class E , int CS, int RS>
CNT< long double >::template Result< Mat< M, N, E, CS, RS > >::Dvd	operator/ (const long 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< long double > ::Add	operator+ (const Mat< M, N, E, CS, RS > &l, const long double &r)
template<int M, int N, class E , int CS, int RS>
Mat< M, N, E, CS, RS > ::template Result< long double > ::Add	operator+ (const long 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< long double > ::Sub	operator- (const Mat< M, N, E, CS, RS > &l, const long double &r)
template<int M, int N, class E , int CS, int RS>
CNT< long double >::template Result< Mat< M, N, E, CS, RS > >::Sub	operator- (const long 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)
std::ostream &	operator<< (std::ostream &o, const MatrixCharacter &)
	Output a textual description of a MatrixCharacter; handy for debugging.
std::ostream &	operator<< (std::ostream &o, const MatrixCommitment &)
	Output a textual description of a MatrixCommitment; handy for debugging.
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (MeasureIndex)
	Define a unique integral type for safe indexing of Measures.
bool	isNaN (const negator< float > &x)
bool	isNaN (const negator< double > &x)
bool	isNaN (const negator< long 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)
bool	isFinite (const negator< long 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)
bool	isInf (const negator< long 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 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)
bool	isNaN (const long 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)
bool	isFinite (const long 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)
bool	isInf (const long 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.
bool	isNumericallyEqual (const double &a, const double &b, double tol=RTraits< double >::getDefaultTolerance())
	Compare two doubles for approximate equality.
bool	isNumericallyEqual (const long double &a, const long double &b, double tol=RTraits< long double >::getDefaultTolerance())
	Compare two long doubles for approximate equality.
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.
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.
bool	isNumericallyEqual (const float &a, const long double &b, double tol=RTraits< float >::getDefaultTolerance())
	Compare a float and a long double for approximate equality at float precision.
bool	isNumericallyEqual (const long double &a, const float &b, double tol=RTraits< float >::getDefaultTolerance())
	Compare a float and a long double for approximate equality at float precision.
bool	isNumericallyEqual (const double &a, const long double &b, double tol=RTraits< double >::getDefaultTolerance())
	Compare a double and a long double for approximate equality at double precision.
bool	isNumericallyEqual (const long double &a, const double &b, double tol=RTraits< double >::getDefaultTolerance())
	Compare a double and a long double for approximate equality at double precision.
bool	isNumericallyEqual (const float &a, int b, double tol=RTraits< float >::getDefaultTolerance())
	Test a float for approximate equality to an integer.
bool	isNumericallyEqual (int a, const float &b, double tol=RTraits< float >::getDefaultTolerance())
	Test a float for approximate equality to an integer.
bool	isNumericallyEqual (const double &a, int b, double tol=RTraits< double >::getDefaultTolerance())
	Test a double for approximate equality to an integer.
bool	isNumericallyEqual (int a, const double &b, double tol=RTraits< double >::getDefaultTolerance())
	Test a double for approximate equality to an integer.
bool	isNumericallyEqual (const long double &a, int b, double tol=RTraits< long double >::getDefaultTolerance())
	Test a long double for approximate equality to an integer.
bool	isNumericallyEqual (int a, const long double &b, double tol=RTraits< long double >::getDefaultTolerance())
	Test a long double for approximate equality to an integer.
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.
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.
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.
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.
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.
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.
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.
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.
template<class P >
bool	isNumericallyEqual (const std::complex< P > &a, const long double &b, double tol=RTraits< P >::getDefaultTolerance())
	Test whether a complex number is approximately equal to a particular real long double.
template<class P >
bool	isNumericallyEqual (const long double &a, const std::complex< P > &b, double tol=RTraits< P >::getDefaultTolerance())
	Test whether a complex number is approximately equal to a particular real long double.
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.
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.
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.
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.
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.
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.
template<class P >
bool	isNumericallyEqual (const conjugate< P > &a, const long double &b, double tol=RTraits< P >::getDefaultTolerance())
	Test whether a conjugate number is approximately equal to a particular real long double.
template<class P >
bool	isNumericallyEqual (const long double &a, const conjugate< P > &b, double tol=RTraits< P >::getDefaultTolerance())
	Test whether a conjugate number is approximately equal to a particular real long double.
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.
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.
	SimTK_BNTCMPLX_SPEC (float, float)
	SimTK_BNTCMPLX_SPEC (float, double)
	SimTK_BNTCMPLX_SPEC (float, long double)
	SimTK_BNTCMPLX_SPEC (double, float)
	SimTK_BNTCMPLX_SPEC (double, double)
	SimTK_BNTCMPLX_SPEC (double, long double)
	SimTK_BNTCMPLX_SPEC (long double, float)
	SimTK_BNTCMPLX_SPEC (long double, double)
	SimTK_BNTCMPLX_SPEC (long double, long double)
	SimTK_NTRAITS_CONJ_SPEC (float, float)
	SimTK_NTRAITS_CONJ_SPEC (float, double)
	SimTK_NTRAITS_CONJ_SPEC (float, long double)
	SimTK_NTRAITS_CONJ_SPEC (double, float)
	SimTK_NTRAITS_CONJ_SPEC (double, double)
	SimTK_NTRAITS_CONJ_SPEC (double, long double)
	SimTK_NTRAITS_CONJ_SPEC (long double, float)
	SimTK_NTRAITS_CONJ_SPEC (long double, double)
	SimTK_NTRAITS_CONJ_SPEC (long double, long double)
	SimTK_DEFINE_REAL_NTRAITS (float)
	SimTK_DEFINE_REAL_NTRAITS (double)
	SimTK_DEFINE_REAL_NTRAITS (long double)
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)
std::ostream &	operator<< (std::ostream &o, const Rotation &m)
template<int S>
UnitVec< 1 >	operator* (const Rotation &R, const UnitVec< S > &v)
template<int S>
UnitRow< 1 >	operator* (const UnitRow< S > &r, const Rotation &R)
template<int S>
UnitVec< 1 >	operator* (const InverseRotation &R, const UnitVec< S > &v)
template<int S>
UnitRow< 1 >	operator* (const UnitRow< S > &r, const InverseRotation &R)
Rotation	operator* (const Rotation &R1, const Rotation &R2)
Rotation	operator* (const Rotation &R1, const InverseRotation &R2)
Rotation	operator* (const InverseRotation &R1, const Rotation &R2)
Rotation	operator* (const InverseRotation &R1, const InverseRotation &R2)
Rotation	operator/ (const Rotation &R1, const Rotation &R2)
Rotation	operator/ (const Rotation &R1, const InverseRotation &R2)
Rotation	operator/ (const InverseRotation &R1, const Rotation &R2)
Rotation	operator/ (const InverseRotation &R1, const InverseRotation &R2)
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)
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)
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< long double >::Mul	operator* (const Row< N, E, S > &l, const long double &r)
template<int N, class E , int S>
Row< N, E, S >::template Result< long double >::Mul	operator* (const long 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< long double >::Dvd	operator/ (const Row< N, E, S > &l, const long double &r)
template<int N, class E , int S>
CNT< long double >::template Result< Row< N, E, S > >::Dvd	operator/ (const long 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< long double >::Add	operator+ (const Row< N, E, S > &l, const long double &r)
template<int N, class E , int S>
Row< N, E, S >::template Result< long double >::Add	operator+ (const long 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< long double >::Sub	operator- (const Row< N, E, S > &l, const long double &r)
template<int N, class E , int S>
CNT< long double >::template Result< Row< N, E, S > >::Sub	operator- (const long 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)
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 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<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<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 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.
template<class E , int S>
Mat< 3, 3, E >	crossMat (const Vec< 3, negator< E >, S > &v)
	Specialize crossMat() for negated scalar types.
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.
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.
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).
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.
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.
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.
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) = (vw)v.
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>
const E &	det (const Mat< 1, 1, E, CS, RS > &m)
	Special case 1x1 determinant. No computation.
template<class E , int CS, int RS>
E	det (const Mat< 2, 2, E, CS, RS > &m)
	Special case 2x2 determinant. 3 flops.
template<class E , int CS, int RS>
E	det (const Mat< 3, 3, E, CS, RS > &m)
	Special case 3x3 determinant. 14 flops.
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.
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.
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.
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 inverse: costs one divide.
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 inverse: costs one divide plus 9 flops.
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 45 flops (for real-valued matrices).
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.
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)
SpatialVec	operator* (const PhiMatrixTranspose &phiT, const SpatialVec &v)
SpatialMat	operator* (const SpatialMat::THerm &m, const PhiMatrixTranspose &phiT)
bool	operator== (const PhiMatrix &p1, const PhiMatrix &p2)
bool	operator== (const PhiMatrixTranspose &p1, const PhiMatrixTranspose &p2)
std::ostream &	operator<< (std::ostream &o, Stage g)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (SubsystemIndex)
	Provide a unique integer type for identifying Subsystems.
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (SystemYIndex)
	This unique integer type is for indexing the global, System-level "y-like" arrays, that is, the arrays in which all of the various Subsystems' continuous state variables q, u, and z have been collected into contiguous memory.
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (SystemQIndex)
	This unique integer type is for indexing global "q-like" arrays, that is, arrays that inherently have the same dimension as the total number of second order state variables (generalized coordinates) in the full System-level view of the State.
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (QIndex)
	Unique integer type for Subsystem-local q indexing.
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (SystemUIndex)
	This unique integer type is for indexing global "u-like" arrays, that is, arrays that inherently have the same dimension as the total number of mobilities (generalized speeds) in the full System-level view of the State.
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (UIndex)
	Unique integer type for Subsystem-local u indexing.
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (SystemZIndex)
	This unique integer type is for indexing global "z-like" arrays, that is, arrays that inherently have the same dimension as the total number of auxiliary state variables in the full System-level view of the State.
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (ZIndex)
	Unique integer type for Subsystem-local u indexing.
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (DiscreteVariableIndex)
	This unique integer type is for selecting discrete variables.
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (CacheEntryIndex)
	This unique integer type is for selecting non-shared cache entries.
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (SystemYErrIndex)
	This unique integer type is for indexing the global, System-level "yErr-like" arrays, that is, the arrays in which all of the various Subsystems' qErr and uErr constraint equation slots have been collected together.
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (SystemQErrIndex)
	This unique integer type is for indexing global "qErr-like" arrays, that is, arrays that inherently have the same dimension as the total number of position-level constraint equations in the full System-level view of the State.
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (QErrIndex)
	Unique integer type for Subsystem-local qErr indexing.
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (SystemUErrIndex)
	This unique integer type is for indexing global "uErr-like" arrays, that is, arrays that inherently have the same dimension as the total number of velocity-level constraint equations in the full System-level view of the State.
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (UErrIndex)
	Unique integer type for Subsystem-local uErr indexing.
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (SystemUDotErrIndex)
	This unique integer type is for indexing global "uDotErr-like" arrays, that is, arrays that inherently have the same dimension as the total number of acceleration-level constraint equations in the full System-level view of the State.
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (UDotErrIndex)
	Unique integer type for Subsystem-local uDotErr indexing.
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (SystemMultiplierIndex)
	This unique integer type is for indexing global "multiplier-like" arrays, that is, arrays that inherently have the same dimension as the total number of Lagrange multipliers in the full System-level view of the State.
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (MultiplierIndex)
	Unique integer type for Subsystem-local multiplier indexing.
std::ostream &	operator<< (std::ostream &o, const State &s)
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>
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< long double >::Mul	operator* (const SymMat< M, E, S > &l, const long double &r)
template<int M, class E , int S>
SymMat< M, E, S >::template Result< long double >::Mul	operator* (const long 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< long double >::Dvd	operator/ (const SymMat< M, E, S > &l, const long double &r)
template<int M, class E , int S>
CNT< long double >::template Result< SymMat< M, E, S > >::Dvd	operator/ (const long 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< long double >::Add	operator+ (const SymMat< M, E, S > &l, const long double &r)
template<int M, class E , int S>
SymMat< M, E, S >::template Result< long double >::Add	operator+ (const long 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< long double >::Sub	operator- (const SymMat< M, E, S > &l, const long double &r)
template<int M, class E , int S>
CNT< long double >::template Result< SymMat< M, E, S > >::Sub	operator- (const long 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)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (EventId)
	This is a class to represent unique IDs for events in a type-safe way.
Vec3	operator* (const Transform &X_BF, const Vec3 &s_F)
	If we multiply a transform by a 3-vector, we treat it as though it had a 4th element "1" appended, that is, it is treated as a *station* rather than a *vector*.
Vec3	operator* (const InverseTransform &X_BF, const Vec3 &s_F)
Transform	operator* (const Transform &X1, const Transform &X2)
Transform	operator* (const Transform &X1, const InverseTransform &X2)
Transform	operator* (const InverseTransform &X1, const Transform &X2)
Transform	operator* (const InverseTransform &X1, const InverseTransform &X2)
bool	operator== (const Transform &X1, const Transform &X2)
bool	operator== (const InverseTransform &X1, const InverseTransform &X2)
bool	operator== (const Transform &X1, const InverseTransform &X2)
bool	operator== (const InverseTransform &X1, const Transform &X2)
std::ostream &	operator<< (std::ostream &o, const Transform &)
std::ostream &	operator<< (std::ostream &o, const AbstractValue &v)
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
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
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
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
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
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
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
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
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.
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.
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).
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.
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< long double >::Mul	operator* (const Vec< M, E, S > &l, const long double &r)
template<int M, class E , int S>
Vec< M, E, S >::template Result< long double >::Mul	operator* (const long 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< long double >::Dvd	operator/ (const Vec< M, E, S > &l, const long double &r)
template<int M, class E , int S>
CNT< long double >::template Result< Vec< M, E, S > >::Dvd	operator/ (const long 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< long double >::Add	operator+ (const Vec< M, E, S > &l, const long double &r)
template<int M, class E , int S>
Vec< M, E, S >::template Result< long double >::Add	operator+ (const long 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< long double >::Sub	operator- (const Vec< M, E, S > &l, const long double &r)
template<int M, class E , int S>
CNT< long double >::template Result< Vec< M, E, S > >::Sub	operator- (const long 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)
template<class ELEM >
VectorBase< typename CNT< ELEM > ::TAbs >	abs (const VectorBase< ELEM > v)
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 (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 (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 (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)
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)
bool	signBit (unsigned long long)
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 long double &x)
int	sign (const negator< float > &x)
int	sign (const negator< double > &x)
int	sign (const negator< long 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)
char	square (char c)
signed char	square (signed char i)
short	square (short i)
int	square (int i)
long	square (long i)
float	square (const float &x)
double	square (const double &x)
long double	square (const long double &x)
float	square (const negator< float > &x)
double	square (const negator< double > &x)
long double	square (const negator< long 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)
char	cube (char c)
signed char	cube (signed char i)
short	cube (short i)
int	cube (int i)
long	cube (long i)
float	cube (const float &x)
double	cube (const double &x)
long double	cube (const long double &x)
negator< float >	cube (const negator< float > &x)
negator< double >	cube (const negator< double > &x)
negator< long double >	cube (const negator< long 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)
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)
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)
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)
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)
template<class E >
Vector_< E >	operator* (const Transform &X, const VectorBase< E > &v)
	Multiplying a matrix or vector by a Transform applies it to each element individually.
template<class E >
Vector_< E >	operator* (const VectorBase< E > &v, const Transform &X)
	Multiplying a matrix or vector by a Transform applies it to each element individually.
template<class E >
RowVector_< E >	operator* (const Transform &X, const RowVectorBase< E > &v)
	Multiplying a matrix or vector by a Transform applies it to each element individually.
template<class E >
RowVector_< E >	operator* (const RowVectorBase< E > &v, const Transform &X)
	Multiplying a matrix or vector by a Transform applies it to each element individually.
template<class E >
Matrix_< E >	operator* (const Transform &X, const MatrixBase< E > &v)
	Multiplying a matrix or vector by a Transform applies it to each element individually.
template<class E >
Matrix_< E >	operator* (const MatrixBase< E > &v, const Transform &X)
	Multiplying a matrix or vector by a Transform applies it to each element individually.
template<int N, class E >
Vec< N, E >	operator* (const Transform &X, const Vec< N, E > &v)
	Multiplying a matrix or vector by a Transform applies it to each element individually.
template<int N, class E >
Vec< N, E >	operator* (const Vec< N, E > &v, const Transform &X)
	Multiplying a matrix or vector by a Transform applies it to each element individually.
template<int N, class E >
Row< N, E >	operator* (const Transform &X, const Row< N, E > &v)
	Multiplying a matrix or vector by a Transform applies it to each element individually.
template<int N, class E >
Row< N, E >	operator* (const Row< N, E > &v, const Transform &X)
	Multiplying a matrix or vector by a Transform applies it to each element individually.
template<int M, int N, class E >
Mat< M, N, E >	operator* (const Transform &X, const Mat< M, N, E > &v)
	Multiplying a matrix or vector by a Transform applies it to each element individually.
template<int M, int N, class E >
Mat< M, N, E >	operator* (const Mat< M, N, E > &v, const Transform &X)
	Multiplying a matrix or vector by a Transform applies it to each element individually.

---

Detailed Description

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

This file defines a large number of standard math functions that can be applied to vectors and matrices (both the large matrix and small matrix classes).

This template defines a standard interface for objects that calculate a function based on a System and State.

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.

---

Typedef Documentation

typedef Real Angle

angle in radians

typedef Real CircleAngle

typedef Matrix_<Complex> ComplexMatrix

typedef MatrixView_<Complex> ComplexMatrixView

typedef RowVector_<Complex> ComplexRowVector

typedef RowVectorView_<Complex> ComplexRowVectorView

typedef Vector_<Complex> ComplexVector

typedef VectorView_<Complex> ComplexVectorView

typedef conjugate<Real> Conjugate

typedef ForceSubsystem::Guts ForceSubsystemRep

typedef Function_<Real> Function

typedef Real LineAngle

typedef Mat<1,1> Mat11

typedef Mat<1,2> Mat12

typedef Mat<1,3> Mat13

typedef Mat<1,4> Mat14

typedef Mat<1,5> Mat15

typedef Mat<1,6> Mat16

typedef Mat<1,7> Mat17

typedef Mat<1,8> Mat18

typedef Mat<1,9> Mat19

typedef Mat<2,1> Mat21

typedef Mat<2,2> Mat22

typedef Mat<2,3> Mat23

typedef Mat<2,4> Mat24

typedef Mat<2,5> Mat25

typedef Mat<2,6> Mat26

typedef Mat<2,7> Mat27

typedef Mat<2,8> Mat28

typedef Mat<2,9> Mat29

typedef Mat<3,1> Mat31

typedef Mat<3,2> Mat32

typedef Mat<3,3> Mat33

typedef Mat<3,4> Mat34

typedef Mat<3,5> Mat35

typedef Mat<3,6> Mat36

typedef Mat<3,7> Mat37

typedef Mat<3,8> Mat38

typedef Mat<3,9> Mat39

typedef Mat<4,1> Mat41

typedef Mat<4,2> Mat42

typedef Mat<4,3> Mat43

typedef Mat<4,4> Mat44

typedef Mat<4,5> Mat45

typedef Mat<4,6> Mat46

typedef Mat<4,7> Mat47

typedef Mat<4,8> Mat48

typedef Mat<4,9> Mat49

typedef Mat<5,1> Mat51

typedef Mat<5,2> Mat52

typedef Mat<5,3> Mat53

typedef Mat<5,4> Mat54

typedef Mat<5,5> Mat55

typedef Mat<5,6> Mat56

typedef Mat<5,7> Mat57

typedef Mat<5,8> Mat58

typedef Mat<5,9> Mat59

typedef Mat<6,1> Mat61

typedef Mat<6,2> Mat62

typedef Mat<6,3> Mat63

typedef Mat<6,4> Mat64

typedef Mat<6,5> Mat65

typedef Mat<6,6> Mat66

typedef Mat<6,7> Mat67

typedef Mat<6,8> Mat68

typedef Mat<6,9> Mat69

typedef Mat<7,1> Mat71

typedef Mat<7,2> Mat72

typedef Mat<7,3> Mat73

typedef Mat<7,4> Mat74

typedef Mat<7,5> Mat75

typedef Mat<7,6> Mat76

typedef Mat<7,7> Mat77

typedef Mat<7,8> Mat78

typedef Mat<7,9> Mat79

typedef Mat<8,1> Mat81

typedef Mat<8,2> Mat82

typedef Mat<8,3> Mat83

typedef Mat<8,4> Mat84

typedef Mat<8,5> Mat85

typedef Mat<8,6> Mat86

typedef Mat<8,7> Mat87

typedef Mat<8,8> Mat88

typedef Mat<8,9> Mat89

typedef Mat<9,1> Mat91

typedef Mat<9,2> Mat92

typedef Mat<9,3> Mat93

typedef Mat<9,4> Mat94

typedef Mat<9,5> Mat95

typedef Mat<9,6> Mat96

typedef Mat<9,7> Mat97

typedef Mat<9,8> Mat98

typedef Mat<9,9> Mat99

typedef Matrix_<Real> Matrix

typedef MatrixView_<Real> MatrixView

typedef Row<1> Row1

typedef Row<2> Row2

typedef Row<3> Row3

typedef Row<4> Row4

typedef Row<5> Row5

typedef Row<6> Row6

typedef Row<7> Row7

typedef Row<8> Row8

typedef Row<9> Row9

typedef RowVector_<Real> RowVector

typedef RowVectorView_<Real> RowVectorView

typedef Mat< 2, 2, Mat33 > SpatialMat

typedef Row< 2, Row3 > SpatialRow

typedef Vec< 2, Vec3 > SpatialVec

typedef Spline_<Real> Spline

typedef int StageVersion

This is the type to use for Stage version numbers.

Whenever any state variable is modified, we increment the stage version for the stage(s) that depend on it. -1 means "unintialized". 0 is never used as a stage version, but is allowed as a cache value which is guaranteed never to look valid.

typedef SymMat<1> SymMat11

typedef SymMat<2> SymMat22

typedef SymMat<3> SymMat33

typedef SymMat<4> SymMat44

typedef SymMat<5> SymMat55

typedef SymMat<6> SymMat66

typedef SymMat<7> SymMat77

typedef SymMat<8> SymMat88

typedef SymMat<9> SymMat99

typedef UnitVec<1> UnitVec3

typedef Vec<1> Vec1

typedef Vec<2> Vec2

typedef Vec<3> Vec3

typedef Vec<4> Vec4

typedef Vec<5> Vec5

typedef Vec<6> Vec6

typedef Vec<7> Vec7

typedef Vec<8> Vec8

typedef Vec<9> Vec9

typedef Vector_<Real> Vector

typedef VectorView_<Real> VectorView

typedef Real WindingAngle

---

Enumeration Type Documentation

anonymous enum

Enumerator:

SCALAR_DEPTH
SCALAR_COMPOSITE_DEPTH
COMPOSITE_COMPOSITE_DEPTH
COMPOSITE_3_DEPTH
MAX_RESOLVED_DEPTH

enum BodyOrSpaceType

Enumerator:

BodyRotationSequence
SpaceRotationSequence

enum OptimizerAlgorithm

Enumerator:

BestAvailiable
InteriorPoint
LBFGS
LBFGSB
CFSQP

---

Function Documentation

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

(

const SymMat< N, ELEM >

v

)

[inline]

References SymMat< M, ELT, RS >::abs().

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

(

const Mat< M, N, ELEM >

v

)

[inline]

References Mat< M, N, ELT, CS, RS >::abs().

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

(

const Row< N, ELEM >

v

)

[inline]

References Row< N, ELT, STRIDE >::abs().

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

(

const Vec< N, ELEM >

v

)

[inline]

References Vec< M, ELT, STRIDE >::abs().

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

(

const MatrixBase< ELEM >

v

)

[inline]

References MatrixBase< ELT >::abs().

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

(

const RowVectorBase< ELEM >

v

)

[inline]

References RowVectorBase< ELT >::abs().

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

(

const VectorBase< ELEM >

v

)

[inline]

References VectorBase< ELT >::abs().

long double SimTK::abs

(

const conjugate< long double > &

c

)

[inline]

References abs(), and conjugate< long double >::conj().

double SimTK::abs

(

const conjugate< double > &

c

)

[inline]

References abs(), and conjugate< double >::conj().

float SimTK::abs

(

const conjugate< float > &

c

)

[inline]

References conjugate< float >::conj().

Referenced by Vec< 3, Real, S >::abs(), Row< 3, Real, S >::abs(), NTraits< conjugate< R > >::abs(), NTraits< complex< R > >::abs(), negator< NUMBER >::abs(), abs(), System::calcWeightedInfinityNorm(), isNumericallyEqual(), NTraits< conjugate< R > >::normalize(), NTraits< complex< R > >::normalize(), Test::numericallyEqual(), and Kabsch78::superpose().

Angle SimTK::calcDihedralAngle	(	const UnitVec3 &	bond12,
		const UnitVec3 &	bond23,
		const UnitVec3 &	bond34
	)

Dihedral angle in radians in the range (-Pi, Pi].

Angle SimTK::calcDihedralAngle	(	const Vec3 &	atomPos1,
		const Vec3 &	atomPos2,
		const Vec3 &	atomPos3,
		const Vec3 &	atomPos4
	)

Dihedral angle in radians in the range (-Pi, Pi].

const complex<long double>& SimTK::conj

(

const conjugate< long double > &

c

)

[inline]

References conjugate< long double >::conj().

const complex<double>& SimTK::conj

(

const conjugate< double > &

c

)

[inline]

References conjugate< double >::conj().

const complex<float>& SimTK::conj

(

const conjugate< float > &

c

)

[inline]

References conjugate< float >::conj().

Referenced by operator/(), conjugate< float >::operator/=(), conjugate< double >::operator/=(), and conjugate< long double >::operator/=().

bool SimTK::contains	(	const ListView< T > &	lv,
		const T &	test
	)			[inline]

References contains().

bool SimTK::contains	(	const List< T > &	l,
		const T &	test
	)			[inline]

If the type T supports an "==" operator, you can instantiate this method to find out if an List<T> contains a particular test element.

References findFirstOf().

bool SimTK::contains	(	const ArrayView< T > &	a,
		const T &	test
	)			[inline]

References findFirstOf().

bool SimTK::contains	(	const Array< T > &	a,
		const T &	test
	)			[inline]

If the type T supports an "==" operator, you can instantiate this method to find out if an Array<T> contains a particular test element.

References findFirstOf().

Referenced by contains().

CNT<E1>::template Result<E2>::Mul SimTK::cross	(	const Row< 2, E1, S1 > &	a,
		const Row< 2, E2, S2 > &	b
	)			[inline]

CNT<E1>::template Result<E2>::Mul SimTK::cross	(	const Vec< 2, E1, S1 > &	a,
		const Row< 2, E2, S2 > &	b
	)			[inline]

CNT<E1>::template Result<E2>::Mul SimTK::cross	(	const Row< 2, E1, S1 > &	a,
		const Vec< 2, E2, S2 > &	b
	)			[inline]

CNT<E1>::template Result<E2>::Mul SimTK::cross	(	const Vec< 2, E1, S1 > &	a,
		const Vec< 2, E2, S2 > &	b
	)			[inline]

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]

References cross(), and Row< N, ELT, STRIDE >::positionalTranspose().

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]

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]

References cross(), and Row< N, ELT, STRIDE >::positionalTranspose().

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]

Row<3,typename CNT<E1>::template Result<E2>::Mul> SimTK::cross	(	const Row< 3, E1, S1 > &	a,
		const Row< 3, E2, S2 > &	b
	)			[inline]

Row<3,typename CNT<E1>::template Result<E2>::Mul> SimTK::cross	(	const Row< 3, E1, S1 > &	a,
		const Vec< 3, E2, S2 > &	b
	)			[inline]

Row<3,typename CNT<E1>::template Result<E2>::Mul> SimTK::cross	(	const Vec< 3, E1, S1 > &	a,
		const Row< 3, E2, S2 > &	b
	)			[inline]

Vec<3,typename CNT<E1>::template Result<E2>::Mul> SimTK::cross	(	const Vec< 3, E1, S1 > &	a,
		const Vec< 3, E2, S2 > &	b
	)			[inline]

Referenced by cross(), operator%(), and Kabsch78::superpose().

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.

References crossMat().

Row<2,E> SimTK::crossMat

(

const Row< 2, E, S > &

r

)

[inline]

Form 2D cross product matrix from a Row<2>; 1 flop.

References crossMat(), and Row< N, ELT, STRIDE >::positionalTranspose().

Row<2,E> SimTK::crossMat

(

const Vec< 2, negator< E >, S > &

v

)

[inline]

Specialize 2D cross product matrix for negated scalar types; 1 flop.

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.

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.

References crossMat().

Mat<3,3,E> SimTK::crossMat

(

const Row< 3, E, S > &

r

)

[inline]

Form cross product matrix from a Row vector; 3 flops.

References crossMat(), and Row< N, ELT, STRIDE >::positionalTranspose().

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.

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.

Referenced by crossMat(), operator*(), MassProperties::toMat66(), PhiMatrixTranspose::toSpatialMat(), PhiMatrix::toSpatialMat(), and MassProperties::toSpatialMat().

SymMat<3,E> SimTK::crossMatSq

(

const Row< 3, negator< E >, S > &

r

)

[inline]

References crossMatSq().

SymMat<3,E> SimTK::crossMatSq

(

const Row< 3, E, S > &

r

)

[inline]

References crossMatSq(), and Row< N, ELT, STRIDE >::positionalTranspose().

SymMat<3,E> SimTK::crossMatSq

(

const Vec< 3, negator< E >, S > &

v

)

[inline]

References square().

SymMat<3,E> SimTK::crossMatSq

(

const Vec< 3, E, S > &

v

)

[inline]

Calculate matrix S(v) such that S(v)*w = -v % (v % w) = (vw)v.

S is a symmetric, 3x3 matrix with nonnegative diagonals. 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. This requires 11 flops to form. We produce the same S(v) regardless of whether v is a column or row. Note that there is no 2D equivalent of this operator.

References square().

Referenced by crossMatSq().

PointeeType* SimTK::deepCopy

(

const PointeeType *

ptr

)

[inline]

References deepCopy().

PointeeType* SimTK::deepCopy	(	const PointeeType *	ptr,
		const Clonable *
	)			[inline]

PointeeType* SimTK::deepCopy	(	const PointeeType *	ptr,
		const void *
	)			[inline]

Referenced by deepCopy().

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.

References det(), and sign().

E SimTK::det

(

const Mat< 3, 3, E, CS, RS > &

m

)

[inline]

Special case 3x3 determinant. 14 flops.

E SimTK::det

(

const Mat< 2, 2, E, CS, RS > &

m

)

[inline]

Special case 2x2 determinant. 3 flops.

const E& SimTK::det

(

const Mat< 1, 1, E, CS, RS > &

m

)

[inline]

Special case 1x1 determinant. No computation.

Referenced by det(), and inverse().

CNT<E1>::template Result<E2>::Mul SimTK::dot	(	const Row< N, E1, S1 > &	r,
		const Row< N, E2, S2 > &	s
	)			[inline]

References dot(), and Row< N, ELT, STRIDE >::positionalTranspose().

CNT<E1>::template Result<E2>::Mul SimTK::dot	(	const Vec< M, E1, S1 > &	v,
		const Row< M, E2, S2 > &	r
	)			[inline]

References dot(), and Row< N, ELT, STRIDE >::positionalTranspose().

CNT<E1>::template Result<E2>::Mul SimTK::dot	(	const Row< N, E1, S1 > &	r,
		const Vec< N, E2, S2 > &	v
	)			[inline]

References dot(), and Row< N, ELT, STRIDE >::positionalTranspose().

CNT<typename CNT<E1>::THerm>::template Result<E2>::Mul SimTK::dot	(	const Vec< 1, E1, S1 > &	r,
		const Vec< 1, E2, S2 > &	v
	)			[inline]

References sum().

CNT<typename CNT<E1>::THerm>::template Result<E2>::Mul SimTK::dot	(	const Vec< M, E1, S1 > &	r,
		const Vec< M, E2, S2 > &	v
	)			[inline]

References sum().

Referenced by MobilizedBody::calcStationToStationDistance2ndTimeDerivative(), MobilizedBody::calcStationToStationDistanceTimeDerivative(), dot(), VoxelHash< AtomSubsystem::AtomIndex >::findNeighbors(), QuadrivalentAtom::QuadrivalentAtom(), and Kabsch78::superpose().

Array<int> SimTK::findAllOf	(	const ListView< T > &	lv,
		const T &	test
	)			[inline]

References findAllOf().

Array<int> SimTK::findAllOf	(	const List< T > &	l,
		const T &	test
	)			[inline]

If the type T supports an "==" operator, you can instantiate this method to find the indices of all elements of an List<T> at which the elements match the supplied test element.

The returned index list will have length 0 if there are no matches.

References ArrayBase< T >::push_back(), and ArrayBase< Concretize< T > >::size().

Array<int> SimTK::findAllOf	(	const ArrayView< T > &	a,
		const T &	test
	)			[inline]

References findAllOf().

Array<int> SimTK::findAllOf	(	const Array< T > &	a,
		const T &	test
	)			[inline]

If the type T supports an "==" operator, you can instantiate this method to find the indices of all elements of an Array<T> at which the elements match the supplied test element.

The returned index list will have length 0 if there are no matches.

References ArrayBase< T >::push_back(), and ArrayBase< T >::size().

Referenced by findAllOf().

int SimTK::findFirstOf	(	const ListView< T > &	lv,
		const T &	test
	)			[inline]

References findFirstOf().

int SimTK::findFirstOf	(	const List< T > &	l,
		const T &	test
	)			[inline]

If the type T supports an "==" operator, you can instantiate this method to find the first element of an List<T> which matches the supplied test element.

The index is returned if found, otherwise -1.

References ArrayBase< Concretize< T > >::size().

int SimTK::findFirstOf	(	const ArrayView< T > &	a,
		const T &	test
	)			[inline]

References findFirstOf().

int SimTK::findFirstOf	(	const Array< T > &	a,
		const T &	test
	)			[inline]

If the type T supports an "==" operator, you can instantiate this method to find the first element of an Array<T> which matches the supplied test element.

The index is returned if found, otherwise -1.

References ArrayBase< T >::size().

Referenced by contains(), and findFirstOf().

const negator<long double>& SimTK::imag

(

const conjugate< long double > &

c

)

[inline]

References conjugate< long double >::imag().

const negator<double>& SimTK::imag

(

const conjugate< double > &

c

)

[inline]

References conjugate< double >::imag().

const negator<float>& SimTK::imag

(

const conjugate< float > &

c

)

[inline]

References conjugate< float >::imag().

Referenced by cube(), and negator< NUMBER >::imag().

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()

References lapackInverse().

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 45 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()

Mat<2,2,E,CS,RS>::TInvert SimTK::inverse

(

const Mat< 2, 2, E, CS, RS > &

m

)

[inline]

Specialized 2x2 inverse: costs one divide plus 9 flops.

References det().

Mat<1,1,E,CS,RS>::TInvert SimTK::inverse

(

const Mat< 1, 1, E, CS, RS > &

m

)

[inline]

Specialized 1x1 inverse: costs one divide.

Referenced by Mat< M, N, ELT, CS, RS >::invert().

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()

References SimTK_ASSERT1, and SimTK_ERRCHK1_ALWAYS.

Mat<1,1,E,CS,RS>::TInvert SimTK::lapackInverse

(

const Mat< 1, 1, E, CS, RS > &

m

)

[inline]

Specialized 1x1 lapackInverse(): costs one divide.

Referenced by inverse().

Row<N, ELEM> SimTK::max

(

const SymMat< N, ELEM >

v

)

[inline]

References SymMat< M, ELT, RS >::getDiag(), and SymMat< M, ELT, RS >::getEltLower().

Row<N, ELEM> SimTK::max

(

const Mat< M, N, ELEM >

v

)

[inline]

References max().

ELEM SimTK::max

(

const Row< N, ELEM >

v

)

[inline]

References max().

ELEM SimTK::max

(

Vec< N, ELEM >

v

)

[inline]

References max().

RowVectorBase<ELEM> SimTK::max

(

const MatrixBase< ELEM >

v

)

[inline]

References max(), and MatrixBase< ELT >::ncol().

ELEM SimTK::max

(

const RowVectorBase< ELEM >

v

)

[inline]

References max(), and RowVectorBase< ELT >::size().

ELEM SimTK::max

(

const VectorBase< ELEM >

v

)

[inline]

References VectorBase< ELT >::size().

Referenced by Test::defTol2(), Spline_< T >::getMaxDerivativeOrder(), Polynomial::getMaxDerivativeOrder(), Linear::getMaxDerivativeOrder(), Constant::getMaxDerivativeOrder(), Vec< 3, Real, S >::isNumericallyEqual(), Row< 3, Real, S >::isNumericallyEqual(), isNumericallyEqual(), max(), Test::numericallyEqual(), RowVectorBase< ELT >::size(), and VectorBase< Real >::size().

Row<N, ELEM> SimTK::mean

(

const SymMat< N, ELEM >

v

)

[inline]

References sum().

Row<N, ELEM> SimTK::mean

(

const Mat< M, N, ELEM >

v

)

[inline]

References sum().

ELEM SimTK::mean

(

const Row< N, ELEM >

v

)

[inline]

References sum().

ELEM SimTK::mean

(

const Vec< N, ELEM >

v

)

[inline]

References sum().

RowVectorBase<ELEM> SimTK::mean

(

const MatrixBase< ELEM >

v

)

[inline]

References MatrixBase< ELT >::nrow(), and sum().

ELEM SimTK::mean

(

const RowVectorBase< ELEM >

v

)

[inline]

References RowVectorBase< ELT >::size(), and sum().

ELEM SimTK::mean

(

const VectorBase< ELEM >

v

)

[inline]

References VectorBase< ELT >::size(), and sum().

Row<N, ELEM> SimTK::median

(

const SymMat< N, ELEM >

v

)

[inline]

References median().

Row<N, ELEM> SimTK::median

(

const Mat< M, N, ELEM >

v

)

[inline]

References median().

ELEM SimTK::median

(

Row< N, ELEM >

v

)

[inline]

ELEM SimTK::median

(

Vec< N, ELEM >

v

)

[inline]

RowVectorBase<ELEM> SimTK::median

(

const MatrixBase< ELEM >

v

)

[inline]

References MatrixBase< ELT >::col(), MatrixBase< ELT >::ncol(), and MatrixBase< ELT >::nrow().

ELEM SimTK::median

(

const RowVectorBase< ELEM >

v

)

[inline]

References RowVectorBase< ELT >::begin(), and RowVectorBase< ELT >::end().

ELEM SimTK::median

(

const VectorBase< ELEM >

v

)

[inline]

References VectorBase< ELT >::begin(), and VectorBase< ELT >::end().

ELEM SimTK::median	(	RandomAccessIterator	start,
		RandomAccessIterator	end
	)			[inline]

References min().

Referenced by median().

Row<N, ELEM> SimTK::min

(

SymMat< N, ELEM >

v

)

[inline]

References SymMat< M, ELT, RS >::getDiag(), and SymMat< M, ELT, RS >::getEltLower().

Row<N, ELEM> SimTK::min

(

const Mat< M, N, ELEM >

v

)

[inline]

References min().

ELEM SimTK::min

(

Row< N, ELEM >

v

)

[inline]

References min().

ELEM SimTK::min

(

const Vec< N, ELEM >

v

)

[inline]

References min().

RowVectorBase<ELEM> SimTK::min

(

const MatrixBase< ELEM >

v

)

[inline]

References min(), and MatrixBase< ELT >::ncol().

ELEM SimTK::min

(

const RowVectorBase< ELEM >

v

)

[inline]

References min(), and RowVectorBase< ELT >::size().

ELEM SimTK::min

(

const VectorBase< ELEM >

v

)

[inline]

References VectorBase< ELT >::size().

Referenced by median(), and min().

long double SimTK::norm

(

const conjugate< long double > &

c

)

[inline]

References conjugate< long double >::conj(), and norm().

double SimTK::norm

(

const conjugate< double > &

c

)

[inline]

References conjugate< double >::conj(), and norm().

float SimTK::norm

(

const conjugate< float > &

c

)

[inline]

References conjugate< float >::conj().

Referenced by MassCenterMotionRemover::calcMassCenterError(), and norm().

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

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

bool SimTK::operator!=	(	const SymMat< M, E1, S1 > &	l,
		const SymMat< M, E2, S2 > &	r
	)			[inline]

bool SimTK::operator!=	(	const Row< N, E1, S1 > &	l,
		const Row< N, E2, S2 > &	r
	)			[inline]

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

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

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

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

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

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

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

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

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

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

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

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

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

CNT<E1>::template Result<E2>::Mul SimTK::operator%	(	const Row< 2, E1, S1 > &	a,
		const Row< 2, E2, S2 > &	b
	)			[inline]

References cross().

CNT<E1>::template Result<E2>::Mul SimTK::operator%	(	const Vec< 2, E1, S1 > &	a,
		const Row< 2, E2, S2 > &	b
	)			[inline]

References cross().

CNT<E1>::template Result<E2>::Mul SimTK::operator%	(	const Row< 2, E1, S1 > &	a,
		const Vec< 2, E2, S2 > &	b
	)			[inline]

References cross().

CNT<E1>::template Result<E2>::Mul SimTK::operator%	(	const Vec< 2, E1, S1 > &	a,
		const Vec< 2, E2, S2 > &	b
	)			[inline]

References cross().

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]

References cross().

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]

References cross().

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]

References cross().

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]

References cross().

Row<3,typename CNT<E1>::template Result<E2>::Mul> SimTK::operator%	(	const Row< 3, E1, S1 > &	a,
		const Row< 3, E2, S2 > &	b
	)			[inline]

References cross().

Row<3,typename CNT<E1>::template Result<E2>::Mul> SimTK::operator%	(	const Row< 3, E1, S1 > &	a,
		const Vec< 3, E2, S2 > &	b
	)			[inline]

References cross().

Row<3,typename CNT<E1>::template Result<E2>::Mul> SimTK::operator%	(	const Vec< 3, E1, S1 > &	a,
		const Row< 3, E2, S2 > &	b
	)			[inline]

References cross().

Vec<3,typename CNT<E1>::template Result<E2>::Mul> SimTK::operator%	(	const Vec< 3, E1, S1 > &	a,
		const Vec< 3, E2, S2 > &	b
	)			[inline]

References cross().

Vec<M,E,S>::template Result<typename negator<R>::StdNumber>::Mul SimTK::operator*	(	const negator< R > &	l,
		const Vec< M, E, S > &	r
	)			[inline]

Vec<M,E,S>::template Result<typename negator<R>::StdNumber>::Mul SimTK::operator*	(	const Vec< M, E, S > &	l,
		const negator< R > &	r
	)			[inline]

Vec<M,E,S>::template Result<std::complex<R> >::Mul SimTK::operator*	(	const conjugate< R > &	l,
		const Vec< M, E, S > &	r
	)			[inline]

Vec<M,E,S>::template Result<std::complex<R> >::Mul SimTK::operator*	(	const Vec< M, E, S > &	l,
		const conjugate< R > &	r
	)			[inline]

Vec<M,E,S>::template Result<std::complex<R> >::Mul SimTK::operator*	(	const std::complex< R > &	l,
		const Vec< M, E, S > &	r
	)			[inline]

Vec<M,E,S>::template Result<std::complex<R> >::Mul SimTK::operator*	(	const Vec< M, E, S > &	l,
		const std::complex< R > &	r
	)			[inline]

Vec<M,E,S>::template Result<typename CNT<E>::Precision>::Mul SimTK::operator*	(	int	l,
		const Vec< M, E, S > &	r
	)			[inline]

Vec<M,E,S>::template Result<typename CNT<E>::Precision>::Mul SimTK::operator*	(	const Vec< M, E, S > &	l,
		int	r
	)			[inline]

Vec<M,E,S>::template Result<long double>::Mul SimTK::operator*	(	const long double &	l,
		const Vec< M, E, S > &	r
	)			[inline]

Vec<M,E,S>::template Result<long double>::Mul SimTK::operator*	(	const Vec< M, E, S > &	l,
		const long double &	r
	)			[inline]

Vec<M,E,S>::template Result<double>::Mul SimTK::operator*	(	const double &	l,
		const Vec< M, E, S > &	r
	)			[inline]

Vec<M,E,S>::template Result<double>::Mul SimTK::operator*	(	const Vec< M, E, S > &	l,
		const double &	r
	)			[inline]

Vec<M,E,S>::template Result<float>::Mul SimTK::operator*	(	const float &	l,
		const Vec< M, E, S > &	r
	)			[inline]

Vec<M,E,S>::template Result<float>::Mul SimTK::operator*	(	const Vec< M, E, S > &	l,
		const float &	r
	)			[inline]

Transform SimTK::operator*	(	const InverseTransform &	X1,
		const InverseTransform &	X2
	)			[inline]

References InverseTransform::compose().

Transform SimTK::operator*	(	const InverseTransform &	X1,
		const Transform &	X2
	)			[inline]

References InverseTransform::compose().

Transform SimTK::operator*	(	const Transform &	X1,
		const InverseTransform &	X2
	)			[inline]

References Transform::compose().

Transform SimTK::operator*	(	const Transform &	X1,
		const Transform &	X2
	)			[inline]

References Transform::compose().

Mat<M,N,E> SimTK::operator*	(	const Mat< M, N, E > &	v,
		const Transform &	X
	)			[inline]

Multiplying a matrix or vector by a Transform applies it to each element individually.

Mat<M,N,E> SimTK::operator*	(	const Transform &	X,
		const Mat< M, N, E > &	v
	)			[inline]

Multiplying a matrix or vector by a Transform applies it to each element individually.

Row<N,E> SimTK::operator*	(	const Row< N, E > &	v,
		const Transform &	X
	)			[inline]

Multiplying a matrix or vector by a Transform applies it to each element individually.

Row<N,E> SimTK::operator*	(	const Transform &	X,
		const Row< N, E > &	v
	)			[inline]

Multiplying a matrix or vector by a Transform applies it to each element individually.

Vec<N,E> SimTK::operator*	(	const Vec< N, E > &	v,
		const Transform &	X
	)			[inline]

Multiplying a matrix or vector by a Transform applies it to each element individually.

Vec<N,E> SimTK::operator*	(	const Transform &	X,
		const Vec< N, E > &	v
	)			[inline]

Multiplying a matrix or vector by a Transform applies it to each element individually.

Matrix_<E> SimTK::operator*	(	const MatrixBase< E > &	v,
		const Transform &	X
	)			[inline]

Multiplying a matrix or vector by a Transform applies it to each element individually.

References MatrixBase< ELT >::ncol(), and MatrixBase< ELT >::nrow().

Matrix_<E> SimTK::operator*	(	const Transform &	X,
		const MatrixBase< E > &	v
	)			[inline]

Multiplying a matrix or vector by a Transform applies it to each element individually.

References MatrixBase< ELT >::ncol(), and MatrixBase< ELT >::nrow().

RowVector_<E> SimTK::operator*	(	const RowVectorBase< E > &	v,
		const Transform &	X
	)			[inline]

Multiplying a matrix or vector by a Transform applies it to each element individually.

References RowVectorBase< ELT >::size().

RowVector_<E> SimTK::operator*	(	const Transform &	X,
		const RowVectorBase< E > &	v
	)			[inline]

Multiplying a matrix or vector by a Transform applies it to each element individually.

References RowVectorBase< ELT >::size().

Vector_<E> SimTK::operator*	(	const VectorBase< E > &	v,
		const Transform &	X
	)			[inline]

Multiplying a matrix or vector by a Transform applies it to each element individually.

References VectorBase< ELT >::size().

Vector_<E> SimTK::operator*	(	const Transform &	X,
		const VectorBase< E > &	v
	)			[inline]

Multiplying a matrix or vector by a Transform applies it to each element individually.

References VectorBase< ELT >::size().

Vec3 SimTK::operator*	(	const InverseTransform &	X_BF,
		const Vec3 &	s_F
	)			[inline]

References Vec< 3 >::getAs(), InverseTransform::shiftFrameStationToBase(), Vec< 3 >::updAs(), and InverseTransform::xformFrameVecToBase().

Vec3 SimTK::operator*	(	const Transform &	X_BF,
		const Vec3 &	s_F
	)			[inline]

If we multiply a transform by a 3-vector, we treat it as though it had a 4th element "1" appended, that is, it is treated as a *station* rather than a *vector*.

If we multiply a transform by an augmented 4-vector, we use the 4th element to decide how to treat it.

The 4th element must be 0 or 1. If 0 it is treated as a vector only and the translation is ignored. If 1 it is treated as a station and rotated & shifted.

References Vec< 3 >::getAs(), Transform::shiftFrameStationToBase(), Vec< 3 >::updAs(), and Transform::xformFrameVecToBase().

SymMat<M,E,S>::template Result<typename negator<R>::StdNumber>::Mul SimTK::operator*	(	const negator< R > &	l,
		const SymMat< M, E, S > &	r
	)			[inline]

SymMat<M,E,S>::template Result<typename negator<R>::StdNumber>::Mul SimTK::operator*	(	const SymMat< M, E, S > &	l,
		const negator< R > &	r
	)			[inline]

SymMat<M,E,S>::template Result<std::complex<R> >::Mul SimTK::operator*	(	const conjugate< R > &	l,
		const SymMat< M, E, S > &	r
	)			[inline]

SymMat<M,E,S>::template Result<std::complex<R> >::Mul SimTK::operator*	(	const SymMat< M, E, S > &	l,
		const conjugate< R > &	r
	)			[inline]

SymMat<M,E,S>::template Result<std::complex<R> >::Mul SimTK::operator*	(	const std::complex< R > &	l,
		const SymMat< M, E, S > &	r
	)			[inline]

SymMat<M,E,S>::template Result<std::complex<R> >::Mul SimTK::operator*	(	const SymMat< M, E, S > &	l,
		const std::complex< R > &	r
	)			[inline]

SymMat<M,E,S>::template Result<typename CNT<E>::Precision>::Mul SimTK::operator*	(	int	l,
		const SymMat< M, E, S > &	r
	)			[inline]

SymMat<M,E,S>::template Result<typename CNT<E>::Precision>::Mul SimTK::operator*	(	const SymMat< M, E, S > &	l,
		int	r
	)			[inline]

SymMat<M,E,S>::template Result<long double>::Mul SimTK::operator*	(	const long double &	l,
		const SymMat< M, E, S > &	r
	)			[inline]

SymMat<M,E,S>::template Result<long double>::Mul SimTK::operator*	(	const SymMat< M, E, S > &	l,
		const long double &	r
	)			[inline]

SymMat<M,E,S>::template Result<double>::Mul SimTK::operator*	(	const double &	l,
		const SymMat< M, E, S > &	r
	)			[inline]

SymMat<M,E,S>::template Result<double>::Mul SimTK::operator*	(	const SymMat< M, E, S > &	l,
		const double &	r
	)			[inline]

SymMat<M,E,S>::template Result<float>::Mul SimTK::operator*	(	const float &	l,
		const SymMat< M, E, S > &	r
	)			[inline]

SymMat<M,E,S>::template Result<float>::Mul SimTK::operator*	(	const SymMat< M, E, S > &	l,
		const float &	r
	)			[inline]

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

References crossMat(), and PhiMatrixTranspose::l().

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

References PhiMatrixTranspose::l().

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

References crossMat(), and PhiMatrix::l().

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

References PhiMatrix::l().

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]

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]

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]

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]

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]

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]

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]

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]

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]

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]

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]

References SymMat< M, ELT, RS >::getDiag(), SymMat< M, ELT, RS >::getEltLower(), and SymMat< M, ELT, RS >::getEltUpper().

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]

References SymMat< M, ELT, RS >::getDiag(), SymMat< M, ELT, RS >::getEltLower(), and SymMat< M, ELT, RS >::getEltUpper().

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]

References SymMat< M, ELT, RS >::getDiag().

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]

References SymMat< M, ELT, RS >::getDiag(), SymMat< M, ELT, RS >::getEltLower(), and SymMat< M, ELT, RS >::getEltUpper().

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]

References SymMat< M, ELT, RS >::getDiag(), SymMat< M, ELT, RS >::getEltLower(), and SymMat< M, ELT, RS >::getEltUpper().

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]

References SymMat< M, ELT, RS >::getDiag(), SymMat< M, ELT, RS >::getEltLower(), and SymMat< M, ELT, RS >::getEltUpper().

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]

References SymMat< M, ELT, RS >::getDiag().

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]

References SymMat< M, ELT, RS >::getDiag(), SymMat< M, ELT, RS >::getEltLower(), and SymMat< M, ELT, RS >::getEltUpper().

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]

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]

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]

CNT<E1>::template Result<E2>::Mul SimTK::operator*	(	const Row< 1, E1, S1 > &	r,
		const Vec< 1, E2, S2 > &	v
	)			[inline]

References sum().

CNT<E1>::template Result<E2>::Mul SimTK::operator*	(	const Row< N, E1, S1 > &	r,
		const Vec< N, E2, S2 > &	v
	)			[inline]

References sum().

Row<N,E,S>::template Result<typename negator<R>::StdNumber>::Mul SimTK::operator*	(	const negator< R > &	l,
		const Row< N, E, S > &	r
	)			[inline]

Row<N,E,S>::template Result<typename negator<R>::StdNumber>::Mul SimTK::operator*	(	const Row< N, E, S > &	l,
		const negator< R > &	r
	)			[inline]

Row<N,E,S>::template Result<std::complex<R> >::Mul SimTK::operator*	(	const conjugate< R > &	l,
		const Row< N, E, S > &	r
	)			[inline]

Row<N,E,S>::template Result<std::complex<R> >::Mul SimTK::operator*	(	const Row< N, E, S > &	l,
		const conjugate< R > &	r
	)			[inline]

Row<N,E,S>::template Result<std::complex<R> >::Mul SimTK::operator*	(	const std::complex< R > &	l,
		const Row< N, E, S > &	r
	)			[inline]

Row<N,E,S>::template Result<std::complex<R> >::Mul SimTK::operator*	(	const Row< N, E, S > &	l,
		const std::complex< R > &	r
	)			[inline]

Row<N,E,S>::template Result<typename CNT<E>::Precision>::Mul SimTK::operator*	(	int	l,
		const Row< N, E, S > &	r
	)			[inline]

Row<N,E,S>::template Result<typename CNT<E>::Precision>::Mul SimTK::operator*	(	const Row< N, E, S > &	l,
		int	r
	)			[inline]

Row<N,E,S>::template Result<long double>::Mul SimTK::operator*	(	const long double &	l,
		const Row< N, E, S > &	r
	)			[inline]

Row<N,E,S>::template Result<long double>::Mul SimTK::operator*	(	const Row< N, E, S > &	l,
		const long double &	r
	)			[inline]

Row<N,E,S>::template Result<double>::Mul SimTK::operator*	(	const double &	l,
		const Row< N, E, S > &	r
	)			[inline]

Row<N,E,S>::template Result<double>::Mul SimTK::operator*	(	const Row< N, E, S > &	l,
		const double &	r
	)			[inline]

Row<N,E,S>::template Result<float>::Mul SimTK::operator*	(	const float &	l,
		const Row< N, E, S > &	r
	)			[inline]

Row<N,E,S>::template Result<float>::Mul SimTK::operator*	(	const Row< N, E, S > &	l,
		const float &	r
	)			[inline]

Rotation SimTK::operator*	(	const InverseRotation &	R1,
		const InverseRotation &	R2
	)			[inline]

Rotation SimTK::operator*	(	const InverseRotation &	R1,
		const Rotation &	R2
	)			[inline]

Rotation SimTK::operator*	(	const Rotation &	R1,
		const InverseRotation &	R2
	)			[inline]

Rotation SimTK::operator*	(	const Rotation &	R1,
		const Rotation &	R2
	)			[inline]

UnitRow<1> SimTK::operator*	(	const UnitRow< S > &	r,
		const InverseRotation &	R
	)			[inline]

References InverseRotation::asMat33(), and UnitRow< S >::asRow3().

UnitVec<1> SimTK::operator*	(	const InverseRotation &	R,
		const UnitVec< S > &	v
	)			[inline]

References InverseRotation::asMat33(), and UnitVec< S >::asVec3().

UnitRow<1> SimTK::operator*	(	const UnitRow< S > &	r,
		const Rotation &	R
	)			[inline]

References Rotation::asMat33(), and UnitRow< S >::asRow3().

UnitVec<1> SimTK::operator*	(	const Rotation &	R,
		const UnitVec< S > &	v
	)			[inline]

References Rotation::asMat33(), and UnitVec< S >::asVec3().

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

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

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

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]

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]

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]

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]

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]

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]

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]

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]

Mat<M,N,E,CS,RS>::template Result<long double>::Mul SimTK::operator*	(	const long double &	l,
		const Mat< M, N, E, CS, RS > &	r
	)			[inline]

Mat<M,N,E,CS,RS>::template Result<long double>::Mul SimTK::operator*	(	const Mat< M, N, E, CS, RS > &	l,
		const long double &	r
	)			[inline]

Mat<M,N,E,CS,RS>::template Result<double>::Mul SimTK::operator*	(	const double &	l,
		const Mat< M, N, E, CS, RS > &	r
	)			[inline]

Mat<M,N,E,CS,RS>::template Result<double>::Mul SimTK::operator*	(	const Mat< M, N, E, CS, RS > &	l,
		const double &	r
	)			[inline]

Mat<M,N,E,CS,RS>::template Result<float>::Mul SimTK::operator*	(	const float &	l,
		const Mat< M, N, E, CS, RS > &	r
	)			[inline]

Mat<M,N,E,CS,RS>::template Result<float>::Mul SimTK::operator*	(	const Mat< M, N, E, CS, RS > &	l,
		const float &	r
	)			[inline]

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]

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]

Vec3 SimTK::operator*	(	const Inertia &	i,
		const Vec3 &	w
	)			[inline]

Inertia SimTK::operator*	(	const Real &	r,
		const Inertia &	i
	)			[inline]

Inertia SimTK::operator*	(	const Inertia &	i,
		const Real &	r
	)			[inline]

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

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

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

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

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

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

conjugate<long double> SimTK::operator*	(	const long double &	a,
		const conjugate< R > &	b
	)			[inline]

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

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

conjugate<long double> SimTK::operator*	(	const conjugate< R > &	a,
		const long double &	b
	)			[inline]

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

complex<long double> SimTK::operator*	(	const double &	r,
		const complex< long double > &	c
	)			[inline]

complex<long double> SimTK::operator*	(	const complex< long double > &	c,
		const double &	r
	)			[inline]

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

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

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

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

complex<long double> SimTK::operator*	(	const long double &	r,
		const complex< double > &	c
	)			[inline]

complex<long double> SimTK::operator*	(	const complex< double > &	c,
		const long double &	r
	)			[inline]

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

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

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

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

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

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

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

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

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

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

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

References MatrixBase< ELT >::ncol(), and MatrixBase< ELT >::nrow().

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

References MatrixBase< ELT >::ncol(), MatrixBase< ELT >::nrow(), and VectorBase< ELT >::nrow().

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

References RowVectorBase< ELT >::ncol(), VectorBase< ELT >::nrow(), and sum().

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

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

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

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

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

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

OrientedBoundingBox SimTK::operator*	(	const Transform &	t,
		const OrientedBoundingBox &	box
	)

Vec<M,E,S>::template Result<typename negator<R>::StdNumber>::Add SimTK::operator+	(	const negator< R > &	l,
		const Vec< M, E, S > &	r
	)			[inline]

Vec<M,E,S>::template Result<typename negator<R>::StdNumber>::Add SimTK::operator+	(	const Vec< M, E, S > &	l,
		const negator< R > &	r
	)			[inline]

Vec<M,E,S>::template Result<std::complex<R> >::Add SimTK::operator+	(	const conjugate< R > &	l,
		const Vec< M, E, S > &	r
	)			[inline]

Vec<M,E,S>::template Result<std::complex<R> >::Add SimTK::operator+	(	const Vec< M, E, S > &	l,
		const conjugate< R > &	r
	)			[inline]

Vec<M,E,S>::template Result<std::complex<R> >::Add SimTK::operator+	(	const std::complex< R > &	l,
		const Vec< M, E, S > &	r
	)			[inline]

Vec<M,E,S>::template Result<std::complex<R> >::Add SimTK::operator+	(	const Vec< M, E, S > &	l,
		const std::complex< R > &	r
	)			[inline]

Vec<M,E,S>::template Result<typename CNT<E>::Precision>::Add SimTK::operator+	(	int	l,
		const Vec< M, E, S > &	r
	)			[inline]

Vec<M,E,S>::template Result<typename CNT<E>::Precision>::Add SimTK::operator+	(	const Vec< M, E, S > &	l,
		int	r
	)			[inline]

Vec<M,E,S>::template Result<long double>::Add SimTK::operator+	(	const long double &	l,
		const Vec< M, E, S > &	r
	)			[inline]

Vec<M,E,S>::template Result<long double>::Add SimTK::operator+	(	const Vec< M, E, S > &	l,
		const long double &	r
	)			[inline]

Vec<M,E,S>::template Result<double>::Add SimTK::operator+	(	const double &	l,
		const Vec< M, E, S > &	r
	)			[inline]

Vec<M,E,S>::template Result<double>::Add SimTK::operator+	(	const Vec< M, E, S > &	l,
		const double &	r
	)			[inline]

Vec<M,E,S>::template Result<float>::Add SimTK::operator+	(	const float &	l,
		const Vec< M, E, S > &	r
	)			[inline]

Vec<M,E,S>::template Result<float>::Add SimTK::operator+	(	const Vec< M, E, S > &	l,
		const float &	r
	)			[inline]

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]

SymMat<M,E,S>::template Result<typename negator<R>::StdNumber>::Add SimTK::operator+	(	const negator< R > &	l,
		const SymMat< M, E, S > &	r
	)			[inline]

SymMat<M,E,S>::template Result<typename negator<R>::StdNumber>::Add SimTK::operator+	(	const SymMat< M, E, S > &	l,
		const negator< R > &	r
	)			[inline]

SymMat<M,E,S>::template Result<std::complex<R> >::Add SimTK::operator+	(	const conjugate< R > &	l,
		const SymMat< M, E, S > &	r
	)			[inline]

SymMat<M,E,S>::template Result<std::complex<R> >::Add SimTK::operator+	(	const SymMat< M, E, S > &	l,
		const conjugate< R > &	r
	)			[inline]

SymMat<M,E,S>::template Result<std::complex<R> >::Add SimTK::operator+	(	const std::complex< R > &	l,
		const SymMat< M, E, S > &	r
	)			[inline]

SymMat<M,E,S>::template Result<std::complex<R> >::Add SimTK::operator+	(	const SymMat< M, E, S > &	l,
		const std::complex< R > &	r
	)			[inline]

SymMat<M,E,S>::template Result<typename CNT<E>::Precision>::Add SimTK::operator+	(	int	l,
		const SymMat< M, E, S > &	r
	)			[inline]

SymMat<M,E,S>::template Result<typename CNT<E>::Precision>::Add SimTK::operator+	(	const SymMat< M, E, S > &	l,
		int	r
	)			[inline]

SymMat<M,E,S>::template Result<long double>::Add SimTK::operator+	(	const long double &	l,
		const SymMat< M, E, S > &	r
	)			[inline]

SymMat<M,E,S>::template Result<long double>::Add SimTK::operator+	(	const SymMat< M, E, S > &	l,
		const long double &	r
	)			[inline]

SymMat<M,E,S>::template Result<double>::Add SimTK::operator+	(	const double &	l,
		const SymMat< M, E, S > &	r
	)			[inline]

SymMat<M,E,S>::template Result<double>::Add SimTK::operator+	(	const SymMat< M, E, S > &	l,
		const double &	r
	)			[inline]

SymMat<M,E,S>::template Result<float>::Add SimTK::operator+	(	const float &	l,
		const SymMat< M, E, S > &	r
	)			[inline]

SymMat<M,E,S>::template Result<float>::Add SimTK::operator+	(	const SymMat< M, E, S > &	l,
		const float &	r
	)			[inline]

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]

Row<N,E,S>::template Result<typename negator<R>::StdNumber>::Add SimTK::operator+	(	const negator< R > &	l,
		const Row< N, E, S > &	r
	)			[inline]

Row<N,E,S>::template Result<typename negator<R>::StdNumber>::Add SimTK::operator+	(	const Row< N, E, S > &	l,
		const negator< R > &	r
	)			[inline]

Row<N,E,S>::template Result<std::complex<R> >::Add SimTK::operator+	(	const conjugate< R > &	l,
		const Row< N, E, S > &	r
	)			[inline]

Row<N,E,S>::template Result<std::complex<R> >::Add SimTK::operator+	(	const Row< N, E, S > &	l,
		const conjugate< R > &	r
	)			[inline]

Row<N,E,S>::template Result<std::complex<R> >::Add SimTK::operator+	(	const std::complex< R > &	l,
		const Row< N, E, S > &	r
	)			[inline]

Row<N,E,S>::template Result<std::complex<R> >::Add SimTK::operator+	(	const Row< N, E, S > &	l,
		const std::complex< R > &	r
	)			[inline]

Row<N,E,S>::template Result<typename CNT<E>::Precision>::Add SimTK::operator+	(	int	l,
		const Row< N, E, S > &	r
	)			[inline]

Row<N,E,S>::template Result<typename CNT<E>::Precision>::Add SimTK::operator+	(	const Row< N, E, S > &	l,
		int	r
	)			[inline]

Row<N,E,S>::template Result<long double>::Add SimTK::operator+	(	const long double &	l,
		const Row< N, E, S > &	r
	)			[inline]

Row<N,E,S>::template Result<long double>::Add SimTK::operator+	(	const Row< N, E, S > &	l,
		const long double &	r
	)			[inline]

Row<N,E,S>::template Result<double>::Add SimTK::operator+	(	const double &	l,
		const Row< N, E, S > &	r
	)			[inline]

Row<N,E,S>::template Result<double>::Add SimTK::operator+	(	const Row< N, E, S > &	l,
		const double &	r
	)			[inline]

Row<N,E,S>::template Result<float>::Add SimTK::operator+	(	const float &	l,
		const Row< N, E, S > &	r
	)			[inline]

Row<N,E,S>::template Result<float>::Add SimTK::operator+	(	const Row< N, E, S > &	l,
		const float &	r
	)			[inline]

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]

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

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

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

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]

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]

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]

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]

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]

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]

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]

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]

Mat<M,N,E,CS,RS>::template Result<long double>::Add SimTK::operator+	(	const long double &	l,
		const Mat< M, N, E, CS, RS > &	r
	)			[inline]

Mat<M,N,E,CS,RS>::template Result<long double>::Add SimTK::operator+	(	const Mat< M, N, E, CS, RS > &	l,
		const long double &	r
	)			[inline]

Mat<M,N,E,CS,RS>::template Result<double>::Add SimTK::operator+	(	const double &	l,
		const Mat< M, N, E, CS, RS > &	r
	)			[inline]

Mat<M,N,E,CS,RS>::template Result<double>::Add SimTK::operator+	(	const Mat< M, N, E, CS, RS > &	l,
		const double &	r
	)			[inline]

Mat<M,N,E,CS,RS>::template Result<float>::Add SimTK::operator+	(	const float &	l,
		const Mat< M, N, E, CS, RS > &	r
	)			[inline]

Mat<M,N,E,CS,RS>::template Result<float>::Add SimTK::operator+	(	const Mat< M, N, E, CS, RS > &	l,
		const float &	r
	)			[inline]

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]

Inertia SimTK::operator+	(	const Inertia &	l,
		const Inertia &	r
	)			[inline]

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

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

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

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

conjugate<long double> SimTK::operator+	(	const long double &	a,
		const conjugate< R > &	b
	)			[inline]

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

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

conjugate<long double> SimTK::operator+	(	const conjugate< R > &	a,
		const long double &	b
	)			[inline]

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

complex<long double> SimTK::operator+	(	const double &	r,
		const complex< long double > &	c
	)			[inline]

complex<long double> SimTK::operator+	(	const complex< long double > &	c,
		const double &	r
	)			[inline]

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

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

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

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

complex<long double> SimTK::operator+	(	const long double &	r,
		const complex< double > &	c
	)			[inline]

complex<long double> SimTK::operator+	(	const complex< double > &	c,
		const long double &	r
	)			[inline]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

CNT<R>::template Result<Vec<M,E,S> >::Sub SimTK::operator-	(	const negator< R > &	l,
		const Vec< M, E, S > &	r
	)			[inline]

Vec<M,E,S>::template Result<typename negator<R>::StdNumber>::Sub SimTK::operator-	(	const Vec< M, E, S > &	l,
		const negator< R > &	r
	)			[inline]

CNT<std::complex<R> >::template Result<Vec<M,E,S> >::Sub SimTK::operator-	(	const conjugate< R > &	l,
		const Vec< M, E, S > &	r
	)			[inline]

Vec<M,E,S>::template Result<std::complex<R> >::Sub SimTK::operator-	(	const Vec< M, E, S > &	l,
		const conjugate< R > &	r
	)			[inline]

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]

Vec<M,E,S>::template Result<std::complex<R> >::Sub SimTK::operator-	(	const Vec< M, E, S > &	l,
		const std::complex< R > &	r
	)			[inline]

CNT<typename CNT<E>::Precision>::template Result<Vec<M,E,S> >::Sub SimTK::operator-	(	int	l,
		const Vec< M, E, S > &	r
	)			[inline]

Vec<M,E,S>::template Result<typename CNT<E>::Precision>::Sub SimTK::operator-	(	const Vec< M, E, S > &	l,
		int	r
	)			[inline]

CNT<long double>::template Result<Vec<M,E,S> >::Sub SimTK::operator-	(	const long double &	l,
		const Vec< M, E, S > &	r
	)			[inline]

Vec<M,E,S>::template Result<long double>::Sub SimTK::operator-	(	const Vec< M, E, S > &	l,
		const long double &	r
	)			[inline]

CNT<double>::template Result<Vec<M,E,S> >::Sub SimTK::operator-	(	const double &	l,
		const Vec< M, E, S > &	r
	)			[inline]

Vec<M,E,S>::template Result<double>::Sub SimTK::operator-	(	const Vec< M, E, S > &	l,
		const double &	r
	)			[inline]

CNT<float>::template Result<Vec<M,E,S> >::Sub SimTK::operator-	(	const float &	l,
		const Vec< M, E, S > &	r
	)			[inline]

Vec<M,E,S>::template Result<float>::Sub SimTK::operator-	(	const Vec< M, E, S > &	l,
		const float &	r
	)			[inline]

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]

CNT<R>::template Result<SymMat<M,E,S> >::Sub SimTK::operator-	(	const negator< R > &	l,
		const SymMat< M, E, S > &	r
	)			[inline]

SymMat<M,E,S>::template Result<typename negator<R>::StdNumber>::Sub SimTK::operator-	(	const SymMat< M, E, S > &	l,
		const negator< R > &	r
	)			[inline]

CNT<std::complex<R> >::template Result<SymMat<M,E,S> >::Sub SimTK::operator-	(	const conjugate< R > &	l,
		const SymMat< M, E, S > &	r
	)			[inline]

SymMat<M,E,S>::template Result<std::complex<R> >::Sub SimTK::operator-	(	const SymMat< M, E, S > &	l,
		const conjugate< R > &	r
	)			[inline]

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]

SymMat<M,E,S>::template Result<std::complex<R> >::Sub SimTK::operator-	(	const SymMat< M, E, S > &	l,
		const std::complex< R > &	r
	)			[inline]

CNT<typename CNT<E>::Precision>::template Result<SymMat<M,E,S> >::Sub SimTK::operator-	(	int	l,
		const SymMat< M, E, S > &	r
	)			[inline]

SymMat<M,E,S>::template Result<typename CNT<E>::Precision>::Sub SimTK::operator-	(	const SymMat< M, E, S > &	l,
		int	r
	)			[inline]

CNT<long double>::template Result<SymMat<M,E,S> >::Sub SimTK::operator-	(	const long double &	l,
		const SymMat< M, E, S > &	r
	)			[inline]

SymMat<M,E,S>::template Result<long double>::Sub SimTK::operator-	(	const SymMat< M, E, S > &	l,
		const long double &	r
	)			[inline]

CNT<double>::template Result<SymMat<M,E,S> >::Sub SimTK::operator-	(	const double &	l,
		const SymMat< M, E, S > &	r
	)			[inline]

SymMat<M,E,S>::template Result<double>::Sub SimTK::operator-	(	const SymMat< M, E, S > &	l,
		const double &	r
	)			[inline]

CNT<float>::template Result<SymMat<M,E,S> >::Sub SimTK::operator-	(	const float &	l,
		const SymMat< M, E, S > &	r
	)			[inline]

SymMat<M,E,S>::template Result<float>::Sub SimTK::operator-	(	const SymMat< M, E, S > &	l,
		const float &	r
	)			[inline]

SymMat< M, E1, S1 >::template Result< SymMat< M, E2, S2 > >::Mul operator-	(	const SymMat< M, E1, S1 > &	l,
		const SymMat< M, E2, S2 > &	r
	)			[inline]

CNT<R>::template Result<Row<N,E,S> >::Sub SimTK::operator-	(	const negator< R > &	l,
		const Row< N, E, S > &	r
	)			[inline]

Row<N,E,S>::template Result<typename negator<R>::StdNumber>::Sub SimTK::operator-	(	const Row< N, E, S > &	l,
		const negator< R > &	r
	)			[inline]

CNT<std::complex<R> >::template Result<Row<N,E,S> >::Sub SimTK::operator-	(	const conjugate< R > &	l,
		const Row< N, E, S > &	r
	)			[inline]

Row<N,E,S>::template Result<std::complex<R> >::Sub SimTK::operator-	(	const Row< N, E, S > &	l,
		const conjugate< R > &	r
	)			[inline]

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]

Row<N,E,S>::template Result<std::complex<R> >::Sub SimTK::operator-	(	const Row< N, E, S > &	l,
		const std::complex< R > &	r
	)			[inline]

CNT<typename CNT<E>::Precision>::template Result<Row<N,E,S> >::Sub SimTK::operator-	(	int	l,
		const Row< N, E, S > &	r
	)			[inline]

Row<N,E,S>::template Result<typename CNT<E>::Precision>::Sub SimTK::operator-	(	const Row< N, E, S > &	l,
		int	r
	)			[inline]

CNT<long double>::template Result<Row<N,E,S> >::Sub SimTK::operator-	(	const long double &	l,
		const Row< N, E, S > &	r
	)			[inline]

Row<N,E,S>::template Result<long double>::Sub SimTK::operator-	(	const Row< N, E, S > &	l,
		const long double &	r
	)			[inline]

CNT<double>::template Result<Row<N,E,S> >::Sub SimTK::operator-	(	const double &	l,
		const Row< N, E, S > &	r
	)			[inline]

Row<N,E,S>::template Result<double>::Sub SimTK::operator-	(	const Row< N, E, S > &	l,
		const double &	r
	)			[inline]

CNT<float>::template Result<Row<N,E,S> >::Sub SimTK::operator-	(	const float &	l,
		const Row< N, E, S > &	r
	)			[inline]

Row<N,E,S>::template Result<float>::Sub SimTK::operator-	(	const Row< N, E, S > &	l,
		const float &	r
	)			[inline]

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]

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

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

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

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]

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]

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]

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]

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]

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]

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]

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]

CNT<long double>::template Result<Mat<M,N,E,CS,RS> >::Sub SimTK::operator-	(	const long double &	l,
		const Mat< M, N, E, CS, RS > &	r
	)			[inline]

Mat<M,N,E,CS,RS>::template Result<long double>::Sub SimTK::operator-	(	const Mat< M, N, E, CS, RS > &	l,
		const long double &	r
	)			[inline]

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]

Mat<M,N,E,CS,RS>::template Result<double>::Sub SimTK::operator-	(	const Mat< M, N, E, CS, RS > &	l,
		const double &	r
	)			[inline]

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]

Mat<M,N,E,CS,RS>::template Result<float>::Sub SimTK::operator-	(	const Mat< M, N, E, CS, RS > &	l,
		const float &	r
	)			[inline]

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]

Inertia SimTK::operator-	(	const Inertia &	l,
		const Inertia &	r
	)			[inline]

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

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

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

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

complex<long double> SimTK::operator-	(	const long double &	a,
		const conjugate< R > &	b
	)			[inline]

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

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

conjugate<long double> SimTK::operator-	(	const conjugate< R > &	a,
		const long double &	b
	)			[inline]

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

complex<long double> SimTK::operator-	(	const double &	r,
		const complex< long double > &	c
	)			[inline]

complex<long double> SimTK::operator-	(	const complex< long double > &	c,
		const double &	r
	)			[inline]

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

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

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

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

complex<long double> SimTK::operator-	(	const long double &	r,
		const complex< double > &	c
	)			[inline]

complex<long double> SimTK::operator-	(	const complex< double > &	c,
		const long double &	r
	)			[inline]

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

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

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

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

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

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

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

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

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

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

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

References RowVectorBase< ELT >::size().

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

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

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

References VectorBase< ELT >::size().

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

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

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

References MatrixBase< ELT >::ncol(), and MatrixBase< ELT >::nrow().

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

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

CNT<R>::template Result<Vec<M,E,S> >::Dvd SimTK::operator/	(	const negator< R > &	l,
		const Vec< M, E, S > &	r
	)			[inline]

Vec<M,E,S>::template Result<typename negator<R>::StdNumber>::Dvd SimTK::operator/	(	const Vec< M, E, S > &	l,
		const negator< R > &	r
	)			[inline]

CNT<std::complex<R> >::template Result<Vec<M,E,S> >::Dvd SimTK::operator/	(	const conjugate< R > &	l,
		const Vec< M, E, S > &	r
	)			[inline]

Vec<M,E,S>::template Result<std::complex<R> >::Dvd SimTK::operator/	(	const Vec< M, E, S > &	l,
		const conjugate< R > &	r
	)			[inline]

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]

Vec<M,E,S>::template Result<std::complex<R> >::Dvd SimTK::operator/	(	const Vec< M, E, S > &	l,
		const std::complex< R > &	r
	)			[inline]

CNT<typename CNT<E>::Precision>::template Result<Vec<M,E,S> >::Dvd SimTK::operator/	(	int	l,
		const Vec< M, E, S > &	r
	)			[inline]

Vec<M,E,S>::template Result<typename CNT<E>::Precision>::Dvd SimTK::operator/	(	const Vec< M, E, S > &	l,
		int	r
	)			[inline]

CNT<long double>::template Result<Vec<M,E,S> >::Dvd SimTK::operator/	(	const long double &	l,
		const Vec< M, E, S > &	r
	)			[inline]

Vec<M,E,S>::template Result<long double>::Dvd SimTK::operator/	(	const Vec< M, E, S > &	l,
		const long double &	r
	)			[inline]

CNT<double>::template Result<Vec<M,E,S> >::Dvd SimTK::operator/	(	const double &	l,
		const Vec< M, E, S > &	r
	)			[inline]

Vec<M,E,S>::template Result<double>::Dvd SimTK::operator/	(	const Vec< M, E, S > &	l,
		const double &	r
	)			[inline]

CNT<float>::template Result<Vec<M,E,S> >::Dvd SimTK::operator/	(	const float &	l,
		const Vec< M, E, S > &	r
	)			[inline]

Vec<M,E,S>::template Result<float>::Dvd SimTK::operator/	(	const Vec< M, E, S > &	l,
		const float &	r
	)			[inline]

CNT<R>::template Result<SymMat<M,E,S> >::Dvd SimTK::operator/	(	const negator< R > &	l,
		const SymMat< M, E, S > &	r
	)			[inline]

SymMat<M,E,S>::template Result<typename negator<R>::StdNumber>::Dvd SimTK::operator/	(	const SymMat< M, E, S > &	l,
		const negator< R > &	r
	)			[inline]

CNT<std::complex<R> >::template Result<SymMat<M,E,S> >::Dvd SimTK::operator/	(	const conjugate< R > &	l,
		const SymMat< M, E, S > &	r
	)			[inline]

SymMat<M,E,S>::template Result<std::complex<R> >::Dvd SimTK::operator/	(	const SymMat< M, E, S > &	l,
		const conjugate< R > &	r
	)			[inline]

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]

SymMat<M,E,S>::template Result<std::complex<R> >::Dvd SimTK::operator/	(	const SymMat< M, E, S > &	l,
		const std::complex< R > &	r
	)			[inline]

CNT<typename CNT<E>::Precision>::template Result<SymMat<M,E,S> >::Dvd SimTK::operator/	(	int	l,
		const SymMat< M, E, S > &	r
	)			[inline]

SymMat<M,E,S>::template Result<typename CNT<E>::Precision>::Dvd SimTK::operator/	(	const SymMat< M, E, S > &	l,
		int	r
	)			[inline]

CNT<long double>::template Result<SymMat<M,E,S> >::Dvd SimTK::operator/	(	const long double &	l,
		const SymMat< M, E, S > &	r
	)			[inline]

SymMat<M,E,S>::template Result<long double>::Dvd SimTK::operator/	(	const SymMat< M, E, S > &	l,
		const long double &	r
	)			[inline]

CNT<double>::template Result<SymMat<M,E,S> >::Dvd SimTK::operator/	(	const double &	l,
		const SymMat< M, E, S > &	r
	)			[inline]

SymMat<M,E,S>::template Result<double>::Dvd SimTK::operator/	(	const SymMat< M, E, S > &	l,
		const double &	r
	)			[inline]

CNT<float>::template Result<SymMat<M,E,S> >::Dvd SimTK::operator/	(	const float &	l,
		const SymMat< M, E, S > &	r
	)			[inline]

SymMat<M,E,S>::template Result<float>::Dvd SimTK::operator/	(	const SymMat< M, E, S > &	l,
		const float &	r
	)			[inline]

CNT<R>::template Result<Row<N,E,S> >::Dvd SimTK::operator/	(	const negator< R > &	l,
		const Row< N, E, S > &	r
	)			[inline]

Row<N,E,S>::template Result<typename negator<R>::StdNumber>::Dvd SimTK::operator/	(	const Row< N, E, S > &	l,
		const negator< R > &	r
	)			[inline]

CNT<std::complex<R> >::template Result<Row<N,E,S> >::Dvd SimTK::operator/	(	const conjugate< R > &	l,
		const Row< N, E, S > &	r
	)			[inline]

Row<N,E,S>::template Result<std::complex<R> >::Dvd SimTK::operator/	(	const Row< N, E, S > &	l,
		const conjugate< R > &	r
	)			[inline]

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]

Row<N,E,S>::template Result<std::complex<R> >::Dvd SimTK::operator/	(	const Row< N, E, S > &	l,
		const std::complex< R > &	r
	)			[inline]

CNT<typename CNT<E>::Precision>::template Result<Row<N,E,S> >::Dvd SimTK::operator/	(	int	l,
		const Row< N, E, S > &	r
	)			[inline]

Row<N,E,S>::template Result<typename CNT<E>::Precision>::Dvd SimTK::operator/	(	const Row< N, E, S > &	l,
		int	r
	)			[inline]

CNT<long double>::template Result<Row<N,E,S> >::Dvd SimTK::operator/	(	const long double &	l,
		const Row< N, E, S > &	r
	)			[inline]

Row<N,E,S>::template Result<long double>::Dvd SimTK::operator/	(	const Row< N, E, S > &	l,
		const long double &	r
	)			[inline]

CNT<double>::template Result<Row<N,E,S> >::Dvd SimTK::operator/	(	const double &	l,
		const Row< N, E, S > &	r
	)			[inline]

Row<N,E,S>::template Result<double>::Dvd SimTK::operator/	(	const Row< N, E, S > &	l,
		const double &	r
	)			[inline]

CNT<float>::template Result<Row<N,E,S> >::Dvd SimTK::operator/	(	const float &	l,
		const Row< N, E, S > &	r
	)			[inline]

Row<N,E,S>::template Result<float>::Dvd SimTK::operator/	(	const Row< N, E, S > &	l,
		const float &	r
	)			[inline]

Rotation SimTK::operator/	(	const InverseRotation &	R1,
		const InverseRotation &	R2
	)			[inline]

Rotation SimTK::operator/	(	const InverseRotation &	R1,
		const Rotation &	R2
	)			[inline]

Rotation SimTK::operator/	(	const Rotation &	R1,
		const InverseRotation &	R2
	)			[inline]

Rotation SimTK::operator/	(	const Rotation &	R1,
		const Rotation &	R2
	)			[inline]

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

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

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

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]

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]

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]

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]

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]

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]

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]

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]

CNT<long double>::template Result<Mat<M,N,E,CS,RS> >::Dvd SimTK::operator/	(	const long double &	l,
		const Mat< M, N, E, CS, RS > &	r
	)			[inline]

Mat<M,N,E,CS,RS>::template Result<long double>::Dvd SimTK::operator/	(	const Mat< M, N, E, CS, RS > &	l,
		const long double &	r
	)			[inline]

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]

Mat<M,N,E,CS,RS>::template Result<double>::Dvd SimTK::operator/	(	const Mat< M, N, E, CS, RS > &	l,
		const double &	r
	)			[inline]

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]

Mat<M,N,E,CS,RS>::template Result<float>::Dvd SimTK::operator/	(	const Mat< M, N, E, CS, RS > &	l,
		const float &	r
	)			[inline]

Inertia SimTK::operator/	(	const Inertia &	i,
		const Real &	r
	)			[inline]

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

References conj().

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

References conj().

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

References conj().

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

complex<long double> SimTK::operator/	(	const long double &	a,
		const conjugate< R > &	b
	)			[inline]

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

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

conjugate<long double> SimTK::operator/	(	const conjugate< R > &	a,
		const long double &	b
	)			[inline]

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

complex<long double> SimTK::operator/	(	const double &	r,
		const complex< long double > &	c
	)			[inline]

complex<long double> SimTK::operator/	(	const complex< long double > &	c,
		const double &	r
	)			[inline]

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

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

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

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

complex<long double> SimTK::operator/	(	const long double &	r,
		const complex< double > &	c
	)			[inline]

complex<long double> SimTK::operator/	(	const complex< double > &	c,
		const long double &	r
	)			[inline]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

std::basic_ostream<CHAR,TRAITS>& SimTK::operator<<	(	std::basic_ostream< CHAR, TRAITS > &	o,
		const Vec< M, E, S > &	v
	)			[inline]

std::ostream& SimTK::operator<<	(	std::ostream &	o,
		const AbstractValue &	v
	)			[inline]

References AbstractValue::getValueAsString().

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

std::basic_ostream<CHAR,TRAITS>& SimTK::operator<<	(	std::basic_ostream< CHAR, TRAITS > &	o,
		const SymMat< M, E, RS > &	m
	)			[inline]

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

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

References Enumeration< T >::getName().

std::basic_ostream<CHAR,TRAITS>& SimTK::operator<<	(	std::basic_ostream< CHAR, TRAITS > &	o,
		const Row< N, E, S > &	v
	)			[inline]

std::ostream& SimTK::operator<<	(	std::ostream &	o,
		const Rotation &	m
	)

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

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

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

std::basic_ostream<CHAR,TRAITS>& SimTK::operator<<	(	std::basic_ostream< CHAR, TRAITS > &	o,
		const Mat< M, N, E, CS, RS > &	m
	)			[inline]

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

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

std::ostream& SimTK::operator<<	(	std::ostream &	stream,
		const Enumeration< T > &	value
	)			[inline]

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

std::ostream& SimTK::operator<<	(	std::ostream &	o,
		const MatrixBase< T > &	m
	)			[inline]

std::ostream& SimTK::operator<<	(	std::ostream &	o,
		const RowVectorBase< T > &	v
	)			[inline]

std::ostream& SimTK::operator<<	(	std::ostream &	o,
		const VectorBase< T > &	v
	)			[inline]

std::ostream& SimTK::operator<<	(	std::ostream &	stream,
		const AtomicInteger &	value
	)

std::ostream& SimTK::operator<<	(	std::ostream &	s,
		const ArrayView< T > &	a
	)			[inline]

std::ostream& SimTK::operator<<	(	std::ostream &	s,
		const Array< T > &	a
	)			[inline]

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

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

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

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

std::ostream& SimTK::operator<<	(	std::ostream &	o,
		const Compound &	c
	)

Dump debugging information about compound structure to a stream.

This method does NOT produce PDB files or anything like it. It is used for debugging the internal structure of instances of the Compound class and is thus not intended for typical API client use.

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).

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).

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

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

bool SimTK::operator==	(	const InverseTransform &	X1,
		const Transform &	X2
	)			[inline]

References Transform::p(), InverseTransform::p(), Transform::R(), and InverseTransform::R().

bool SimTK::operator==	(	const Transform &	X1,
		const InverseTransform &	X2
	)			[inline]

References InverseTransform::p(), Transform::p(), InverseTransform::R(), and Transform::R().

bool SimTK::operator==	(	const InverseTransform &	X1,
		const InverseTransform &	X2
	)			[inline]

References InverseTransform::p(), and InverseTransform::R().

bool SimTK::operator==	(	const Transform &	X1,
		const Transform &	X2
	)			[inline]

References Transform::p(), and Transform::R().

bool SimTK::operator==	(	const SymMat< M, E1, S1 > &	l,
		const SymMat< M, E2, S2 > &	r
	)			[inline]

References SymMat< M, ELT, RS >::getAsVec().

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

References PhiMatrixTranspose::l().

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

References PhiMatrix::l().

bool SimTK::operator==	(	const Row< N, E1, S1 > &	l,
		const Row< N, E2, S2 > &	r
	)			[inline]

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

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

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

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

bool SimTK::operator==	(	const Inertia &	i1,
		const Inertia &	i2
	)			[inline]

References Inertia::toMat33().

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

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

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

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

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

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

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

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

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

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

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

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).

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).

std::basic_istream<CHAR,TRAITS>& SimTK::operator>>	(	std::basic_istream< CHAR, TRAITS > &	is,
		Vec< M, E, S > &	v
	)			[inline]

std::basic_istream<CHAR,TRAITS>& SimTK::operator>>	(	std::basic_istream< CHAR, TRAITS > &	is,
		SymMat< M, E, RS > &	m
	)			[inline]

std::basic_istream<CHAR,TRAITS>& SimTK::operator>>	(	std::basic_istream< CHAR, TRAITS > &	is,
		Row< N, E, S > &	v
	)			[inline]

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

std::basic_istream<CHAR,TRAITS>& SimTK::operator>>	(	std::basic_istream< CHAR, TRAITS > &	is,
		Mat< M, N, E, CS, RS > &	m
	)			[inline]

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

PhiMatrixTranspose SimTK::operator~

(

const PhiMatrix &

phi

)

[inline]

References transpose().

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]

References outer(), and Row< N, ELT, STRIDE >::positionalTranspose().

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]

References outer(), and Row< N, ELT, STRIDE >::positionalTranspose().

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]

References outer(), and Row< N, ELT, STRIDE >::positionalTranspose().

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]

Referenced by outer().

const long double& SimTK::real

(

const conjugate< long double > &

c

)

[inline]

References conjugate< long double >::real().

const double& SimTK::real

(

const conjugate< double > &

c

)

[inline]

References conjugate< double >::real().

const float& SimTK::real

(

const conjugate< float > &

c

)

[inline]

References conjugate< float >::real().

Referenced by cube(), negator< NUMBER >::real(), and Kabsch78::superpose().

SimTK::SimTK_BNTCMPLX_SPEC	(	long	double,
		long	double
	)

SimTK::SimTK_BNTCMPLX_SPEC	(	long	double,
		double
	)

SimTK::SimTK_BNTCMPLX_SPEC	(	long	double,
		float
	)

SimTK::SimTK_BNTCMPLX_SPEC	(	double	,
		long	double
	)

SimTK::SimTK_BNTCMPLX_SPEC	(	double	,
		double
	)

SimTK::SimTK_BNTCMPLX_SPEC	(	double	,
		float
	)

SimTK::SimTK_BNTCMPLX_SPEC	(	float	,
		long	double
	)

SimTK::SimTK_BNTCMPLX_SPEC	(	float	,
		double
	)

SimTK::SimTK_BNTCMPLX_SPEC	(	float	,
		float
	)

SimTK::SimTK_DEFINE_AND_EXPORT_UNIQUE_INDEX_TYPE

(

TinkerBiotypeIndex

)

SimTK::SimTK_DEFINE_AND_EXPORT_UNIQUE_INDEX_TYPE

(

BiotypeIndex

)

SimTK::SimTK_DEFINE_REAL_NTRAITS

(

long

double

)

SimTK::SimTK_DEFINE_REAL_NTRAITS

(

double

)

SimTK::SimTK_DEFINE_REAL_NTRAITS

(

float

)

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

EventId

)

This is a class to represent unique IDs for events in a type-safe way.

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

MultiplierIndex

)

Unique integer type for Subsystem-local multiplier indexing.

See also:

SystemMultiplierIndex

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

SystemMultiplierIndex

)

This unique integer type is for indexing global "multiplier-like" arrays, that is, arrays that inherently have the same dimension as the total number of Lagrange multipliers in the full System-level view of the State.

See also:

MultiplierIndex for Subsystem-local multiplier indexing

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

UDotErrIndex

)

Unique integer type for Subsystem-local uDotErr indexing.

See also:

SystemUDotErrIndex

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

SystemUDotErrIndex

)

This unique integer type is for indexing global "uDotErr-like" arrays, that is, arrays that inherently have the same dimension as the total number of acceleration-level constraint equations in the full System-level view of the State.

See also:

UDotErrIndex for Subsystem-local uDotErr indexing

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

UErrIndex

)

Unique integer type for Subsystem-local uErr indexing.

See also:

SystemUErrIndex

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

SystemUErrIndex

)

This unique integer type is for indexing global "uErr-like" arrays, that is, arrays that inherently have the same dimension as the total number of velocity-level constraint equations in the full System-level view of the State.

See also:

UErrIndex for Subsystem-local uErr indexing

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

QErrIndex

)

Unique integer type for Subsystem-local qErr indexing.

See also:

SystemQErrIndex

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

SystemQErrIndex

)

This unique integer type is for indexing global "qErr-like" arrays, that is, arrays that inherently have the same dimension as the total number of position-level constraint equations in the full System-level view of the State.

See also:

QErrIndex for Subsystem-local qErr indexing

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

SystemYErrIndex

)

This unique integer type is for indexing the global, System-level "yErr-like" arrays, that is, the arrays in which all of the various Subsystems' qErr and uErr constraint equation slots have been collected together.

Note that there is no Subsystem-local equivalent of the yErr array.

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

CacheEntryIndex

)

This unique integer type is for selecting non-shared cache entries.

These indices are always Subsystem-local, that is, the first explicitly-allocated cache entry belonging to each Subsystem has index 0.

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

DiscreteVariableIndex

)

This unique integer type is for selecting discrete variables.

These indices are always Subsystem-local, that is, the first discrete variable belonging to each Subsystem has index 0.

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

ZIndex

)

Unique integer type for Subsystem-local u indexing.

See also:

SystemZIndex

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

SystemZIndex

)

This unique integer type is for indexing global "z-like" arrays, that is, arrays that inherently have the same dimension as the total number of auxiliary state variables in the full System-level view of the State.

This type should be used for the global z and its global time derivative zDot.

See also:

ZIndex for Subsystem-local z indexing

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

UIndex

)

Unique integer type for Subsystem-local u indexing.

See also:

SystemUIndex

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

SystemUIndex

)

This unique integer type is for indexing global "u-like" arrays, that is, arrays that inherently have the same dimension as the total number of mobilities (generalized speeds) in the full System-level view of the State.

This type should be used for the global u and its global time derivative uDot.

See also:

UIndex for Subsystem-local u indexing

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

QIndex

)

Unique integer type for Subsystem-local q indexing.

See also:

SystemQIndex

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

SystemQIndex

)

This unique integer type is for indexing global "q-like" arrays, that is, arrays that inherently have the same dimension as the total number of second order state variables (generalized coordinates) in the full System-level view of the State.

This type should be used for the global q and its global time derivatives qDot and qDotDot.

See also:

QIndex for Subsystem-local q indexing

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

SystemYIndex

)

This unique integer type is for indexing the global, System-level "y-like" arrays, that is, the arrays in which all of the various Subsystems' continuous state variables q, u, and z have been collected into contiguous memory.

This type should be used for the global y and its global time derivative yDot. Note that there is no Subsystem-local equivalent of the y array.

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

SubsystemIndex

)

Provide a unique integer type for identifying Subsystems.

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

MeasureIndex

)

Define a unique integral type for safe indexing of Measures.

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

EventTriggerByStageIndex

)

Unique integer type for Subsystem-local, per-stage event indexing.

See also:

SystemEventTriggerIndex

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

SystemEventTriggerByStageIndex

)

This unique integer type is for identifying a triggered event within a particular Stage of the full System-level view of the State.

(Event triggers for a particular Stage are stored consecutively within the full collection of event triggers.) That is, the EventTriggerByStageIndex will be 0 for the first event trigger at that stage.

See also:

SystemEventTriggerIndex for System-global event indexing

EventTriggerByStageIndex for Subsystem-local, per-stage event indexing

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

EventTriggerIndex

)

Unique integer type for Subsystem-local event indexing.

See also:

SystemEventTriggerIndex

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

SystemEventTriggerIndex

)

This unique integer type is for identifying a triggered event in the full System-level view of the State.

More precisely, this is the index of the slot in the global array in the cache allocated to hold the value of that event's trigger function.

See also:

EventTriggerIndex for Subsystem-local event indexing

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

EventIndex

)

Unique integer type for Subsystem-local event indexing.

See also:

SystemEventIndex

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

SystemEventIndex

)

This unique integer type is for identifying an event in the full System-level view of the State.

This is a global resource and applies to all System-level events, not just triggered events requiring other State resources.

See also:

EventIndex for Subsystem-local event indexing

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

SubtreeQIndex

)

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

ConstraintIndex

)

const

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

MobilizedBodyIndex

)

const

SimTK::SimTK_LIST_SPECIALIZE

(

std::complex< long double >

)

SimTK::SimTK_LIST_SPECIALIZE

(

std::complex< double >

)

SimTK::SimTK_LIST_SPECIALIZE

(

std::complex< float >

)

SimTK::SimTK_LIST_SPECIALIZE

(

double

)

SimTK::SimTK_LIST_SPECIALIZE

(

float

)

SimTK_LIST_SPECIALIZE

(

long

)

SimTK::SimTK_LIST_SPECIALIZE

(

int

)

SimTK::SimTK_LIST_SPECIALIZE

(

short

)

SimTK_LIST_SPECIALIZE

(

unsigned

char

)

SimTK::SimTK_LIST_SPECIALIZE

(

char

)

SimTK::SimTK_LIST_SPECIALIZE

(

signed

char

)

SimTK::SimTK_LIST_SPECIALIZE

(

bool

)

SimTK::SimTK_NTRAITS_CONJ_SPEC	(	long	double,
		long	double
	)

SimTK::SimTK_NTRAITS_CONJ_SPEC	(	long	double,
		double
	)

SimTK::SimTK_NTRAITS_CONJ_SPEC	(	long	double,
		float
	)

SimTK::SimTK_NTRAITS_CONJ_SPEC	(	double	,
		long	double
	)

SimTK::SimTK_NTRAITS_CONJ_SPEC	(	double	,
		double
	)

SimTK::SimTK_NTRAITS_CONJ_SPEC	(	double	,
		float
	)

SimTK::SimTK_NTRAITS_CONJ_SPEC	(	float	,
		long	double
	)

SimTK::SimTK_NTRAITS_CONJ_SPEC	(	float	,
		double
	)

SimTK::SimTK_NTRAITS_CONJ_SPEC	(	float	,
		float
	)

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

(

const SymMat< N, ELEM >

v

)

[inline]

References sort().

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

(

Mat< M, N, ELEM >

v

)

[inline]

References Mat< M, N, ELT, CS, RS >::col(), and sort().

Row<N, ELEM> SimTK::sort

(

Row< N, ELEM >

v

)

[inline]

References sort().

Vec<N, ELEM> SimTK::sort

(

Vec< N, ELEM >

v

)

[inline]

References sort().

MatrixBase<ELEM> SimTK::sort

(

const MatrixBase< ELEM >

v

)

[inline]

References MatrixBase< ELT >::col(), MatrixBase< ELT >::ncol(), MatrixBase< ELT >::nrow(), sort(), and MatrixBase< ELT >::updCol().

RowVectorBase<ELEM> SimTK::sort

(

const RowVectorBase< ELEM >

v

)

[inline]

References RowVectorBase< ELT >::begin(), RowVectorBase< ELT >::end(), RowVectorBase< ELT >::size(), and sort().

VectorBase<ELEM> SimTK::sort

(

const VectorBase< ELEM >

v

)

[inline]

References VectorBase< ELT >::begin(), VectorBase< ELT >::end(), and VectorBase< ELT >::size().

Referenced by sort().

Row<N, ELEM> SimTK::sum

(

const SymMat< N, ELEM >

v

)

[inline]

References SymMat< M, ELT, RS >::sum().

Row<N, ELEM> SimTK::sum

(

const Mat< M, N, ELEM >

v

)

[inline]

References Mat< M, N, ELT, CS, RS >::sum().

ELEM SimTK::sum

(

const Row< N, ELEM >

v

)

[inline]

References Row< N, ELT, STRIDE >::sum().

ELEM SimTK::sum

(

const Vec< N, ELEM >

v

)

[inline]

References Vec< M, ELT, STRIDE >::sum().

RowVectorBase<ELEM> SimTK::sum

(

const MatrixBase< ELEM >

v

)

[inline]

References MatrixBase< ELT >::sum().

ELEM SimTK::sum

(

const RowVectorBase< ELEM >

v

)

[inline]

References RowVectorBase< ELT >::sum().

ELEM SimTK::sum

(

const VectorBase< ELEM >

v

)

[inline]

References VectorBase< ELT >::sum().

Referenced by dot(), mean(), and operator*().

PhiMatrixTranspose SimTK::transpose

(

const PhiMatrix &

phi

)

[inline]

Referenced by operator~().