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	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	Assembler
	This Study attempts to find a configuration (set of joint coordinates q) of a Simbody MultibodySystem that satisfies the System's position Constraints plus optional additional assembly conditions. More...
class	AssemblyCondition
	Define an assembly condition consisting of a scalar goal and/or a related set of assembly error equations (that is, an objective and/or some constraints). More...
class	QValue
	This AssemblyCondition requests that a particular generalized coordinate end up with a specified value. More...
class	Markers
	This AssemblyCondition specifies a correspondence between stations on mobilized bodies ("markers") and fixed ground-frame locations ("observations"). More...
class	Body
	The Body class represents a reference frame that can be used to describe mass properties and geometry. More...
class	CollisionDetectionAlgorithm
	A CollisionDetectionAlgorithm implements an algorithm for detecting overlaps between pairs of ContactGeometry objects, and creating Contact objects based on them. More...
class	CompliantContactSubsystem
	This is a force subsystem that implements a compliant contact model to respond to Contact objects as detected by a ContactTrackerSubsystem. More...
class	ContactForce
	This is a simple class containing the basic force information for a single contact between deformable surfaces S1 and S2 mounted on rigid bodies B1 and B2. More...
class	ContactDetail
	This provides deformed geometry and force details for one element of a contact patch that may be composed of many elements. More...
class	ContactPatch
	A ContactPatch is the description of the forces and the deformed shape of the contact surfaces that result from compliant contact interactions. More...
class	ContactForceGenerator
	A ContactForceGenerator implements an algorithm for responding to overlaps or potential overlaps between pairs of ContactSurface objects, as detected by a ContactTrackerSubsystem. More...
class	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 surfaces that are in contact with each other. More...
class	UntrackedContact
	This subclass of Contact represents a pair of contact surfaces that are not yet being tracked; there is no ContactId for them. More...
class	BrokenContact
	This subclass of Contact represents a pair of contact surfaces that were in contact (meaning within cutoff range) but have now gone out of range. More...
class	CircularPointContact
	This subclass of Contact represents a contact between two non-conforming surfaces 1 and 2 that initially meet at a point where each surface has a uniform radius of curvature in all directions (R1 and R2), like a sphere (inside or outside) or a halfspace, resulting in a contact region with circular symmetry. More...
class	TriangleMeshContact
	This subclass of Contact is used when one or both of the ContactGeometry objects is a TriangleMesh. 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	ContactGeometry
	A ContactGeometry object describes the physical shape of a body. More...
class	ContactGeometryImpl
class	OBBTreeNodeImpl
class	ContactImpl
	This is the internal implementation base class for Contact. More...
class	UntrackedContactImpl
	This is the internal implementation class for UntrackedContact. More...
class	BrokenContactImpl
	This is the internal implementation class for BrokenContact. More...
class	CircularPointContactImpl
	This is the internal implementation class for CircularPointContact. More...
class	TriangleMeshContactImpl
	This is the internal implementation class for TriangleMeshContact. More...
class	PointContactImpl
	This is the internal implementation class for PointContact. More...
class	ContactMaterial
	Define the physical properties of the material from which a contact surface is made, including properties needed by a variety of contact response techniques that might be applied during contact. More...
class	ContactSurface
	This class combines a piece of ContactGeometry with a ContactMaterial to make an object suitable for attaching to a body which can then engage in contact behavior with other contact surfaces. More...
class	ContactTrackerSubsystem
	This subsystem identifies and tracks potential contacts between bodies of a multibody system, but does not generate any physical responses to those contacts. More...
class	ContactSnapshot
	Objects of this class represent collections of surface-pair interactions that are being tracked at a particular instant during a simulation. More...
class	ContactTracker
	A ContactTracker implements an algorithm for detecting overlaps or potential overlaps between pairs of ContactGeometry objects, and managing Contact objects that track individual contacts as they evolve through time. More...
class	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
	This is the base class from which all Force element handle classes derive. More...
class	ForceSubsystem
	This is logically an abstract class, more specialized than "Subsystem" but not yet concrete. More...
class	GeneralContactSubsystem
	This class performs collision detection for use in contact modeling. More...
class	GeneralForceSubsystem
	This is a concrete subsystem which can apply arbitrary forces to a MultibodySystem. More...
class	HuntCrossleyContact
	This is a concrete subsystem that handles simple, frictionless contact situations with a model due to Hunt & Crossley: 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	Motion
	A Motion object belongs to a particular mobilizer and specifies how the associated motion is to be calculated. More...
class	MultibodySystem
	The job of the MultibodySystem class is to coordinate the activities of various subsystems which can be part of a multibody system. More...
class	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	UserFunction
	This template class defines a standard interface for objects that calculate a function based on a System and State for use in a TextDataEventReporter. More...
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	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	RungeKutta3Integrator
	This is a 3rd order Runge-Kutta Integrator using coefficents from J.C. 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...
struct	ArrayIndexTraits
	This templatized type is used by the Array_<T,X> classes to obtain the information they need to use the class X as an index class for the array. More...
struct	ArrayIndexTraits< unsigned >
	Specialization of ArrayIndexTraits for unsigned (that is, unsigned int) used as an index. More...
struct	ArrayIndexTraits< int >
	Specialization of ArrayIndexTraits for (signed) int used as an index. More...
struct	ArrayIndexTraits< unsigned long >
	Specialization of ArrayIndexTraits for unsigned long used as an index. More...
struct	ArrayIndexTraits< long >
	Specialization of ArrayIndexTraits for (signed) long used as an index. More...
struct	ArrayIndexTraits< unsigned short >
	Specialization of ArrayIndexTraits for unsigned short used as an index. More...
struct	ArrayIndexTraits< short >
	Specialization of ArrayIndexTraits for (signed) short used as an index. More...
struct	ArrayIndexTraits< unsigned char >
	Specialization of ArrayIndexTraits for unsigned char used as an index. More...
struct	ArrayIndexTraits< signed char >
	Specialization of ArrayIndexTraits for signed char used as an index. More...
struct	ArrayIndexTraits< char >
	Specialization of ArrayIndexTraits for char used as an index. More...
struct	ArrayIndexTraits< bool >
	Specialization of ArrayIndexTraits for bool used as an index. More...
struct	ArrayIndexTraits< unsigned long long >
	Specialization of ArrayIndexTraits for unsigned long long used as an index. More...
struct	ArrayIndexTraits< long long >
	Specialization of ArrayIndexTraits for long long used as an index. More...
class	ArrayViewConst_
	This Array_ helper class is the base class for ArrayView_ which is the base class for Array_; here we provide only the minimal read-only "const" functionality required by any Array_ object, and shallow copy semantics. More...
class	ArrayView_
	This Array_ helper class is the base class for Array_, extending ArrayViewConst_ to add the ability to modify elements, but not the ability to change size or reallocate. More...
class	Array_
	The SimTK::Array_<T> container class is a plug-compatible replacement for the C++ standard template library (STL) std::vector<T> class, but with some important advantages in performance, and functionality, and binary compatibility. More...
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	Function_
	This abstract class represents a mathematical function that calculates a value of arbitrary type based on M real arguments. More...
class	Inertia_
	The physical meaning of an inertia is the distribution of a rigid body's mass about a particular point. More...
class	Gyration_
	A Gyration matrix is a unit-mass inertia matrix; you can convert it to an Inertia by multiplying it by the actual body mass. More...
class	SpatialInertia_
	A spatial inertia contains the mass, center of mass point, and inertia matrix for a rigid body. More...
class	ArticulatedInertia_
	An articulated body inertia (ABI) matrix P(q) contains the spatial inertia properties that a body appears to have when it is the free base body of an articulated multibody tree in a given configuration q. More...
class	MassProperties
	This class contains the mass, center of mass, and 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	AbstractMeasure
	This is the base class for all Measure handle classes. More...
class	Measure_
	This is the base handle class for all Measures whose value type is known. More...
class	Measure_Differentiate_Result
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> (or SimTK::Array_<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 a plug-compatible std::string replacement (plus some additional functionality) intended to be suitable for passing through the SimTK API without introducing binary compatibility problems the way std::string does, especially on Windows. More...
class	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 System handles. 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	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	Xml
	This class provides a minimalist capability for reading and writing XML documents, as files or strings. 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 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 Function_< Real >	Function
	This typedef is used for the very common case that the return type of the Function object is Real.
typedef Vec< 2, Vec3 >	SpatialVec
	SpatialVec[0] is the rotational component; [1] is translational.
typedef Vec< 2, Vec< 3, float > >	fSpatialVec
typedef Vec< 2, Vec< 3, double > >	dSpatialVec
typedef Row< 2, Row3 >	SpatialRow
	This is the type of a transposed SpatialVec.
typedef Row< 2, Row< 3, float > >	fSpatialRow
typedef Row< 2, Row< 3, double > >	dSpatialRow
typedef Mat< 2, 2, Mat33 >	SpatialMat
	This is used for primarily for spatial mass properties.
typedef Mat< 2, 2, Mat < 3, 3, float > >	fSpatialMat
typedef Mat< 2, 2, Mat < 3, 3, double > >	dSpatialMat
typedef Gyration_< Real >	Gyration
	A gyration (unit inertia) tensor at default precision.
typedef Gyration_< float >	fGyration
	A gyration (unit inertia) tensor at float precision.
typedef Gyration_< double >	dGyration
	A gyration (unit inertia) tensor at double precision.
typedef Inertia_< Real >	Inertia
	An inertia tensor at default precision.
typedef Inertia_< float >	fInertia
	An inertia tensor at float precision.
typedef Inertia_< double >	dInertia
	An inertia tensor at double precision.
typedef SpatialInertia_< Real >	SpatialInertia
	A spatial (rigid body) inertia matrix at default precision.
typedef SpatialInertia_< float >	fSpatialInertia
	A spatial (rigid body) inertia matrix at float precision.
typedef SpatialInertia_< double >	dSpatialInertia
	A spatial (rigid body) inertia matrix at double precision.
typedef ArticulatedInertia_< Real >	ArticulatedInertia
	An articulated body inertia matrix at default precision.
typedef ArticulatedInertia_ < float >	fArticulatedInertia
	An articulated body inertia matrix at float precision.
typedef ArticulatedInertia_ < double >	dArticulatedInertia
	An articulated body inertia matrix at double precision.
typedef Measure_< Real >	Measure
	A convenient abbreviation for the most common kind of Measure -- one which returns a single Real result.
typedef Quaternion_< Real >	Quaternion
typedef Quaternion_< float >	fQuaternion
typedef Quaternion_< double >	dQuaternion
typedef Rotation_< Real >	Rotation
typedef Rotation_< float >	fRotation
typedef Rotation_< double >	dRotation
typedef InverseRotation_< Real >	InverseRotation
typedef InverseRotation_< float >	fInverseRotation
typedef InverseRotation_< double >	dInverseRotation
typedef int	StageVersion
	This is the type to use for Stage version numbers.
typedef Transform_< Real >	Transform
typedef Transform_< float >	fTransform
typedef Transform_< double >	dTransform
typedef UnitVec< Real, 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 (AssemblyConditionIndex)
	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(PresQPoolIndex) SimTK_DEFINE_UNIQUE_INDEX_TYPE(PresUPoolIndex) SimTK_DEFINE_UNIQUE_INDEX_TYPE(PresUDotPoolIndex) SimTK_DEFINE_UNIQUE_INDEX_TYPE(PresForcePoolIndex) SimTK_DEFINE_UNIQUE_INDEX_TYPE(MobilizerQIndex) SimTK_DEFINE_UNIQUE_INDEX_TYPE(MobilizerUIndex) SimTK_DEFINE_UNIQUE_INDEX_TYPE(ConstrainedBodyIndex) SimTK_DEFINE_UNIQUE_INDEX_TYPE(ConstrainedMobilizerIndex) SimTK_DEFINE_UNIQUE_INDEX_TYPE(ConstrainedQIndex) SimTK_DEFINE_UNIQUE_INDEX_TYPE(ConstrainedUIndex) SimTK_DEFINE_UNIQUE_INDEX_TYPE(ParticipatingQIndex) SimTK_DEFINE_UNIQUE_INDEX_TYPE(ParticipatingUIndex) SimTK_DEFINE_UNIQUE_INDEX_TYPE(SubtreeBodyIndex) static const SubtreeBodyIndex SubtreeAncestorIndex(0)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (SubtreeQIndex) SimTK_DEFINE_UNIQUE_INDEX_TYPE(SubtreeUIndex) SimTK_DEFINE_UNIQUE_INDEX_TYPE(ForceIndex) SimTK_DEFINE_UNIQUE_INDEX_TYPE(ContactSetIndex) namespace Exception
std::ostream &	operator<< (std::ostream &o, const ContactForce &f)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (ContactSurfaceIndex)
	This defines a unique index for all the contact surfaces being handled either by a ContactTrackerSubsystem or within a single ContactSet of a GeneralContactSubsystem.
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (ContactId)
	This is a unique integer Id assigned to each contact pair when we first begin to track it.
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (ContactTypeId)
	This is a small integer that serves as the unique typeid for each type of concrete Contact class.
std::ostream &	operator<< (std::ostream &o, const Contact &c)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (ContactGeometryTypeId)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (ContactCliqueId)
std::ostream &	operator<< (std::ostream &o, const ContactSnapshot &cs)
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 &)
std::ostream &	operator<< (std::ostream &stream, const AtomicInteger &value)
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.
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.
template<class T >
std::ostream &	operator<< (std::ostream &o, const Measure_Differentiate_Result< T > &)
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)
template<class P >
std::ostream &	operator<< (std::ostream &, const Rotation_< P > &)
	Write a Rotation matrix to an output stream by writing out its underlying Mat33.
template<class P >
std::ostream &	operator<< (std::ostream &, const InverseRotation_< P > &)
	Write an InverseRotation matrix to an output stream by writing out its underlying Mat33.
template<int N, class E1 , int S1, class E2 , int S2>
Row< N, E1, S1 >::template Result< Row< N, E2, S2 > >::Add	operator+ (const Row< N, E1, S1 > &l, const Row< N, E2, S2 > &r)
template<int N, class E1 , int S1, class E2 , int S2>
Row< N, E1, S1 >::template Result< Row< N, E2, S2 > >::Sub	operator- (const Row< N, E1, S1 > &l, const Row< N, E2, S2 > &r)
template<int N, class E1 , int S1, class E2 , int S2>
bool	operator== (const Row< N, E1, S1 > &l, const Row< N, E2, S2 > &r)
	bool = v1[i] == v2[i], for all elements i
template<int N, class E1 , int S1, class E2 , int S2>
bool	operator!= (const Row< N, E1, S1 > &l, const Row< N, E2, S2 > &r)
	bool = v1[i] != v2[i], for any element i
template<int N, class E1 , int S1, class E2 , int S2>
bool	operator< (const Row< N, E1, S1 > &l, const Row< N, E2, S2 > &r)
	bool = v1[i] < v2[i], for all elements i
template<int N, class E1 , int S1, class E2 >
bool	operator< (const Row< N, E1, S1 > &v, const E2 &e)
	bool = v[i] < e, for all elements v[i] and element e
template<int N, class E1 , int S1, class E2 , int S2>
bool	operator> (const Row< N, E1, S1 > &l, const Row< N, E2, S2 > &r)
	bool = v1[i] > v2[i], for all elements i
template<int N, class E1 , int S1, class E2 >
bool	operator> (const Row< N, E1, S1 > &v, const E2 &e)
	bool = v[i] > e, for all elements v[i] and element e
template<int N, class E1 , int S1, class E2 , int S2>
bool	operator<= (const Row< N, E1, S1 > &l, const Row< N, E2, S2 > &r)
	bool = v1[i] <= v2[i], for all elements i.
template<int N, class E1 , int S1, class E2 >
bool	operator<= (const Row< N, E1, S1 > &v, const E2 &e)
	bool = v[i] <= e, for all elements v[i] and element e.
template<int N, class E1 , int S1, class E2 , int S2>
bool	operator>= (const Row< N, E1, S1 > &l, const Row< N, E2, S2 > &r)
	bool = v1[i] >= v2[i], for all elements i This is not the same as !(v1<v2).
template<int N, class E1 , int S1, class E2 >
bool	operator>= (const Row< N, E1, S1 > &v, const E2 &e)
	bool = v[i] >= e, for all elements v[i] and element e.
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)
	Read a Row from a stream as M elements separated by white space or by commas, optionally enclosed in () or [] (but no leading "~").
template<int M, class EL , int CSL, int RSL, class ER , int RSR>
bool	operator== (const Mat< M, M, EL, CSL, RSL > &l, const SymMat< M, ER, RSR > &r)
template<int M, class EL , int CSL, int RSL, class ER , int RSR>
bool	operator!= (const Mat< M, M, EL, CSL, RSL > &l, const SymMat< M, ER, RSR > &r)
template<int M, class EL , int RSL, class ER , int CSR, int RSR>
bool	operator== (const SymMat< M, EL, RSL > &l, const Mat< M, M, ER, CSR, RSR > &r)
template<int M, class EL , int RSL, class ER , int CSR, int RSR>
bool	operator!= (const SymMat< M, EL, RSL > &l, const Mat< M, M, ER, CSR, RSR > &r)
template<int M, class E1 , int S1, class E2 , int S2>
CNT< typename CNT< E1 >::THerm > ::template Result< E2 >::Mul	dot (const Vec< M, E1, S1 > &r, const Vec< M, E2, S2 > &v)
template<class E1 , int S1, class E2 , int S2>
CNT< typename CNT< E1 >::THerm > ::template Result< E2 >::Mul	dot (const Vec< 1, E1, S1 > &r, const Vec< 1, E2, S2 > &v)
template<int N, class E1 , int S1, class E2 , int S2>
CNT< E1 >::template Result< E2 > ::Mul	operator* (const Row< N, E1, S1 > &r, const Vec< N, E2, S2 > &v)
template<class E1 , int S1, class E2 , int S2>
CNT< E1 >::template Result< E2 > ::Mul	operator* (const Row< 1, E1, S1 > &r, const Vec< 1, E2, S2 > &v)
template<int N, class E1 , int S1, class E2 , int S2>
CNT< E1 >::template Result< E2 > ::Mul	dot (const Row< N, E1, S1 > &r, const Vec< N, E2, S2 > &v)
template<int M, class E1 , int S1, class E2 , int S2>
CNT< E1 >::template Result< E2 > ::Mul	dot (const Vec< M, E1, S1 > &v, const Row< M, E2, S2 > &r)
template<int N, class E1 , int S1, class E2 , int S2>
CNT< E1 >::template Result< E2 > ::Mul	dot (const Row< N, E1, S1 > &r, const Row< N, E2, S2 > &s)
template<int M, class E1 , int S1, class E2 , int S2>
Mat< M, M, typename CNT< E1 > ::template Result< typename CNT< E2 >::THerm >::Mul >	outer (const Vec< M, E1, S1 > &v, const Vec< M, E2, S2 > &w)
template<int M, class E1 , int S1, class E2 , int S2>
Vec< M, E1, S1 >::template Result< Row< M, E2, S2 > >::Mul	operator* (const Vec< M, E1, S1 > &v, const Row< M, E2, S2 > &r)
template<int M, class E1 , int S1, class E2 , int S2>
Mat< M, M, typename CNT< E1 > ::template Result< E2 >::Mul >	outer (const Vec< M, E1, S1 > &v, const Row< M, E2, S2 > &r)
template<int M, class E1 , int S1, class E2 , int S2>
Mat< M, M, typename CNT< E1 > ::template Result< E2 >::Mul >	outer (const Row< M, E1, S1 > &r, const Vec< M, E2, S2 > &v)
template<int M, class E1 , int S1, class E2 , int S2>
Mat< M, M, typename CNT< E1 > ::template Result< E2 >::Mul >	outer (const Row< M, E1, S1 > &r, const Row< M, E2, S2 > &s)
template<int M, int N, class ME , int CS, int RS, class E , int S>
Mat< M, N, ME, CS, RS > ::template Result< Vec< N, E, S > >::Mul	operator* (const Mat< M, N, ME, CS, RS > &m, const Vec< N, E, S > &v)
template<int M, class E , int S, int N, class ME , int CS, int RS>
Row< M, E, S >::template Result< Mat< M, N, ME, CS, RS > >::Mul	operator* (const Row< M, E, S > &r, const Mat< M, N, ME, CS, RS > &m)
template<int N, class ME , int RS, class E , int S>
SymMat< N, ME, RS >::template Result< Vec< N, E, S > >::Mul	operator* (const SymMat< N, ME, RS > &m, const Vec< N, E, S > &v)
template<class ME , int RS, class E , int S>
SymMat< 1, ME, RS >::template Result< Vec< 1, E, S > >::Mul	operator* (const SymMat< 1, ME, RS > &m, const Vec< 1, E, S > &v)
template<class ME , int RS, class E , int S>
SymMat< 2, ME, RS >::template Result< Vec< 2, E, S > >::Mul	operator* (const SymMat< 2, ME, RS > &m, const Vec< 2, E, S > &v)
template<class ME , int RS, class E , int S>
SymMat< 3, ME, RS >::template Result< Vec< 3, E, S > >::Mul	operator* (const SymMat< 3, ME, RS > &m, const Vec< 3, E, S > &v)
template<int M, class E , int S, class ME , int RS>
Row< M, E, S >::template Result< SymMat< M, ME, RS > >::Mul	operator* (const Row< M, E, S > &r, const SymMat< M, ME, RS > &m)
template<class E , int S, class ME , int RS>
Row< 1, E, S >::template Result< SymMat< 1, ME, RS > >::Mul	operator* (const Row< 1, E, S > &r, const SymMat< 1, ME, RS > &m)
template<class E , int S, class ME , int RS>
Row< 2, E, S >::template Result< SymMat< 2, ME, RS > >::Mul	operator* (const Row< 2, E, S > &r, const SymMat< 2, ME, RS > &m)
template<class E , int S, class ME , int RS>
Row< 3, E, S >::template Result< SymMat< 3, ME, RS > >::Mul	operator* (const Row< 3, E, S > &r, const SymMat< 3, ME, RS > &m)
template<int M, class E1 , int S1, int N, class E2 , int S2>
Vec< M, E1, S1 >::template Result< Row< N, E2, S2 > >::MulNon	operator* (const Vec< M, E1, S1 > &v, const Row< N, E2, S2 > &r)
template<int M, class E1 , int S1, int MM, int NN, class E2 , int CS2, int RS2>
Vec< M, E1, S1 >::template Result< Mat< MM, NN, E2, CS2, RS2 > >::MulNon	operator* (const Vec< M, E1, S1 > &v, const Mat< MM, NN, E2, CS2, RS2 > &m)
template<int M, class E1 , int S1, int MM, class E2 , int RS2>
Vec< M, E1, S1 >::template Result< SymMat< MM, E2, RS2 > >::MulNon	operator* (const Vec< M, E1, S1 > &v, const SymMat< MM, E2, RS2 > &m)
template<int M, class E1 , int S1, int MM, class E2 , int S2>
Vec< M, E1, S1 >::template Result< Vec< MM, E2, S2 > >::MulNon	operator* (const Vec< M, E1, S1 > &v1, const Vec< MM, E2, S2 > &v2)
template<int M, class E , int S, int MM, int NN, class ME , int CS, int RS>
Row< M, E, S >::template Result< Mat< MM, NN, ME, CS, RS > >::MulNon	operator* (const Row< M, E, S > &r, const Mat< MM, NN, ME, CS, RS > &m)
template<int N, class E1 , int S1, int M, class E2 , int S2>
Row< N, E1, S1 >::template Result< Vec< M, E2, S2 > >::MulNon	operator* (const Row< N, E1, S1 > &r, const Vec< M, E2, S2 > &v)
template<int N1, class E1 , int S1, int N2, class E2 , int S2>
Row< N1, E1, S1 >::template Result< Row< N2, E2, S2 > >::MulNon	operator* (const Row< N1, E1, S1 > &r1, const Row< N2, E2, S2 > &r2)
template<int M, int N, class ME , int CS, int RS, int MM, class E , int S>
Mat< M, N, ME, CS, RS > ::template Result< Vec< MM, E, S > >::MulNon	operator* (const Mat< M, N, ME, CS, RS > &m, const Vec< MM, E, S > &v)
template<int M, int N, class ME , int CS, int RS, int NN, class E , int S>
Mat< M, N, ME, CS, RS > ::template Result< Row< NN, E, S > >::MulNon	operator* (const Mat< M, N, ME, CS, RS > &m, const Row< NN, E, S > &r)
template<int M, int N, class ME , int CS, int RS, int Dim, class E , int S>
Mat< M, N, ME, CS, RS > ::template Result< SymMat< Dim, E, S > >::MulNon	operator* (const Mat< M, N, ME, CS, RS > &m, const SymMat< Dim, E, S > &sy)
template<class E1 , int S1, class E2 , int S2>
Vec< 3, typename CNT< E1 > ::template Result< E2 >::Mul >	cross (const Vec< 3, E1, S1 > &a, const Vec< 3, E2, S2 > &b)
template<class E1 , int S1, class E2 , int S2>
Vec< 3, typename CNT< E1 > ::template Result< E2 >::Mul >	operator% (const Vec< 3, E1, S1 > &a, const Vec< 3, E2, S2 > &b)
template<class E1 , int S1, class E2 , int S2>
Row< 3, typename CNT< E1 > ::template Result< E2 >::Mul >	cross (const Vec< 3, E1, S1 > &a, const Row< 3, E2, S2 > &b)
template<class E1 , int S1, class E2 , int S2>
Row< 3, typename CNT< E1 > ::template Result< E2 >::Mul >	operator% (const Vec< 3, E1, S1 > &a, const Row< 3, E2, S2 > &b)
template<class E1 , int S1, class E2 , int S2>
Row< 3, typename CNT< E1 > ::template Result< E2 >::Mul >	cross (const Row< 3, E1, S1 > &a, const Vec< 3, E2, S2 > &b)
template<class E1 , int S1, class E2 , int S2>
Row< 3, typename CNT< E1 > ::template Result< E2 >::Mul >	operator% (const Row< 3, E1, S1 > &a, const Vec< 3, E2, S2 > &b)
template<class E1 , int S1, class E2 , int S2>
Row< 3, typename CNT< E1 > ::template Result< E2 >::Mul >	cross (const Row< 3, E1, S1 > &a, const Row< 3, E2, S2 > &b)
template<class E1 , int S1, class E2 , int S2>
Row< 3, typename CNT< E1 > ::template Result< E2 >::Mul >	operator% (const Row< 3, E1, S1 > &a, const Row< 3, E2, S2 > &b)
template<class E1 , int S1, int N, class E2 , int CS, int RS>
Mat< 3, N, typename CNT< E1 > ::template Result< E2 >::Mul >	cross (const Vec< 3, E1, S1 > &v, const Mat< 3, N, E2, CS, RS > &m)
template<class E1 , int S1, int N, class E2 , int CS, int RS>
Mat< 3, N, typename CNT< E1 > ::template Result< E2 >::Mul >	operator% (const Vec< 3, E1, S1 > &v, const Mat< 3, N, E2, CS, RS > &m)
template<class EV , int SV, class EM , int RS>
Mat< 3, 3, typename CNT< EV > ::template Result< EM >::Mul >	cross (const Vec< 3, EV, SV > &v, const SymMat< 3, EM, RS > &s)
template<class EV , int SV, class EM , int RS>
Mat< 3, 3, typename CNT< EV > ::template Result< EM >::Mul >	operator% (const Vec< 3, EV, SV > &v, const SymMat< 3, EM, RS > &s)
template<class E1 , int S1, int N, class E2 , int CS, int RS>
Mat< 3, N, typename CNT< E1 > ::template Result< E2 >::Mul >	cross (const Row< 3, E1, S1 > &r, const Mat< 3, N, E2, CS, RS > &m)
template<class E1 , int S1, int N, class E2 , int CS, int RS>
Mat< 3, N, typename CNT< E1 > ::template Result< E2 >::Mul >	operator% (const Row< 3, E1, S1 > &r, const Mat< 3, N, E2, CS, RS > &m)
template<class EV , int SV, class EM , int RS>
Mat< 3, 3, typename CNT< EV > ::template Result< EM >::Mul >	cross (const Row< 3, EV, SV > &r, const SymMat< 3, EM, RS > &s)
template<class EV , int SV, class EM , int RS>
Mat< 3, 3, typename CNT< EV > ::template Result< EM >::Mul >	operator% (const Row< 3, EV, SV > &r, const SymMat< 3, EM, RS > &s)
template<int M, class EM , int CS, int RS, class EV , int S>
Mat< M, 3, typename CNT< EM > ::template Result< EV >::Mul >	cross (const Mat< M, 3, EM, CS, RS > &m, const Vec< 3, EV, S > &v)
template<int M, class EM , int CS, int RS, class EV , int S>
Mat< M, 3, typename CNT< EM > ::template Result< EV >::Mul >	operator% (const Mat< M, 3, EM, CS, RS > &m, const Vec< 3, EV, S > &v)
template<class EM , int RS, class EV , int SV>
Mat< 3, 3, typename CNT< EM > ::template Result< EV >::Mul >	cross (const SymMat< 3, EM, RS > &s, const Vec< 3, EV, SV > &v)
template<class EM , int RS, class EV , int SV>
Mat< 3, 3, typename CNT< EM > ::template Result< EV >::Mul >	operator% (const SymMat< 3, EM, RS > &s, const Vec< 3, EV, SV > &v)
template<int M, class EM , int CS, int RS, class ER , int S>
Mat< M, 3, typename CNT< EM > ::template Result< ER >::Mul >	cross (const Mat< M, 3, EM, CS, RS > &m, const Row< 3, ER, S > &r)
template<int M, class EM , int CS, int RS, class ER , int S>
Mat< M, 3, typename CNT< EM > ::template Result< ER >::Mul >	operator% (const Mat< M, 3, EM, CS, RS > &m, const Row< 3, ER, S > &r)
template<class EM , int RS, class EV , int SV>
Mat< 3, 3, typename CNT< EM > ::template Result< EV >::Mul >	cross (const SymMat< 3, EM, RS > &s, const Row< 3, EV, SV > &r)
template<class EM , int RS, class EV , int SV>
Mat< 3, 3, typename CNT< EM > ::template Result< EV >::Mul >	operator% (const SymMat< 3, EM, RS > &s, const Row< 3, EV, SV > &r)
template<class E1 , int S1, class E2 , int S2>
CNT< E1 >::template Result< E2 > ::Mul	cross (const Vec< 2, E1, S1 > &a, const Vec< 2, E2, S2 > &b)
template<class E1 , int S1, class E2 , int S2>
CNT< E1 >::template Result< E2 > ::Mul	operator% (const Vec< 2, E1, S1 > &a, const Vec< 2, E2, S2 > &b)
template<class E1 , int S1, class E2 , int S2>
CNT< E1 >::template Result< E2 > ::Mul	cross (const Row< 2, E1, S1 > &a, const Vec< 2, E2, S2 > &b)
template<class E1 , int S1, class E2 , int S2>
CNT< E1 >::template Result< E2 > ::Mul	operator% (const Row< 2, E1, S1 > &a, const Vec< 2, E2, S2 > &b)
template<class E1 , int S1, class E2 , int S2>
CNT< E1 >::template Result< E2 > ::Mul	cross (const Vec< 2, E1, S1 > &a, const Row< 2, E2, S2 > &b)
template<class E1 , int S1, class E2 , int S2>
CNT< E1 >::template Result< E2 > ::Mul	operator% (const Vec< 2, E1, S1 > &a, const Row< 2, E2, S2 > &b)
template<class E1 , int S1, class E2 , int S2>
CNT< E1 >::template Result< E2 > ::Mul	cross (const Row< 2, E1, S1 > &a, const Row< 2, E2, S2 > &b)
template<class E1 , int S1, class E2 , int S2>
CNT< E1 >::template Result< E2 > ::Mul	operator% (const Row< 2, E1, S1 > &a, const Row< 2, E2, S2 > &b)
template<class E , int S>
Mat< 3, 3, E >	crossMat (const Vec< 3, E, S > &v)
	Calculate matrix M(v) such that M(v)*w = v % w.
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) = (v % w) % 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>
E	det (const Mat< 1, 1, E, CS, RS > &m)
	Special case Mat 1x1 determinant. No computation.
template<class E , int RS>
E	det (const SymMat< 1, E, RS > &s)
	Special case SymMat 1x1 determinant. No computation.
template<class E , int CS, int RS>
E	det (const Mat< 2, 2, E, CS, RS > &m)
	Special case Mat 2x2 determinant. 3 flops (if elements are Real).
template<class E , int RS>
E	det (const SymMat< 2, E, RS > &s)
	Special case 2x2 SymMat determinant. 3 flops (if elements are Real).
template<class E , int CS, int RS>
E	det (const Mat< 3, 3, E, CS, RS > &m)
	Special case Mat 3x3 determinant. 14 flops (if elements are Real).
template<class E , int RS>
E	det (const SymMat< 3, E, RS > &s)
	Special case SymMat 3x3 determinant. 14 flops (if elements are Real).
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<int M, class E , int RS>
E	det (const SymMat< M, E, RS > &s)
	Determinant of SymMat larger than 3x3.
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 Mat inverse: costs one divide.
template<class E , int RS>
SymMat< 1, E, RS >::TInvert	inverse (const SymMat< 1, E, RS > &s)
	Specialized 1x1 SymMat 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 Mat inverse: costs one divide plus 9 flops.
template<class E , int RS>
SymMat< 2, E, RS >::TInvert	inverse (const SymMat< 2, E, RS > &s)
	Specialized 2x2 SymMat inverse: costs one divide plus 7 flops.
template<class E , int CS, int RS>
Mat< 3, 3, E, CS, RS >::TInvert	inverse (const Mat< 3, 3, E, CS, RS > &m)
	Specialized 3x3 inverse: costs one divide plus 41 flops (for real-valued matrices).
template<class E , int RS>
SymMat< 3, E, RS >::TInvert	inverse (const SymMat< 3, E, RS > &s)
	Specialized 3x3 inverse for symmetric or Hermitian: costs one divide plus 29 flops (for real-valued matrices).
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.
SpatialVec	findRelativeVelocity (const Transform &X_FA, const SpatialVec &V_FA, const Transform &X_FB, const SpatialVec &V_FB)
	Find the relative spatial velocity between two frames A and B whose individual spatial velocities are known with respect to a third frame F, with the result returned in A.
SpatialVec	findRelativeVelocityInF (const Vec3 &p_AB_F, const SpatialVec &V_FA, const SpatialVec &V_FB)
	Find the relative spatial velocity between two frames A and B whose individual spatial velocities are known in a third frame F, but leave the result in F.
SpatialVec	reverseRelativeVelocity (const Transform &X_AB, const SpatialVec &V_AB)
	Given the relative velocity of frame B in frame A, reverse that to give the relative velocity of frame A in B.
SpatialVec	reverseRelativeVelocityInA (const Transform &X_AB, const SpatialVec &V_AB)
	Given the relative velocity of frame B in frame A, reverse that to give the relative velocity of frame A in B, but leave the result expressed in frame A.
SpatialVec	shiftVelocityBy (const SpatialVec &V_AB, const Vec3 &r_A)
	Shift a relative spatial velocity measured at some point to that same relative spatial quantity but measured at a new point given by an offset from the old one.
SpatialVec	shiftVelocityFromTo (const SpatialVec &V_A_BP, const Vec3 &fromP_A, const Vec3 &toQ_A)
	Shift a relative spatial velocity measured at some point P to that same relative spatial quantity but measured at a new point Q given the points P and Q.
SpatialVec	shiftForceBy (const SpatialVec &F_AP, const Vec3 &r_A)
	Shift a spatial force applied at some point of a body to that same spatial force applied at a new point given by an offset from the old one.
SpatialVec	shiftForceFromTo (const SpatialVec &F_AP, const Vec3 &fromP_A, const Vec3 &toQ_A)
	Shift a spatial force applied at some point P of a body to that same spatial force applied at a new point Q, given P and Q.
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 z 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>
SymMat< M, E1, S1 >::template Result< SymMat< M, E2, S2 > >::Mul	operator* (const SymMat< M, E1, S1 > &l, const SymMat< M, E2, S2 > &r)
template<int M, class E1 , int S1, class E2 , int S2>
bool	operator== (const SymMat< M, E1, S1 > &l, const SymMat< M, E2, S2 > &r)
template<int M, class E1 , int S1, class E2 , int S2>
bool	operator!= (const SymMat< M, E1, S1 > &l, const SymMat< M, E2, S2 > &r)
template<int M, class E , int S>
SymMat< M, E, S >::template Result< float >::Mul	operator* (const SymMat< M, E, S > &l, const float &r)
template<int M, class E , int S>
SymMat< M, E, S >::template Result< float >::Mul	operator* (const float &l, const SymMat< M, E, S > &r)
template<int M, class E , int S>
SymMat< M, E, S >::template Result< double >::Mul	operator* (const SymMat< M, E, S > &l, const double &r)
template<int M, class E , int S>
SymMat< M, E, S >::template Result< double >::Mul	operator* (const double &l, const SymMat< M, E, S > &r)
template<int M, class E , int S>
SymMat< M, E, S >::template Result< 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.
template<class P >
std::ostream &	operator<< (std::ostream &, const Transform_< P > &)
	Generate formatted output of a Transform to an output stream.
template<class P >
std::ostream &	operator<< (std::ostream &, const InverseTransform_< P > &)
	Generate formatted output of an InverseTransform to an output stream.
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)
	Read a Vec from a stream as M elements separated by white space or by commas, optionally enclosed in () [] ~() or ~[].
	SimTK_ELEMENTWISE_FUNCTION (exp) SimTK_ELEMENTWISE_FUNCTION(log) SimTK_ELEMENTWISE_FUNCTION(sqrt) SimTK_ELEMENTWISE_FUNCTION(sin) SimTK_ELEMENTWISE_FUNCTION(cos) SimTK_ELEMENTWISE_FUNCTION(tan) SimTK_ELEMENTWISE_FUNCTION(asin) SimTK_ELEMENTWISE_FUNCTION(acos) SimTK_ELEMENTWISE_FUNCTION(atan) SimTK_ELEMENTWISE_FUNCTION(sinh) SimTK_ELEMENTWISE_FUNCTION(cosh) SimTK_ELEMENTWISE_FUNCTION(tanh) template< class ELEM > VectorBase< typename CNT< ELEM >
template<class ELEM >
RowVectorBase< typename CNT < ELEM >::TAbs >	abs (const RowVectorBase< ELEM > v)
template<class ELEM >
MatrixBase< typename CNT< ELEM > ::TAbs >	abs (const MatrixBase< ELEM > v)
template<int N, class ELEM >
Vec< N, typename CNT< ELEM > ::TAbs >	abs (const Vec< N, ELEM > v)
template<int N, class ELEM >
Row< N, typename CNT< ELEM > ::TAbs >	abs (const Row< N, ELEM > v)
template<int M, int N, class ELEM >
Mat< M, N, typename CNT< ELEM > ::TAbs >	abs (const Mat< M, N, ELEM > v)
template<int N, class ELEM >
SymMat< N, typename CNT< ELEM > ::TAbs >	abs (const SymMat< N, ELEM > v)
template<class ELEM >
ELEM	sum (const VectorBase< ELEM > v)
template<class ELEM >
ELEM	sum (const RowVectorBase< ELEM > v)
template<class ELEM >
RowVectorBase< ELEM >	sum (const MatrixBase< ELEM > v)
template<int N, class ELEM >
ELEM	sum (const Vec< N, ELEM > v)
template<int N, class ELEM >
ELEM	sum (const Row< N, ELEM > v)
template<int M, int N, class ELEM >
Row< N, ELEM >	sum (const Mat< M, N, ELEM > v)
template<int N, class ELEM >
Row< N, ELEM >	sum (const SymMat< N, ELEM > v)
template<class ELEM >
ELEM	min (const VectorBase< ELEM > v)
template<class ELEM >
ELEM	min (const RowVectorBase< ELEM > v)
template<class ELEM >
RowVectorBase< ELEM >	min (const MatrixBase< ELEM > v)
template<int N, class ELEM >
ELEM	min (const Vec< N, ELEM > v)
template<int N, class ELEM >
ELEM	min (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 i)
bool	signBit (unsigned short i)
bool	signBit (unsigned int i)
bool	signBit (unsigned long i)
bool	signBit (unsigned long long i)
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)
double &	clampInPlace (double low, double &v, double high)
	Check that low <= v <= high and modify v in place if necessary to bring it into that range.
float &	clampInPlace (float low, float &v, float high)
long double &	clampInPlace (long double low, long double &v, long double high)
double &	clampInPlace (int low, double &v, int high)
float &	clampInPlace (int low, float &v, int high)
long double &	clampInPlace (int low, long double &v, int high)
double &	clampInPlace (int low, double &v, double high)
float &	clampInPlace (int low, float &v, float high)
long double &	clampInPlace (int low, long double &v, long double high)
double &	clampInPlace (double low, double &v, int high)
float &	clampInPlace (float low, float &v, int high)
long double &	clampInPlace (long double low, long double &v, int high)
unsigned char &	clampInPlace (unsigned char low, unsigned char &v, unsigned char high)
unsigned short &	clampInPlace (unsigned short low, unsigned short &v, unsigned short high)
unsigned int &	clampInPlace (unsigned int low, unsigned int &v, unsigned int high)
unsigned long &	clampInPlace (unsigned long low, unsigned long &v, unsigned long high)
unsigned long long &	clampInPlace (unsigned long long low, unsigned long long &v, unsigned long long high)
char &	clampInPlace (char low, char &v, char high)
signed char &	clampInPlace (signed char low, signed char &v, signed char high)
short &	clampInPlace (short low, short &v, short high)
int &	clampInPlace (int low, int &v, int high)
long &	clampInPlace (long low, long &v, long high)
long long &	clampInPlace (long long low, long long &v, long long high)
negator< float > &	clampInPlace (float low, negator< float > &v, float high)
negator< double > &	clampInPlace (double low, negator< double > &v, double high)
negator< long double > &	clampInPlace (long double low, negator< long double > &v, long double high)
double	clamp (double low, double v, double high)
	If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v.
float	clamp (float low, float v, float high)
long double	clamp (long double low, long double v, long double high)
double	clamp (int low, double v, int high)
float	clamp (int low, float v, int high)
long double	clamp (int low, long double v, int high)
double	clamp (int low, double v, double high)
float	clamp (int low, float v, float high)
long double	clamp (int low, long double v, long double high)
double	clamp (double low, double v, int high)
float	clamp (float low, float v, int high)
long double	clamp (long double low, long double v, int high)
unsigned char	clamp (unsigned char low, unsigned char v, unsigned char high)
unsigned short	clamp (unsigned short low, unsigned short v, unsigned short high)
unsigned int	clamp (unsigned int low, unsigned int v, unsigned int high)
unsigned long	clamp (unsigned long low, unsigned long v, unsigned long high)
unsigned long long	clamp (unsigned long long low, unsigned long long v, unsigned long long high)
char	clamp (char low, char v, char high)
signed char	clamp (signed char low, signed char v, signed char high)
short	clamp (short low, short v, short high)
int	clamp (int low, int v, int high)
long	clamp (long low, long v, long high)
long long	clamp (long long low, long long v, long long high)
float	clamp (float low, negator< float > v, float high)
double	clamp (double low, negator< double > v, double high)
long double	clamp (long double low, negator< long double > v, long double high)
double	stepUp (double x)
	Interpolate smoothly from 0 up to 1 as the input argument goes from 0 to 1, with first and second derivatives zero at either end of the interval.
double	stepDown (double x)
	Interpolate smoothly from 1 down to 0 as the input argument goes from 0 to 1, with first and second derivatives zero at either end of the interval.
double	stepAny (double y0, double yRange, double x0, double oneOverXRange, double x)
	Interpolate smoothly from y0 to y1 as the input argument goes from x0 to x1, with first and second derivatives zero at either end of the interval.
double	dstepUp (double x)
	First derivative of stepUp(): d/dx stepUp(x).
double	dstepDown (double x)
	First derivative of stepDown(): d/dx stepDown(x).
double	dstepAny (double yRange, double x0, double oneOverXRange, double x)
	First derivative of stepAny(): d/dx stepAny(x).
double	d2stepUp (double x)
	Second derivative of stepUp(): d^2/dx^2 stepUp(x).
double	d2stepDown (double x)
	Second derivative of stepDown(): d^2/dx^2 stepDown(x).
double	d2stepAny (double yRange, double x0, double oneOverXRange, double x)
	Second derivative of stepAny(): d^2/dx^2 stepAny(x).
double	d3stepUp (double x)
	Third derivative of stepUp(): d^3/dx^3 stepUp(x).
double	d3stepDown (double x)
	Third derivative of stepDown(): d^3/dx^3 stepDown(x).
double	d3stepAny (double yRange, double x0, double oneOverXRange, double x)
	Third derivative of stepAny(): d^3/dx^3 stepAny(x).
float	stepUp (float x)
float	stepDown (float x)
float	stepAny (float y0, float yRange, float x0, float oneOverXRange, float x)
float	dstepUp (float x)
float	dstepDown (float x)
float	dstepAny (float yRange, float x0, float oneOverXRange, float x)
float	d2stepUp (float x)
float	d2stepDown (float x)
float	d2stepAny (float yRange, float x0, float oneOverXRange, float x)
float	d3stepUp (float x)
float	d3stepDown (float x)
float	d3stepAny (float yRange, float x0, float oneOverXRange, float x)
long double	stepUp (long double x)
long double	stepDown (long double x)
long double	stepAny (long double y0, long double yRange, long double x0, long double oneOverXRange, long double x)
long double	dstepUp (long double x)
long double	dstepDown (long double x)
long double	dstepAny (long double yRange, long double x0, long double oneOverXRange, long double x)
long double	d2stepUp (long double x)
long double	d2stepDown (long double x)
long double	d2stepAny (long double yRange, long double x0, long double oneOverXRange, long double x)
long double	d3stepUp (long double x)
long double	d3stepDown (long double x)
long double	d3stepAny (long double yRange, long double x0, long double oneOverXRange, long double x)
double	stepUp (int x)
double	stepDown (int 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)
template<class E >
Matrix_< E >	operator* (const MatrixBase< E > &l, int r)
template<class E >
Matrix_< E >	operator* (int l, const MatrixBase< E > &r)
template<class E >
Matrix_< E >	operator/ (const MatrixBase< E > &l, int r)
Global operators involving Vector objects
These operators take VectorBase arguments and produce Vector_ results.
template<class E1 , class E2 >
Vector_< typename CNT< E1 > ::template Result< E2 >::Add >	operator+ (const VectorBase< E1 > &l, const VectorBase< E2 > &r)
template<class E >
Vector_< E >	operator+ (const VectorBase< E > &l, const typename CNT< E >::T &r)
template<class E >
Vector_< E >	operator+ (const typename CNT< E >::T &l, const VectorBase< E > &r)
template<class E1 , class E2 >
Vector_< typename CNT< E1 > ::template Result< E2 >::Sub >	operator- (const VectorBase< E1 > &l, const VectorBase< E2 > &r)
template<class E >
Vector_< E >	operator- (const VectorBase< E > &l, const typename CNT< E >::T &r)
template<class E >
Vector_< E >	operator- (const typename CNT< E >::T &l, const VectorBase< E > &r)
template<class E >
Vector_< E >	operator* (const VectorBase< E > &l, const typename CNT< E >::StdNumber &r)
template<class E >
Vector_< E >	operator* (const typename CNT< E >::StdNumber &l, const VectorBase< E > &r)
template<class E >
Vector_< E >	operator/ (const VectorBase< E > &l, const typename CNT< E >::StdNumber &r)
template<class E >
Vector_< E >	operator* (const VectorBase< E > &l, int r)
template<class E >
Vector_< E >	operator* (int l, const VectorBase< E > &r)
template<class E >
Vector_< E >	operator/ (const VectorBase< E > &l, int r)
Global operators involving RowVector objects
These operators take RowVectorBase arguments and produce RowVector_ results.
template<class E1 , class E2 >
RowVector_< typename CNT< E1 > ::template Result< E2 >::Add >	operator+ (const RowVectorBase< E1 > &l, const RowVectorBase< E2 > &r)
template<class E >
RowVector_< E >	operator+ (const RowVectorBase< E > &l, const typename CNT< E >::T &r)
template<class E >
RowVector_< E >	operator+ (const typename CNT< E >::T &l, const RowVectorBase< E > &r)
template<class E1 , class E2 >
RowVector_< typename CNT< E1 > ::template Result< E2 >::Sub >	operator- (const RowVectorBase< E1 > &l, const RowVectorBase< E2 > &r)
template<class E >
RowVector_< E >	operator- (const RowVectorBase< E > &l, const typename CNT< E >::T &r)
template<class E >
RowVector_< E >	operator- (const typename CNT< E >::T &l, const RowVectorBase< E > &r)
template<class E >
RowVector_< E >	operator* (const RowVectorBase< E > &l, const typename CNT< E >::StdNumber &r)
template<class E >
RowVector_< E >	operator* (const typename CNT< E >::StdNumber &l, const RowVectorBase< E > &r)
template<class E >
RowVector_< E >	operator/ (const RowVectorBase< E > &l, const typename CNT< E >::StdNumber &r)
template<class E >
RowVector_< E >	operator* (const RowVectorBase< E > &l, int r)
template<class E >
RowVector_< E >	operator* (int l, const RowVectorBase< E > &r)
template<class E >
RowVector_< E >	operator/ (const RowVectorBase< E > &l, int r)
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 P , int S>
UnitVec< P, 1 >	operator* (const Rotation_< P > &R, const UnitVec< P, S > &v)
	Rotating a unit vector leaves it unit length, saving us from having to perform an expensive normalization.
template<class P , int S>
UnitRow< P, 1 >	operator* (const UnitRow< P, S > &r, const Rotation_< P > &R)
	Rotating a unit vector leaves it unit length, saving us from having to perform an expensive normalization.
template<class P , int S>
UnitVec< P, 1 >	operator* (const InverseRotation_< P > &R, const UnitVec< P, S > &v)
	Rotating a unit vector leaves it unit length, saving us from having to perform an expensive normalization.
template<class P , int S>
UnitRow< P, 1 >	operator* (const UnitRow< P, S > &r, const InverseRotation_< P > &R)
	Rotating a unit vector leaves it unit length, saving us from having to perform an expensive normalization.
template<class P >
Rotation_< P >	operator* (const Rotation_< P > &R1, const Rotation_< P > &R2)
	Composition of Rotation matrices via operator*.
template<class P >
Rotation_< P >	operator* (const Rotation_< P > &R1, const InverseRotation_< P > &R2)
	Rotating a unit vector leaves it unit length, saving us from having to perform an expensive normalization.
template<class P >
Rotation_< P >	operator* (const InverseRotation_< P > &R1, const Rotation_< P > &R2)
	Rotating a unit vector leaves it unit length, saving us from having to perform an expensive normalization.
template<class P >
Rotation_< P >	operator* (const InverseRotation_< P > &R1, const InverseRotation_< P > &R2)
	Rotating a unit vector leaves it unit length, saving us from having to perform an expensive normalization.
template<class P >
Rotation_< P >	operator/ (const Rotation_< P > &R1, const Rotation_< P > &R2)
	Composition of a Rotation matrix and the inverse of another Rotation via operator/, that is R1/R2 == R1*(~R2).
template<class P >
Rotation_< P >	operator/ (const Rotation_< P > &R1, const InverseRotation &R2)
	Rotating a unit vector leaves it unit length, saving us from having to perform an expensive normalization.
template<class P >
Rotation_< P >	operator/ (const InverseRotation_< P > &R1, const Rotation_< P > &R2)
	Rotating a unit vector leaves it unit length, saving us from having to perform an expensive normalization.
template<class P >
Rotation_< P >	operator/ (const InverseRotation_< P > &R1, const InverseRotation_< P > &R2)
	Rotating a unit vector leaves it unit length, saving us from having to perform an expensive normalization.
template<class P , int S>
Vec< 3, P >	operator* (const Transform_< P > &X_BF, const Vec< 3, P, S > &s_F)
	If we multiply a transform or inverse transform by a 3-vector, we treat the vector as though it had a 4th element "1" appended, that is, it is treated as a station rather than a vector.
template<class P , int S>
Vec< 3, P >	operator* (const InverseTransform_< P > &X_BF, const Vec< 3, P, S > &s_F)
	If we multiply a transform or inverse transform by a 3-vector, we treat the vector as though it had a 4th element "1" appended, that is, it is treated as a station rather than a vector.
template<class P , int S>
Vec< 3, P >	operator* (const Transform_< P > &X_BF, const Vec< 3, negator< P >, S > &s_F)
	If we multiply a transform or inverse transform by a 3-vector, we treat the vector as though it had a 4th element "1" appended, that is, it is treated as a station rather than a vector.
template<class P , int S>
Vec< 3, P >	operator* (const InverseTransform_< P > &X_BF, const Vec< 3, negator< P >, S > &s_F)
	If we multiply a transform or inverse transform by a 3-vector, we treat the vector as though it had a 4th element "1" appended, that is, it is treated as a station rather than a vector.
template<class P , int S>
Vec< 4, P >	operator* (const Transform_< P > &X_BF, const Vec< 4, P, S > &a_F)
	If we multiply a transform or inverse transform by an augmented 4-vector, we use the 4th element to decide how to treat it.
template<class P , int S>
Vec< 4, P >	operator* (const InverseTransform_< P > &X_BF, const Vec< 4, P, S > &a_F)
	If we multiply a transform or inverse transform by a 3-vector, we treat the vector as though it had a 4th element "1" appended, that is, it is treated as a station rather than a vector.
template<class P , int S>
Vec< 4, P >	operator* (const Transform_< P > &X_BF, const Vec< 4, negator< P >, S > &s_F)
	If we multiply a transform or inverse transform by a 3-vector, we treat the vector as though it had a 4th element "1" appended, that is, it is treated as a station rather than a vector.
template<class P , int S>
Vec< 4, P >	operator* (const InverseTransform_< P > &X_BF, const Vec< 4, negator< P >, S > &s_F)
	If we multiply a transform or inverse transform by a 3-vector, we treat the vector as though it had a 4th element "1" appended, that is, it is treated as a station rather than a vector.
template<class P , class E >
Vector_< E >	operator* (const Transform_< P > &X, const VectorBase< E > &v)
	Multiplying a matrix or vector by a Transform_.
template<class P , class E >
Vector_< E >	operator* (const VectorBase< E > &v, const Transform_< P > &X)
	If we multiply a transform or inverse transform by a 3-vector, we treat the vector as though it had a 4th element "1" appended, that is, it is treated as a station rather than a vector.
template<class P , class E >
RowVector_< E >	operator* (const Transform_< P > &X, const RowVectorBase< E > &v)
	If we multiply a transform or inverse transform by a 3-vector, we treat the vector as though it had a 4th element "1" appended, that is, it is treated as a station rather than a vector.
template<class P , class E >
RowVector_< E >	operator* (const RowVectorBase< E > &v, const Transform_< P > &X)
	If we multiply a transform or inverse transform by a 3-vector, we treat the vector as though it had a 4th element "1" appended, that is, it is treated as a station rather than a vector.
template<class P , class E >
Matrix_< E >	operator* (const Transform_< P > &X, const MatrixBase< E > &v)
	If we multiply a transform or inverse transform by a 3-vector, we treat the vector as though it had a 4th element "1" appended, that is, it is treated as a station rather than a vector.
template<class P , class E >
Matrix_< E >	operator* (const MatrixBase< E > &v, const Transform_< P > &X)
	If we multiply a transform or inverse transform by a 3-vector, we treat the vector as though it had a 4th element "1" appended, that is, it is treated as a station rather than a vector.
template<class P , int N, class E , int S>
Vec< N, E >	operator* (const Transform_< P > &X, const Vec< N, E, S > &v)
	If we multiply a transform or inverse transform by a 3-vector, we treat the vector as though it had a 4th element "1" appended, that is, it is treated as a station rather than a vector.
template<class P , int N, class E , int S>
Vec< N, E >	operator* (const Vec< N, E, S > &v, const Transform_< P > &X)
	If we multiply a transform or inverse transform by a 3-vector, we treat the vector as though it had a 4th element "1" appended, that is, it is treated as a station rather than a vector.
template<class P , int N, class E , int S>
Row< N, E >	operator* (const Transform_< P > &X, const Row< N, E, S > &v)
	If we multiply a transform or inverse transform by a 3-vector, we treat the vector as though it had a 4th element "1" appended, that is, it is treated as a station rather than a vector.
template<class P , int N, class E , int S>
Row< N, E >	operator* (const Row< N, E, S > &v, const Transform_< P > &X)
	If we multiply a transform or inverse transform by a 3-vector, we treat the vector as though it had a 4th element "1" appended, that is, it is treated as a station rather than a vector.
template<class P , int M, int N, class E , int CS, int RS>
Mat< M, N, E >	operator* (const Transform_< P > &X, const Mat< M, N, E, CS, RS > &v)
	If we multiply a transform or inverse transform by a 3-vector, we treat the vector as though it had a 4th element "1" appended, that is, it is treated as a station rather than a vector.
template<class P , int M, int N, class E , int CS, int RS>
Mat< M, N, E >	operator* (const Mat< M, N, E, CS, RS > &v, const Transform_< P > &X)
	If we multiply a transform or inverse transform by a 3-vector, we treat the vector as though it had a 4th element "1" appended, that is, it is treated as a station rather than a vector.
template<class P >
Transform_< P >	operator* (const Transform_< P > &X1, const Transform_< P > &X2)
	Composition of transforms.
template<class P >
Transform_< P >	operator* (const Transform_< P > &X1, const InverseTransform_< P > &X2)
	If we multiply a transform or inverse transform by a 3-vector, we treat the vector as though it had a 4th element "1" appended, that is, it is treated as a station rather than a vector.
template<class P >
Transform_< P >	operator* (const InverseTransform_< P > &X1, const Transform_< P > &X2)
	If we multiply a transform or inverse transform by a 3-vector, we treat the vector as though it had a 4th element "1" appended, that is, it is treated as a station rather than a vector.
template<class P >
Transform_< P >	operator* (const InverseTransform_< P > &X1, const InverseTransform_< P > &X2)
	If we multiply a transform or inverse transform by a 3-vector, we treat the vector as though it had a 4th element "1" appended, that is, it is treated as a station rather than a vector.
template<class P >
bool	operator== (const Transform_< P > &X1, const Transform_< P > &X2)
	Comparison operators return true only if the two transforms are bit identical; that's not too useful.
template<class P >
bool	operator== (const InverseTransform_< P > &X1, const InverseTransform_< P > &X2)
	If we multiply a transform or inverse transform by a 3-vector, we treat the vector as though it had a 4th element "1" appended, that is, it is treated as a station rather than a vector.
template<class P >
bool	operator== (const Transform_< P > &X1, const InverseTransform_< P > &X2)
	If we multiply a transform or inverse transform by a 3-vector, we treat the vector as though it had a 4th element "1" appended, that is, it is treated as a station rather than a vector.
template<class P >
bool	operator== (const InverseTransform_< P > &X1, const Transform_< P > &X2)
	If we multiply a transform or inverse transform by a 3-vector, we treat the vector as though it had a 4th element "1" appended, that is, it is treated as a station rather than a vector.

---

Detailed Description

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

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 ArticulatedInertia_<Real> ArticulatedInertia

An articulated body inertia matrix at default precision.

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 ArticulatedInertia_<double> dArticulatedInertia

An articulated body inertia matrix at double precision.

typedef Gyration_<double> dGyration

A gyration (unit inertia) tensor at double precision.

typedef Inertia_<double> dInertia

An inertia tensor at double precision.

typedef InverseRotation_<double> dInverseRotation

typedef Quaternion_<double> dQuaternion

typedef Rotation_<double> dRotation

typedef SpatialInertia_<double> dSpatialInertia

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

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

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

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

typedef Transform_<double> dTransform

typedef ArticulatedInertia_<float> fArticulatedInertia

An articulated body inertia matrix at float precision.

typedef Gyration_<float> fGyration

A gyration (unit inertia) tensor at float precision.

typedef Inertia_<float> fInertia

An inertia tensor at float precision.

typedef InverseRotation_<float> fInverseRotation

typedef ForceSubsystem::Guts ForceSubsystemRep

typedef Quaternion_<float> fQuaternion

typedef Rotation_<float> fRotation

typedef SpatialInertia_<float> fSpatialInertia

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

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

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

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

typedef Transform_<float> fTransform

typedef Function_<Real> Function

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

typedef Gyration_<Real> Gyration

A gyration (unit inertia) tensor at default precision.

typedef Inertia_<Real> Inertia

An inertia tensor at default precision.

typedef InverseRotation_<Real> InverseRotation

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 Measure_<Real> Measure

A convenient abbreviation for the most common kind of Measure -- one which returns a single Real result.

typedef Quaternion_<Real> Quaternion

typedef Rotation_<Real> Rotation

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 SpatialInertia_<Real> SpatialInertia

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

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 Transform_<Real> Transform

typedef UnitVec<Real,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().

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, P, S >::abs(), Row< 3, P, 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/=().

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<3,3,typename CNT<EM>::template Result<EV>::Mul> SimTK::cross	(	const SymMat< 3, EM, RS > &	s,
		const Row< 3, EV, SV > &	r
	)			[inline]

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

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<3,3,typename CNT<EM>::template Result<EV>::Mul> SimTK::cross	(	const SymMat< 3, EM, RS > &	s,
		const Vec< 3, EV, SV > &	v
	)			[inline]

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,3,typename CNT<EV>::template Result<EM>::Mul> SimTK::cross	(	const Row< 3, EV, SV > &	r,
		const SymMat< 3, EM, RS > &	s
	)			[inline]

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

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,3,typename CNT<EV>::template Result<EM>::Mul> SimTK::cross	(	const Vec< 3, EV, SV > &	v,
		const SymMat< 3, EM, RS > &	s
	)			[inline]

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(), MassProperties::toSpatialMat(), and PhiMatrix::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) = (v % w) % v.

S is a symmetric, 3x3 matrix with nonnegative diagonals that obey the triangle inequality. If M(v) = crossMat(v), then S(v) = square(M(v)) = ~M(v)*M(v) = -M(v)*M(v) since M is skew symmetric.

Also, S(v) = dot(v,v)*I - outer(v,v) = ~v*v*I - v*~v, where I is the identity matrix. This is the form necessary for shifting inertia matrices using the parallel axis theorem, something we do a lot of in multibody dynamics. Consequently we want to calculate S very efficiently, which we can do because it has the following very simple form. Assume v=[x y z]. Then

             y^2+z^2      T         T
     S(v) =    -xy     x^2+z^2      T
               -xz       -yz     x^2+y^2
    

where "T" indicates that the element is identical to the symmetric one. 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(), and Gyration_< P >::pointMassAt().

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 SymMat< M, E, RS > &

s

)

[inline]

Determinant of SymMat larger than 3x3.

TODO: This should be done instead with a symmetric factorization; the determinant will be calculable as a product of some diagonal in the factorization. For now we'll punt to the really bad Mat determinant above.

References det().

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 SymMat< 3, E, RS > &

s

)

[inline]

Special case SymMat 3x3 determinant. 14 flops (if elements are Real).

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

E SimTK::det

(

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

m

)

[inline]

Special case Mat 3x3 determinant. 14 flops (if elements are Real).

E SimTK::det

(

const SymMat< 2, E, RS > &

s

)

[inline]

Special case 2x2 SymMat determinant. 3 flops (if elements are Real).

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

E SimTK::det

(

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

m

)

[inline]

Special case Mat 2x2 determinant. 3 flops (if elements are Real).

E SimTK::det

(

const SymMat< 1, E, RS > &

s

)

[inline]

Special case SymMat 1x1 determinant. No computation.

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

E SimTK::det

(

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

m

)

[inline]

Special case Mat 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().

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

SymMat<3,E,RS>::TInvert SimTK::inverse

(

const SymMat< 3, E, RS > &

s

)

[inline]

Specialized 3x3 inverse for symmetric or Hermitian: costs one divide plus 29 flops (for real-valued matrices).

No pivoting done here so this may be subject to numerical errors that Lapack would avoid. Call lapackSymInverse() instead if you're worried.

See also:

lapackSymInverse()

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

(

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

m

)

[inline]

Specialized 3x3 inverse: costs one divide plus 41 flops (for real-valued matrices).

No pivoting done here so this may be subject to numerical errors that Lapack would avoid. Call lapackInverse() instead if you're worried.

See also:

lapackInverse()

SymMat<2,E,RS>::TInvert SimTK::inverse

(

const SymMat< 2, E, RS > &

s

)

[inline]

Specialized 2x2 SymMat inverse: costs one divide plus 7 flops.

References det().

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

(

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

m

)

[inline]

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

References det().

SymMat<1,E,RS>::TInvert SimTK::inverse

(

const SymMat< 1, E, RS > &

s

)

[inline]

Specialized 1x1 SymMat inverse: costs one divide.

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

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

(

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

m

)

[inline]

Specialized 1x1 Mat inverse: costs one divide.

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 AssemblyCondition::calcGoal(), Test::defTol2(), Implementation::getDependsOnStageVirtual(), Spline_< T >::getMaxDerivativeOrder(), Polynomial::getMaxDerivativeOrder(), Linear::getMaxDerivativeOrder(), Constant::getMaxDerivativeOrder(), Implementation::getNumTimeDerivativesVirtual(), Vec< 3, P, S >::isNumericallyEqual(), SymMat< 3, P >::isNumericallyEqual(), Row< 3, P, S >::isNumericallyEqual(), isNumericallyEqual(), Mat< 3, 3, P >::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 SymMat< M, EL, RSL > &	l,
		const Mat< M, M, ER, CSR, RSR > &	r
	)			[inline]

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

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

bool = v1[i] != v2[i], for any element i

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<3,3,typename CNT<EM>::template Result<EV>::Mul> SimTK::operator%	(	const SymMat< 3, EM, RS > &	s,
		const Row< 3, EV, SV > &	r
	)			[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<3,3,typename CNT<EM>::template Result<EV>::Mul> SimTK::operator%	(	const SymMat< 3, EM, RS > &	s,
		const Vec< 3, EV, SV > &	v
	)			[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,3,typename CNT<EV>::template Result<EM>::Mul> SimTK::operator%	(	const Row< 3, EV, SV > &	r,
		const SymMat< 3, EM, RS > &	s
	)			[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,3,typename CNT<EV>::template Result<EM>::Mul> SimTK::operator%	(	const Vec< 3, EV, SV > &	v,
		const SymMat< 3, EM, RS > &	s
	)			[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_<P> SimTK::operator*	(	const InverseTransform_< P > &	X1,
		const InverseTransform_< P > &	X2
	)			[inline]

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

This way we use both the rotational and translational components of the transform.

References InverseTransform_< P >::compose().

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

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

This way we use both the rotational and translational components of the transform.

References InverseTransform_< P >::compose().

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

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

This way we use both the rotational and translational components of the transform.

References Transform_< P >::compose().

Transform_<P> SimTK::operator*	(	const Transform_< P > &	X1,
		const Transform_< P > &	X2
	)			[inline]

Composition of transforms.

Operators are provided for all the combinations of transform and inverse transform.

References Transform_< P >::compose().

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

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

This way we use both the rotational and translational components of the transform.

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

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

This way we use both the rotational and translational components of the transform.

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

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

This way we use both the rotational and translational components of the transform.

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

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

This way we use both the rotational and translational components of the transform.

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

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

This way we use both the rotational and translational components of the transform.

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

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

This way we use both the rotational and translational components of the transform.

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

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

This way we use both the rotational and translational components of the transform.

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

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

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

This way we use both the rotational and translational components of the transform.

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

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

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

This way we use both the rotational and translational components of the transform.

References RowVectorBase< ELT >::size().

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

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

This way we use both the rotational and translational components of the transform.

References RowVectorBase< ELT >::size().

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

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

This way we use both the rotational and translational components of the transform.

References VectorBase< ELT >::size().

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

Multiplying a matrix or vector by a Transform_.

applies it to each element individually.

References VectorBase< ELT >::size().

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

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

This way we use both the rotational and translational components of the transform.

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

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

This way we use both the rotational and translational components of the transform.

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

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

This way we use both the rotational and translational components of the transform.

References Vec< M, ELT, STRIDE >::getAs(), InverseTransform_< P >::shiftFrameStationToBase(), Vec< M, ELT, STRIDE >::updAs(), and InverseTransform_< P >::xformFrameVecToBase().

Vec<4,P> SimTK::operator*	(	const Transform_< P > &	X_BF,
		const Vec< 4, P, S > &	a_F
	)			[inline]

If we multiply a transform or inverse 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< M, ELT, STRIDE >::getAs(), Transform_< P >::shiftFrameStationToBase(), Vec< M, ELT, STRIDE >::updAs(), and Transform_< P >::xformFrameVecToBase().

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

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

This way we use both the rotational and translational components of the transform.

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

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

This way we use both the rotational and translational components of the transform.

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

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

This way we use both the rotational and translational components of the transform.

References InverseTransform_< P >::shiftFrameStationToBase().

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

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

This way we use both the rotational and translational components of the transform.

References Transform_< P >::shiftFrameStationToBase().

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]

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

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_<P> SimTK::operator*	(	const InverseRotation_< P > &	R1,
		const InverseRotation_< P > &	R2
	)			[inline]

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

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

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

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

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

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

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

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

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

Composition of Rotation matrices via operator*.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

References Rotation_< P >::asMat33(), and UnitVec< P, 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]

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*	(	int	l,
		const RowVectorBase< E > &	r
	)			[inline]

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

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*	(	int	l,
		const VectorBase< E > &	r
	)			[inline]

Vector_<E> SimTK::operator*	(	const VectorBase< E > &	l,
		int	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*	(	int	l,
		const MatrixBase< E > &	r
	)			[inline]

Matrix_<E> SimTK::operator*	(	const MatrixBase< E > &	l,
		int	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]

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> >::Sub SimTK::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]

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_<P> SimTK::operator/	(	const InverseRotation_< P > &	R1,
		const InverseRotation_< P > &	R2
	)			[inline]

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

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

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

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

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

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

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

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

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

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

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]

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

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]

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

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]

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

Mat<M,N,E,CS,RS>::template Result<float>::Dvd SimTK::operator/	(	const Mat< M, N, E, CS, RS > &	l,
		const float &	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,
		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,
		int	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,
		int	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

bool SimTK::operator<	(	const Row< N, E1, S1 > &	v,
		const E2 &	e
	)			[inline]

bool = v[i] < e, for all elements v[i] and element e

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

bool = v1[i] < v2[i], for all elements i

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 &	,
		const InverseTransform_< P > &
	)			[inline]

Generate formatted output of an InverseTransform to an output stream.

std::ostream& SimTK::operator<<	(	std::ostream &	,
		const Transform_< P > &
	)			[inline]

Generate formatted output of a Transform to an output stream.

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 &	,
		const InverseRotation_< P > &
	)			[inline]

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

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

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

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

References HANDLE.

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::ostream& SimTK::operator<<	(	std::ostream &	o,
		const Measure_Differentiate_Result< T > &
	)			[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 &	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 &	stream,
		const AtomicInteger &	value
	)

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 &	o,
		const ContactSnapshot &	cs
	)			[inline]

References ContactSnapshot::getNumContacts(), and ContactSnapshot::getTimestamp().

std::ostream& SimTK::operator<<	(	std::ostream &	o,
		const Contact &	c
	)			[inline]

References Contact::getCondition(), Contact::getContactId(), Contact::getSurface1(), Contact::getSurface2(), Contact::getTypeId(), and Contact::nameOfCondition().

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

References ContactForce::m_contactId, ContactForce::m_contactPt, ContactForce::m_forceOnSurface2, ContactForce::m_potentialEnergy, and ContactForce::m_powerLoss.

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 Row< N, E1, S1 > &	v,
		const E2 &	e
	)			[inline]

bool = v[i] <= e, for all elements v[i] and element e.

This is not the same as !(v1>e).

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

bool = v1[i] <= v2[i], for all elements i.

This is not the same as !(v1>v2).

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_< P > &	X1,
		const Transform_< P > &	X2
	)			[inline]

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

This way we use both the rotational and translational components of the transform.

References Transform_< P >::p(), InverseTransform_< P >::p(), Transform_< P >::R(), and InverseTransform_< P >::R().

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

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

This way we use both the rotational and translational components of the transform.

References InverseTransform_< P >::p(), Transform_< P >::p(), InverseTransform_< P >::R(), and Transform_< P >::R().

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

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

This way we use both the rotational and translational components of the transform.

References InverseTransform_< P >::p(), and InverseTransform_< P >::R().

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

Comparison operators return true only if the two transforms are bit identical; that's not too useful.

References Transform_< P >::p(), and Transform_< P >::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 SymMat< M, EL, RSL > &	l,
		const Mat< M, M, ER, CSR, RSR > &	r
	)			[inline]

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

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

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

bool = v1[i] == v2[i], for all elements i

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]

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 Row< N, E1, S1 > &	v,
		const E2 &	e
	)			[inline]

bool = v[i] > e, for all elements v[i] and element e

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

bool = v1[i] > v2[i], for all elements i

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 Row< N, E1, S1 > &	v,
		const E2 &	e
	)			[inline]

bool = v[i] >= e, for all elements v[i] and element e.

This is not the same as !(v1<e).

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

bool = v1[i] >= v2[i], for all elements i This is not the same as !(v1<v2).

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

Read a Vec from a stream as M elements separated by white space or by commas, optionally enclosed in () [] ~() or ~[].

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]

Read a Row from a stream as M elements separated by white space or by commas, optionally enclosed in () or [] (but no leading "~").

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 z 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

(

ContactCliqueId

)

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

ContactGeometryTypeId

)

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

ContactTypeId

)

This is a small integer that serves as the unique typeid for each type of concrete Contact class.

This is used to select an appropriate contact response method for a given type of Contact. This Id is unique across all threads of a given program execution but you can't expect to get the same Id for different programs or different executions of the same program.

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

ContactId

)

This is a unique integer Id assigned to each contact pair when we first begin to track it.

The Id persists for as long as we are tracking this pair of surfaces; it is the basis for our notions of "the same contact" and "continuing contact". After we stop tracking a contact pair, its Id will not refer to any contact pair and any given Id will not be reused for a very long time; hence, these will typically be large numbers even if there are only a small number of contacts at any given moment. The Id is unique only within an instance of ContactTrackerSubsystem.

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

ContactSurfaceIndex

)

This defines a unique index for all the contact surfaces being handled either by a ContactTrackerSubsystem or within a single ContactSet of a GeneralContactSubsystem.

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_DEFINE_UNIQUE_INDEX_TYPE

(

AssemblyConditionIndex

)

SimTK::SimTK_ELEMENTWISE_FUNCTION

(

exp

)

References VectorBase< ELT >::abs().

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