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	Exception
namespace	Impl
Classes
class	Assembler
	This Study attempts to find a configuration (set of joint coordinates q) of a Simbody MultibodySystem that satisfies the System's position Constraints plus optional additional assembly conditions. More...
class	AssemblyCondition
	Define an assembly condition consisting of a scalar goal and/or a related set of assembly error equations (that is, an objective and/or some constraints). More...
class	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	EllipticalPointContact
	This subclass of Contact represents a contact between two non-conforming surfaces 1 and 2 that initially meet at a point and where each surface has two principal curvatures (maximum and minimum) in perpendicular directions. More...
class	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 contact surface. 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	EllipticalPointContactImpl
	This is the internal implementation class for EllipticalPointContact. 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	DecorationGenerator
	A DecorationGenerator is used to define geometry that may change over the course of a simulation. More...
class	DecorationSubsystem
	This is the client-side handle class encapsulating the hidden implementation of the DecorationSubsystem. More...
class	ElasticFoundationForce
	This class implements an elastic foundation or "bed of springs" contact model. More...
class	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, which include a body and a particular kind of mobilizer (joint) connecting that body to its parent. 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	Visualizer
	Provide simple visualization of and interaction with a Simbody simulation, with real time control of the frame rate. There are several operating modes available, including real time operation permitting responsive user interaction with the simulation. More...
class	MatrixBase
	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	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	AnalyticGeometry
	This abstract class represents a piece of high-quality geometry that can be used for valid physical simulation. More...
class	AnalyticCurve
class	AnalyticSurface
class	AnalyticVolume
class	AnalyticLine
	An analytic line has only a length. More...
class	AnalyticCircle
	An analytic circle has only a radius. More...
class	AnalyticSphere
class	AnalyticCylinder
	The coordinate frame of the central cross section is the same as for a circle; that is, x and z are radial and y points along the cylinder's axis. More...
class	AnalyticBrick
	This is a rectangular solid. More...
class	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	PolygonalMesh
	This class provides a description of a mesh made of polygonal faces. 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	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...
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	Function_
	This abstract class represents a mathematical function that calculates a value of arbitrary type based on M real arguments. More...
class	Parallel2DExecutor
	This class is used for performing multithreaded computations over two dimensional ranges. More...
class	ParallelExecutor
	This class is used for performing multithreaded computations. More...
class	ParallelWorkQueue
	This class is used for performing multithreaded computations. It maintains a queue of tasks to be executed, and a pool of threads for executing them. More...
class	Pathname
	This class encapsulates the handling of file and directory pathnames in a platform-independent manner. More...
class	Plugin
	This is the base class for representing a runtime-linked dynamic library, also known as a "plugin", in a platform-independent manner. More...
class	PIMPLHandle
	This class provides some infrastructure useful in making SimTK Private Implementation (PIMPL) classes. More...
class	PIMPLImplementation
	This class provides some infrastructure useful in creating PIMPL Implementation classes (the ones referred to by Handles). More...
class	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	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	ThreadLocal
	This class represents a "thread local" variable: one which has a different value on each thread. 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	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	CoordinateAxis
	This class, along with its sister class CoordinateDirection, provides convenient manipulation of the three coordinate axes via the definition of three constants XAxis, YAxis, and ZAxis each with a unique subtype and implicit conversion to the integers 0, 1, and 2 whenever necessary. Methods are provided to allow code to be written once that can be used to work with the axes in any order. More...
class	CoordinateDirection
	A CoordinateDirection is a CoordinateAxis plus a direction indicating the positive or negative direction along that axis. More...
class	Inertia_
	The physical meaning of an inertia is the distribution of a rigid body's mass about a particular point. More...
class	UnitInertia_
	A UnitInertia matrix is a unit-mass inertia matrix; you can convert it to an Inertia by multiplying it by the actual body mass. More...
class	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	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	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	PhiMatrix
class	PhiMatrixTranspose
class	Transform_
	This class represents the rotate-and-shift transform which gives the location and orientation of a new frame F in a base (reference) frame B. More...
class	InverseTransform_
	Transform from frame B to frame F, but with the internal representation inverted. More...
class	UnitVec
	This class is a Vec3 plus an ironclad guarantee either that: 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	PolynomialRootFinder
	This class provides static methods for finding the roots of polynomials. More...
class	Random
	This class defines the interface for pseudo-random number generators. More...
class	CNT
	Specialized information about Composite Numerical Types which allows us to define appropriate templatized classes using them. More...
struct	Wider
struct	Wider< float, float >
struct	Wider< float, double >
struct	Wider< double, float >
struct	Wider< double, double >
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	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	Event
	An Event is "something that happens" during a Study that is advancing through time. More...
class	EventTriggerInfo
	This class is used to communicate between the System and an Integrator regarding the properties of a particular event trigger function. More...
class	EventHandler
	An EventHandler is an object that defines an event that can occur within a system. More...
class	ScheduledEventHandler
	ScheduledEventHandler is a subclass of EventHandler for events that occur at a particular time that is known in advance. More...
class	TriggeredEventHandler
	TriggeredEventHandler is a subclass of EventHandler for events that occur when some condition is satisfied within the system. More...
class	PeriodicEventHandler
	PeriodicEventHandler is a subclass of ScheduledEventHandler which generates a series of uniformly spaced events at regular intervals. More...
class	EventReporter
	An EventReporter is an object that defines an event that can occur within a system. More...
class	ScheduledEventReporter
	ScheduledEventReporter is a subclass of EventReporter for events that occur at a particular time that is known in advance. More...
class	TriggeredEventReporter
	TriggeredEventReporter is a subclass of EventReporter for events that occur when some condition is satisfied within the system. More...
class	PeriodicEventReporter
	PeriodicEventReporter is a subclass of ScheduledEventReporter which generates a series of uniformly spaced events at regular intervals. More...
class	AbstractMeasure
	This is the base class for all Measure handle classes. More...
class	Measure_
	This is the base handle class for all Measures whose value type is known. More...
class	Measure_Differentiate_Result
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	Study
class	Subsystem
	The abstract parent of all Subsystems. More...
class	System
	The handle class which serves as the abstract parent of all System handles. More...
class	DefaultSystemSubsystem
	This is a concrete Subsystem that is part of every System. It provides a variety of services for the System, such as maintaining lists of event handlers and reporters, and acting as a source of globally unique event IDs. More...
class	Mat
	CS is total spacing between columns in memory (default M) RS is total spacing between rows in memory (default 1) More...
class	Row
	Generic Row. More...
class	SymMat
	RS is total spacing between rows in memory (default 1) More...
class	Vec
	Generic Vec. 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	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
	Base class for the various matrix factorizations. More...
class	FactorLU
	Class for performing LU matrix factorizations. More...
class	FactorQTZ
	Class to perform a QTZ (linear least squares) factorization. More...
class	Eigen
	Class to compute Eigen values and Eigen vectors of a matrix. More...
class	FactorSVD
	Class to compute a singular value decomposition of a matrix. More...
class	OptimizerSystem
	Abstract class which defines an objective/cost function which is optimized by and Optimizer object. More...
class	Optimizer
	API for SimTK Simmath's optimizers. More...
class	CPodesIntegrator
	This is an Integrator based on the CPODES library. More...
class	ExplicitEulerIntegrator
	This is an Integrator based on the explicit Euler algorithm. More...
class	Integrator
	An Integrator is an object that can simulate the behavior of a System through time. More...
class	CPodesSystem
	This abstract class defines the system to be integrated with SimTK CPodes. More...
class	CPodes
	This is a straightforward translation of the Sundials CPODES C interface into C++. More...
class	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	MobilizedBodyIndex
	This is for arrays indexed by mobilized body number within a subsystem (typically the SimbodyMatterSubsystem). It is assigned when a MobilizedBody is added to a subsystem. You can abbreviate this as MobodIndex if you prefer. More...
class	ConstraintIndex
	This is for arrays indexed by constraint number within a subsystem (typically the SimbodyMatterSubsystem). It is assigned when a Constraint is added to the subsystem. More...
class	MobilizerQIndex
	The Mobilizer associated with each MobilizedBody, once modeled, has a specific number of generalized coordinates q (0-7) and generalized speeds (mobilities) u (0-6). This is the index type for the small array of Mobilizer-local q's. More...
class	MobilizerUIndex
	The Mobilizer associated with each MobilizedBody, once modeled, has a specific number of generalized coordinates q (0-7) and generalized speeds (mobilities) u (0-6). This is the index type for the small array of Mobilizer-local u's. More...
class	ForceIndex
	This type represents the index of a Force element within its subsystem. More...
class	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. More...
class	ContactId
	This is a unique integer Id assigned to each contact pair when we first begin to track it. More...
class	ContactTypeId
	This is a small integer that serves as the unique typeid for each type of concrete Contact class. More...
class	ContactGeometryTypeId
	This is a unique integer type for quickly identifying specific types of contact geometry for fast lookup purposes. More...
class	EventId
	This is a class to represent unique IDs for events in a type-safe way. More...
class	SubsystemIndex
	Provide a unique integer type for identifying Subsystems. More...
class	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. More...
class	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. More...
class	QIndex
	Unique integer type for Subsystem-local q indexing. More...
class	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. More...
class	UIndex
	Unique integer type for Subsystem-local u indexing. More...
class	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. More...
class	ZIndex
	Unique integer type for Subsystem-local z indexing. More...
class	DiscreteVariableIndex
	This unique integer type is for selecting discrete variables. More...
class	CacheEntryIndex
	This unique integer type is for selecting non-shared cache entries. More...
class	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. More...
class	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. More...
class	QErrIndex
	Unique integer type for Subsystem-local qErr indexing. More...
class	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. More...
class	UErrIndex
	Unique integer type for Subsystem-local uErr indexing. More...
class	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. More...
class	UDotErrIndex
	Unique integer type for Subsystem-local uDotErr indexing. More...
class	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. More...
class	MultiplierIndex
	Unique integer type for Subsystem-local multiplier indexing. More...
Typedefs
typedef MobilizedBodyIndex	MobodIndex
	This is the approved abbeviation for MobilizedBodyIndex. Feel free to use it if you get tired of typing or seeing the full name.
typedef ForceSubsystem::Guts	ForceSubsystemRep
typedef Visualizer	VTKVisualizer
	OBSOLETE: This provides limited backwards compatibility with the old VTK Visualizer that is no longer supported. Switch to Visualizer instead.
typedef Visualizer::Reporter	VTKEventReporter
	OBSOLETE: This provides limited backwards compatibility with the old VTK Visualizer that is no longer supported. Switch to Visualizer::Reporter instead.
typedef Vector_< Real >	Vector
typedef Vector_< float >	fVector
typedef Vector_< double >	dVector
typedef Vector_< Complex >	ComplexVector
typedef Vector_< fComplex >	fComplexVector
typedef Vector_< dComplex >	dComplexVector
typedef VectorView_< Real >	VectorView
typedef VectorView_< float >	fVectorView
typedef VectorView_< double >	dVectorView
typedef VectorView_< Complex >	ComplexVectorView
typedef VectorView_< fComplex >	fComplexVectorView
typedef VectorView_< dComplex >	dComplexVectorView
typedef RowVector_< Real >	RowVector
typedef RowVector_< float >	fRowVector
typedef RowVector_< double >	dRowVector
typedef RowVector_< Complex >	ComplexRowVector
typedef RowVector_< fComplex >	fComplexRowVector
typedef RowVector_< dComplex >	dComplexRowVector
typedef RowVectorView_< Real >	RowVectorView
typedef RowVectorView_< float >	fRowVectorView
typedef RowVectorView_< double >	dRowVectorView
typedef RowVectorView_< Complex >	ComplexRowVectorView
typedef RowVectorView_< fComplex >	fComplexRowVectorView
typedef RowVectorView_< dComplex >	dComplexRowVectorView
typedef Matrix_< Real >	Matrix
typedef Matrix_< float >	fMatrix
typedef Matrix_< double >	dMatrix
typedef Matrix_< Complex >	ComplexMatrix
typedef Matrix_< fComplex >	fComplexMatrix
typedef Matrix_< dComplex >	dComplexMatrix
typedef MatrixView_< Real >	MatrixView
typedef MatrixView_< float >	fMatrixView
typedef MatrixView_< double >	dMatrixView
typedef MatrixView_< Complex >	ComplexMatrixView
typedef MatrixView_< fComplex >	fComplexMatrixView
typedef MatrixView_< dComplex >	dComplexMatrixView
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
	Spatial vectors are used for (rotation,translation) quantities and consist of a pair of Vec3 objects, arranged as a 2-vector of 3-vectors.
typedef Vec< 2, Vec< 3, float > >	fSpatialVec
	A SpatialVec that is always single (float) precision regardless of the compiled-in precision of Real.
typedef Vec< 2, Vec< 3, double > >	dSpatialVec
	A SpatialVec that is always double precision regardless of the compiled-in precision of Real.
typedef Row< 2, Row3 >	SpatialRow
	This is the type of a transposed SpatialVec; it does not usually appear explicitly in user programs.
typedef Row< 2, Row< 3, float > >	fSpatialRow
	A SpatialRow that is always single (float) precision regardless of the compiled-in precision of Real.
typedef Row< 2, Row< 3, double > >	dSpatialRow
	A SpatialRow that is always double precision regardless of the compiled-in precision of Real.
typedef Mat< 2, 2, Mat33 >	SpatialMat
	Spatial matrices are used to hold 6x6 matrices that are best viewed as 2x2 matrices of 3x3 matrices; most commonly for spatial and articulated body inertias and spatial shift matrices.
typedef Mat< 2, 2, Mat < 3, 3, float > >	fSpatialMat
	A SpatialMat that is always single (float) precision regardless of the compiled-in precision of Real.
typedef Mat< 2, 2, Mat < 3, 3, double > >	dSpatialMat
	A SpatialMat that is always double precision regardless of the compiled-in precision of Real.
typedef UnitInertia_< Real >	UnitInertia
	A unit inertia (gyration) tensor at default precision.
typedef UnitInertia_< float >	fUnitInertia
	A unit inertia (gyration) tensor at float precision.
typedef UnitInertia_< double >	dUnitInertia
	A unit inertia (gyration) 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 MassProperties_< Real >	MassProperties
	Rigid body mass properties at default precision.
typedef MassProperties_< float >	fMassProperties
	Rigid body mass properties at float precision.
typedef MassProperties_< double >	dMassProperties
	Rigid body mass properties 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 UnitInertia	Gyration
	For backwards compatibility only; use UnitInertia instead.
typedef Quaternion_< Real >	Quaternion
typedef Quaternion_< float >	fQuaternion
typedef Quaternion_< double >	dQuaternion
typedef Rotation_< Real >	Rotation
typedef Rotation_< float >	fRotation
typedef Rotation_< double >	dRotation
typedef InverseRotation_< Real >	InverseRotation
typedef InverseRotation_< float >	fInverseRotation
typedef InverseRotation_< double >	dInverseRotation
typedef Transform_< Real >	Transform
typedef Transform_< float >	fTransform
typedef Transform_< double >	dTransform
typedef UnitVec< Real, 1 >	UnitVec3
typedef UnitVec< float, 1 >	fUnitVec3
typedef UnitVec< double, 1 >	dUnitVec3
typedef conjugate< Real >	Conjugate
typedef Measure_< Real >	Measure
	A convenient abbreviation for the most common kind of Measure -- one which returns a single Real result.
typedef int	StageVersion
	This is the type to use for Stage version numbers.
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 Vec< 1, float >	fVec1
typedef Vec< 2, float >	fVec2
typedef Vec< 3, float >	fVec3
typedef Vec< 4, float >	fVec4
typedef Vec< 5, float >	fVec5
typedef Vec< 6, float >	fVec6
typedef Vec< 7, float >	fVec7
typedef Vec< 8, float >	fVec8
typedef Vec< 9, float >	fVec9
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 Row< 1, float >	fRow1
typedef Row< 2, float >	fRow2
typedef Row< 3, float >	fRow3
typedef Row< 4, float >	fRow4
typedef Row< 5, float >	fRow5
typedef Row< 6, float >	fRow6
typedef Row< 7, float >	fRow7
typedef Row< 8, float >	fRow8
typedef Row< 9, float >	fRow9
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 SymMat< 1, float >	fSymMat11
typedef SymMat< 2, float >	fSymMat22
typedef SymMat< 3, float >	fSymMat33
typedef SymMat< 4, float >	fSymMat44
typedef SymMat< 5, float >	fSymMat55
typedef SymMat< 6, float >	fSymMat66
typedef SymMat< 7, float >	fSymMat77
typedef SymMat< 8, float >	fSymMat88
typedef SymMat< 9, float >	fSymMat99
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 Mat< 1, 1, float >	fMat11
typedef Mat< 2, 2, float >	fMat22
typedef Mat< 3, 3, float >	fMat33
typedef Mat< 3, 4, float >	fMat34
typedef Mat< 4, 3, float >	fMat43
typedef Mat< 4, 4, float >	fMat44
typedef Mat< 5, 5, float >	fMat55
typedef Mat< 6, 6, float >	fMat66
typedef Mat< 7, 7, float >	fMat77
typedef Mat< 8, 8, float >	fMat88
typedef Mat< 9, 9, float >	fMat99
typedef Spline_< Real >	Spline
Enumerations
enum	BodyOrSpaceType { BodyRotationSequence = 0, SpaceRotationSequence = 1 }
enum	{   SCALAR_DEPTH = 0, SCALAR_COMPOSITE_DEPTH = 1, COMPOSITE_COMPOSITE_DEPTH = 2, COMPOSITE_3_DEPTH = 3,   MAX_RESOLVED_DEPTH = COMPOSITE_3_DEPTH }
enum	OptimizerAlgorithm {   BestAvailiable = 0, InteriorPoint = 1, LBFGS = 2, LBFGSB = 3,   CFSQP = 4 }
Functions
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (AssemblyConditionIndex)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (MobilizedBodyIndex)
static const MobilizedBodyIndex	GroundIndex (0)
	This is the MobilizedBodyIndex corresponding to the unique Ground body; its index is always zero.
	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)
std::ostream &	operator<< (std::ostream &o, const ContactForce &f)
std::ostream &	operator<< (std::ostream &o, const ContactDetail &d)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (ContactSurfaceIndex)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (ContactId)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (ContactTypeId)
std::ostream &	operator<< (std::ostream &o, const Contact &c)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (ContactGeometryTypeId)
	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 &)
template<class T >
static std::istream &	readVectorFromStreamHelper (std::istream &in, bool isFixedSize, Vector_< T > &out)
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.
template<class T , class X >
static std::istream &	readArrayFromStreamHelper (std::istream &in, bool isFixedSize, Array_< T, X > &out)
std::ostream &	operator<< (std::ostream &stream, const AtomicInteger &value)
template<class T >
std::ostream &	operator<< (std::ostream &stream, const Enumeration< T > &value)
template<class H , class IMPL , bool PTR>
std::ostream &	operator<< (std::ostream &o, const PIMPLHandle< H, IMPL, PTR > &h)
template<class HANDLE , class IMPL , bool PTR>
std::ostream &	operator<< (std::ostream &o, const PIMPLHandle< HANDLE, IMPL, PTR > &h)
template<class T >
static bool	tryConvertStringTo (const String &value, T &out)
template<>
bool	tryConvertStringTo (const String &value, String &out)
template<>
bool	tryConvertStringTo (const String &value, std::string &out)
template<class T >
static bool	tryConvertStringTo (const String &value, T *&out)
template<class T >
static void	cleanUpThreadLocalStorage (void *value)
long long	timespecToNs (const timespec &ts)
	Convert a time stored in a timespec struct to the equivalent number of nanoseconds (as a signed quantity).
void	nsToTimespec (const long long &ns, timespec &ts)
	Given a signed number of nanoseconds, convert that into seconds and leftover nanoseconds in a timespec struct.
double	nsToSec (const long long &ns)
	Given a count of nanosecond ticks as a signed 64 bit integer, return the same time interval as a double precision floating point number of seconds.
long long	secToNs (const double &s)
	Given a signed time interval as a double precision floating point number of seconds, return the same time interval as a count of nanosecond ticks in a signed 64 bit integer.
double	cpuTime ()
	Return the cumulative CPU time in seconds (both kernel and user time) that has been used so far by any of the threads in the currently executing process.
double	threadCpuTime ()
	Return the total CPU time in seconds (both kernel and user time) that has been used so far by the currently executing thread.
long long	realTimeInNs ()
	Return current time on the high-resolution interval timer in nanoseconds, as a 64-bit integer count.
double	realTime ()
	Return current time on the high-resolution interval timer in seconds.
void	sleepInNs (const long long &ns)
	Sleep for the indicated number of nanoseconds, with the actual precision system dependent but intended to be the best achievable, hopefully less than 5ms in all cases.
void	sleepInSec (const double &seconds)
	Sleep for the indicated number of seconds, with the actual precision system dependent but intended to be the best achievable, hopefully less than 5ms in all cases.
std::ostream &	operator<< (std::ostream &o, const AbstractValue &v)
	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)
template<class P >
static std::ostream &	operator<< (std::ostream &o, const MassProperties_< P > &mp)
	Output a human-readable representation of a MassProperties object to the given output stream.
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.
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)
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.
static Real	convertRadiansToDegrees (const Real rad)
static Real	convertDegreesToRadians (const Real deg)
complex< float >	operator* (const complex< float > &c, int r)
complex< float >	operator* (int r, const complex< float > &c)
complex< double >	operator* (const complex< float > &c, const double &r)
complex< double >	operator* (const double &r, const complex< float > &c)
complex< 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)
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 DEST , class SRC >
static const DEST &	negRecast (const SRC &s)
template<class A , class B >
negator< A >::template Result < B >::Add	operator+ (const negator< A > &l, const B &r)
template<class A , class B >
CNT< A >::template Result < negator< B > >::Add	operator+ (const A &l, const negator< B > &r)
template<class A , class B >
negator< A >::template Result < negator< B > >::Add	operator+ (const negator< A > &l, const negator< B > &r)
template<class A , class B >
negator< A >::template Result < B >::Sub	operator- (const negator< A > &l, const B &r)
template<class A , class B >
CNT< A >::template Result < negator< B > >::Sub	operator- (const A &l, const negator< B > &r)
template<class A , class B >
negator< A >::template Result < negator< B > >::Sub	operator- (const negator< A > &l, const negator< B > &r)
template<class A , class B >
negator< A >::template Result < B >::Mul	operator* (const negator< A > &l, const B &r)
template<class A , class B >
CNT< A >::template Result < negator< B > >::Mul	operator* (const A &l, const negator< B > &r)
template<class A , class B >
negator< A >::template Result < negator< B > >::Mul	operator* (const negator< A > &l, const negator< B > &r)
template<class A , class B >
negator< A >::template Result < B >::Dvd	operator/ (const negator< A > &l, const B &r)
template<class A , class B >
CNT< A >::template Result < negator< B > >::Dvd	operator/ (const A &l, const negator< B > &r)
template<class A , class B >
negator< A >::template Result < negator< B > >::Dvd	operator/ (const negator< A > &l, const negator< B > &r)
template<class A , class B >
bool	operator== (const negator< A > &l, const B &r)
template<class A , class B >
bool	operator== (const A &l, const negator< B > &r)
template<class A , class B >
bool	operator== (const negator< A > &l, const negator< B > &r)
template<class A , class B >
bool	operator!= (const negator< A > &l, const B &r)
template<class A , class B >
bool	operator!= (const A &l, const negator< B > &r)
template<class A , class B >
bool	operator!= (const negator< A > &l, const negator< B > &r)
template<class NUM , class CHAR , class TRAITS >
std::basic_istream< CHAR, TRAITS > &	operator>> (std::basic_istream< CHAR, TRAITS > &is, negator< NUM > &nn)
template<class NUM , class CHAR , class TRAITS >
std::basic_ostream< CHAR, TRAITS > &	operator<< (std::basic_ostream< CHAR, TRAITS > &os, const negator< NUM > &nn)
static const complex< long double >	zeroes (0)
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)
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)
unsigned long long	square (unsigned long long u)
char	square (char c)
signed char	square (signed char i)
short	square (short i)
int	square (int i)
long	square (long i)
long long	square (long long i)
float	square (const float &x)
double	square (const double &x)
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)
unsigned long long	cube (unsigned long long u)
char	cube (char c)
signed char	cube (signed char i)
short	cube (short i)
int	cube (int i)
long	cube (long i)
long long	cube (long long i)
float	cube (const float &x)
double	cube (const double &x)
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)
std::pair< double, double >	approxCompleteEllipticIntegralsKE (double m)
	Given 0<=m<=1, return complete elliptic integrals of the first and second kinds, K(m) and E(m), approximated but with a maximum error of 2e-8 so at least 7 digits are correct (same in float or double precision). See Elliptic integrals for a discussion.
std::pair< float, float >	approxCompleteEllipticIntegralsKE (float m)
	This is the single precision (float) version of the approximate calculation of elliptic integrals, still yielding about 7 digits of accuracy even though all calculations are done in float precision.
std::pair< double, double >	approxCompleteEllipticIntegralsKE (int m)
	This integer overload is present to prevent ambiguity; it converts its argument to double precision and then calls approxCompleteEllipticIntegralsKE(double).
std::pair< double, double >	completeEllipticIntegralsKE (double m)
	Given 0<=m<=1, return complete elliptic integrals of the first and second kinds, K(m) and E(m), calculated to (roughly) machine precision (float or double). See Elliptic integrals for a discussion.
std::pair< float, float >	completeEllipticIntegralsKE (float m)
	This is the single precision (float) version of the machine-precision calculation of elliptic integrals, providing accuracy to float precision (about 7 digits) which is no better than you'll get with the much faster approximate version, so use that instead!
std::pair< double, double >	completeEllipticIntegralsKE (int m)
	This integer overload is present to prevent ambiguity; it converts its argument to double precision and then calls completeEllipticIntegralsKE(double).
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (SystemEventIndex)
	This unique integer type is for identifying an event in the full System-level view of the State.
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (EventIndex)
	Unique integer type for Subsystem-local event indexing.
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (SystemEventTriggerIndex)
	This unique integer type is for identifying a triggered event in the full System-level view of the State.
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (EventTriggerIndex)
	Unique integer type for Subsystem-local event indexing.
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (SystemEventTriggerByStageIndex)
	This unique integer type is for identifying a triggered event within a particular Stage of the full System-level view of the State.
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (EventTriggerByStageIndex)
	Unique integer type for Subsystem-local, per-stage event indexing.
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (EventId)
	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 > &)
std::ostream &	operator<< (std::ostream &o, Stage g)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (SubsystemIndex)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (SystemYIndex)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (SystemQIndex)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (QIndex)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (SystemUIndex)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (UIndex)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (SystemZIndex)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (ZIndex)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (DiscreteVariableIndex)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (CacheEntryIndex)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (SystemYErrIndex)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (SystemQErrIndex)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (QErrIndex)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (SystemUErrIndex)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (UErrIndex)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (SystemUDotErrIndex)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (UDotErrIndex)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (SystemMultiplierIndex)
	SimTK_DEFINE_UNIQUE_INDEX_TYPE (MultiplierIndex)
std::ostream &	operator<< (std::ostream &o, const State &s)
static System::ProjectOptions	operator| (System::ProjectOptions::Option o1, System::ProjectOptions::Option o2)
static System::ProjectOptions	operator| (System::ProjectOptions opts, System::ProjectOptions::Option o)
static System::ProjectOptions	operator| (System::ProjectOptions::Option o, System::ProjectOptions opts)
static System::ProjectOptions	operator& (System::ProjectOptions::Option o1, System::ProjectOptions::Option o2)
static System::ProjectOptions	operator& (System::ProjectOptions opts, System::ProjectOptions::Option o)
static System::ProjectOptions	operator& (System::ProjectOptions::Option o, System::ProjectOptions opts)
static System::ProjectOptions	operator~ (System::ProjectOptions::Option o)
static System::ProjectOptions	operator- (System::ProjectOptions opts, System::ProjectOptions::Option o)
static System::ProjectOptions	operator- (System::ProjectOptions opts1, System::ProjectOptions opts2)
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)
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.
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)
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 ~[].
static int	explicitODE_static (const CPodesSystem &sys, Real t, const Vector &y, Vector &fout)
static int	implicitODE_static (const CPodesSystem &sys, Real t, const Vector &y, const Vector &yp, Vector &fout)
static int	constraint_static (const CPodesSystem &sys, Real t, const Vector &y, Vector &cout)
static int	project_static (const CPodesSystem &sys, Real t, const Vector &ycur, Vector &corr, Real epsProj, Vector &err)
static int	quadrature_static (const CPodesSystem &sys, Real t, const Vector &y, Vector &qout)
static int	root_static (const CPodesSystem &sys, Real t, const Vector &y, const Vector &yp, Vector &gout)
static int	weight_static (const CPodesSystem &sys, const Vector &y, Vector &weights)
static void	errorHandler_static (const CPodesSystem &sys, int error_code, const char *module, const char *function, char *msg)
Global operators involving Matrix objects
These operators take MatrixBase arguments and produce Matrix_ results.
template<class E1 , class E2 >
Matrix_< typename CNT< E1 > ::template Result< E2 >::Add >	operator+ (const MatrixBase< E1 > &l, const MatrixBase< E2 > &r)
template<class E >
Matrix_< E >	operator+ (const MatrixBase< E > &l, const typename CNT< E >::T &r)
template<class E >
Matrix_< E >	operator+ (const typename CNT< E >::T &l, const MatrixBase< E > &r)
template<class E1 , class E2 >
Matrix_< typename CNT< E1 > ::template Result< E2 >::Sub >	operator- (const MatrixBase< E1 > &l, const MatrixBase< E2 > &r)
template<class E >
Matrix_< E >	operator- (const MatrixBase< E > &l, const typename CNT< E >::T &r)
template<class E >
Matrix_< E >	operator- (const typename CNT< E >::T &l, const MatrixBase< E > &r)
template<class E >
Matrix_< E >	operator* (const MatrixBase< E > &l, const typename CNT< E >::StdNumber &r)
template<class E >
Matrix_< E >	operator* (const typename CNT< E >::StdNumber &l, const MatrixBase< E > &r)
template<class E >
Matrix_< E >	operator/ (const MatrixBase< E > &l, const typename CNT< E >::StdNumber &r)
template<class E >
Matrix_< E >	operator* (const MatrixBase< E > &l, int r)
template<class E >
Matrix_< E >	operator* (int l, const MatrixBase< E > &r)
template<class E >
Matrix_< E >	operator/ (const MatrixBase< E > &l, int r)
Global operators involving Vector objects
These operators take VectorBase arguments and produce Vector_ results.
template<class E1 , class E2 >
Vector_< typename CNT< E1 > ::template Result< E2 >::Add >	operator+ (const VectorBase< E1 > &l, const VectorBase< E2 > &r)
template<class E >
Vector_< E >	operator+ (const VectorBase< E > &l, const typename CNT< E >::T &r)
template<class E >
Vector_< E >	operator+ (const typename CNT< E >::T &l, const VectorBase< E > &r)
template<class E1 , class E2 >
Vector_< typename CNT< E1 > ::template Result< E2 >::Sub >	operator- (const VectorBase< E1 > &l, const VectorBase< E2 > &r)
template<class E >
Vector_< E >	operator- (const VectorBase< E > &l, const typename CNT< E >::T &r)
template<class E >
Vector_< E >	operator- (const typename CNT< E >::T &l, const VectorBase< E > &r)
template<class E >
Vector_< E >	operator* (const VectorBase< E > &l, const typename CNT< E >::StdNumber &r)
template<class E >
Vector_< E >	operator* (const typename CNT< E >::StdNumber &l, const VectorBase< E > &r)
template<class E >
Vector_< E >	operator/ (const VectorBase< E > &l, const typename CNT< E >::StdNumber &r)
template<class E >
Vector_< E >	operator* (const VectorBase< E > &l, int r)
template<class E >
Vector_< E >	operator* (int l, const VectorBase< E > &r)
template<class E >
Vector_< E >	operator/ (const VectorBase< E > &l, int r)
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)
	Composition of Rotation matrices via operator*.
template<class P >
Rotation_< P >	operator* (const InverseRotation_< P > &R1, const Rotation_< P > &R2)
	Composition of Rotation matrices via operator*.
template<class P >
Rotation_< P >	operator* (const InverseRotation_< P > &R1, const InverseRotation_< P > &R2)
	Composition of Rotation matrices via operator*.
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)
	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 InverseRotation_< 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 InverseRotation_< P > &R1, const InverseRotation_< P > &R2)
	Composition of a Rotation matrix and the inverse of another Rotation via operator/, that is R1/R2 == R1*(~R2).
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 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 Transform_< P > &X_BF, const Vec< 4, negator< P >, S > &s_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, negator< P >, S > &s_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 , 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)
	Multiplying a matrix or vector by a Transform_.
template<class P , class E >
RowVector_< E >	operator* (const Transform_< P > &X, const RowVectorBase< E > &v)
	Multiplying a matrix or vector by a Transform_.
template<class P , class E >
RowVector_< E >	operator* (const RowVectorBase< E > &v, const Transform_< P > &X)
	Multiplying a matrix or vector by a Transform_.
template<class P , class E >
Matrix_< E >	operator* (const Transform_< P > &X, const MatrixBase< E > &v)
	Multiplying a matrix or vector by a Transform_.
template<class P , class E >
Matrix_< E >	operator* (const MatrixBase< E > &v, const Transform_< P > &X)
	Multiplying a matrix or vector by a Transform_.
template<class P , int N, class E , int S>
Vec< N, E >	operator* (const Transform_< P > &X, const Vec< N, E, S > &v)
	Multiplying a matrix or vector by a Transform_.
template<class P , int N, class E , int S>
Vec< N, E >	operator* (const Vec< N, E, S > &v, const Transform_< P > &X)
	Multiplying a matrix or vector by a Transform_.
template<class P , int N, class E , int S>
Row< N, E >	operator* (const Transform_< P > &X, const Row< N, E, S > &v)
	Multiplying a matrix or vector by a Transform_.
template<class P , int N, class E , int S>
Row< N, E >	operator* (const Row< N, E, S > &v, const Transform_< P > &X)
	Multiplying a matrix or vector by a Transform_.
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)
	Multiplying a matrix or vector by a Transform_.
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)
	Multiplying a matrix or vector by a Transform_.
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)
	Composition of transforms.
template<class P >
Transform_< P >	operator* (const InverseTransform_< P > &X1, const Transform_< P > &X2)
	Composition of transforms.
template<class P >
Transform_< P >	operator* (const InverseTransform_< P > &X1, const InverseTransform_< P > &X2)
	Composition of transforms.
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)
	Comparison operators return true only if the two transforms are bit identical; that's not too useful.
template<class P >
bool	operator== (const Transform_< P > &X1, const InverseTransform_< 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 Transform_< P > &X2)
	Comparison operators return true only if the two transforms are bit identical; that's not too useful.
Variables
static const Vec3	Black = Vec3( 0, 0, 0)
static const Vec3	Gray = Vec3(.5,.5,.5)
static const Vec3	Red = Vec3( 1, 0, 0)
static const Vec3	Green = Vec3( 0, 1, 0)
static const Vec3	Blue = Vec3( 0, 0, 1)
static const Vec3	Yellow = Vec3( 1, 1, 0)
static const Vec3	Orange = Vec3( 1,.5, 0)
static const Vec3	Magenta = Vec3( 1, 0, 1)
static const Vec3	Purple = Vec3(.5, 0,.5)
static const Vec3	Cyan = Vec3( 0, 1, 1)
static const Vec3	White = Vec3( 1, 1, 1)
static std::map< void *, pthread_key_t >	instanceMap
static std::map< pthread_key_t, std::set< void * > >	keyInstances
static pthread_mutex_t	keyLock = PTHREAD_MUTEX_INITIALIZER
static const CoordinateAxis::XCoordinateAxis	XAxis
	Constant representing the X coordinate axis; will implicitly convert to the integer 0 when used in a context requiring an integer.
static const CoordinateAxis::YCoordinateAxis	YAxis
	Constant representing the Y coordinate axis; will implicitly convert to the integer 1 when used in a context requiring an integer.
static const CoordinateAxis::ZCoordinateAxis	ZAxis
	Constant representing the Z coordinate axis; will implicitly convert to the integer 2 when used in a context requiring an integer.
static const CoordinateDirection::NegXDirection	NegXAxis
static const CoordinateDirection::NegYDirection	NegYAxis
static const CoordinateDirection::NegZDirection	NegZAxis
static const Real &	NaN = NTraits<Real>::getNaN()
	This is the IEEE "not a number" constant for this implementation of the default-precision Real type; be very careful using this because it has many strange properties such as not comparing equal to itself.
static const Real &	Infinity = NTraits<Real>::getInfinity()
	This is the IEEE positive infinity constant for this implementation of the default-precision Real type; -Infinity will produce the negative infinity constant.
static const Real &	Eps = NTraits<Real>::getEps()
	Epsilon is the size of roundoff noise; it is the smallest positive number of default-precision type Real such that 1+Eps != 1.
static const Real &	SqrtEps = NTraits<Real>::getSqrtEps()
	This is the square root of Eps, ~1e-8 if Real is double, ~3e-4 if Real is float.
static const Real &	TinyReal = NTraits<Real>::getTiny()
	TinyReal is a floating point value smaller than the floating point precision; it is defined as Eps^(5/4) which is ~1e-20 for Real==double and ~1e-9 for float.
static const Real &	SignificantReal = NTraits<Real>::getSignificant()
	SignificantReal is the smallest value that we consider to be clearly distinct from roundoff error when it is the result of a computation; it is defined as Eps^(7/8) which is ~1e-14 when Real==double, ~1e-6 when Real==float.
static const Real &	LeastPositiveReal = NTraits<Real>::getLeastPositive()
	This is the smallest positive real number that can be expressed in the type Real; it is ~1e-308 when Real==double, ~1e-38 when Real==float.
static const Real &	MostPositiveReal = NTraits<Real>::getMostPositive()
	This is the largest finite positive real number that can be expressed in the Real type; ~1e+308 when Real==double, ~1e+38 when Real==float. Note that there is also a value Infinity that will test larger than this one.
static const Real &	LeastNegativeReal = NTraits<Real>::getLeastNegative()
	This is the largest negative real number (that is, closest to zero) that can be expressed in values of type Real.
static const Real &	MostNegativeReal = NTraits<Real>::getMostNegative()
	This is the smallest finite negative real number that can be expressed in values of type Real. Note that -Infinity is a value that will still test smaller than this one.
static const int	NumDigitsReal = NTraits<Real>::getNumDigits()
	This is the number of decimal digits that can be reliably stored and retrieved in the default Real precision (typically log10(1/eps)-1), that is, about 15 digits when Real==double and 6 digits when Real==float.
static const int	LosslessNumDigitsReal = NTraits<Real>::getLosslessNumDigits()
	This is the smallest number of decimal digits you should store in a text file if you want to be able to get exactly the same bit pattern back when you read it back in and convert the text to a Real value.
static const Real &	Zero = NTraits<Real>::getZero()
	Real(0)
static const Real &	One = NTraits<Real>::getOne()
	Real(1)
static const Real &	MinusOne = NTraits<Real>::getMinusOne()
	Real(-1)
static const Real &	Two = NTraits<Real>::getTwo()
	Real(2)
static const Real &	Three = NTraits<Real>::getThree()
	Real(3)
static const Real &	OneHalf = NTraits<Real>::getOneHalf()
	Real(1)/2.
static const Real &	OneThird = NTraits<Real>::getOneThird()
	Real(1)/3.
static const Real &	OneFourth = NTraits<Real>::getOneFourth()
	Real(1)/4.
static const Real &	OneFifth = NTraits<Real>::getOneFifth()
	Real(1)/5.
static const Real &	OneSixth = NTraits<Real>::getOneSixth()
	Real(1)/6.
static const Real &	OneSeventh = NTraits<Real>::getOneSeventh()
	Real(1)/7.
static const Real &	OneEighth = NTraits<Real>::getOneEighth()
	Real(1)/8.
static const Real &	OneNinth = NTraits<Real>::getOneNinth()
	Real(1)/9.
static const Real &	Pi = NTraits<Real>::getPi()
	Real(pi)
static const Real &	OneOverPi = NTraits<Real>::getOneOverPi()
	1/Real(pi)
static const Real &	E = NTraits<Real>::getE()
	e = Real(exp(1))
static const Real &	Log2E = NTraits<Real>::getLog2E()
	Real(log2(e)) (log base 2)
static const Real &	Log10E = NTraits<Real>::getLog10E()
	Real(log10(e)) (log base 10)
static const Real &	Sqrt2 = NTraits<Real>::getSqrt2()
	Real(sqrt(2))
static const Real &	OneOverSqrt2 = NTraits<Real>::getOneOverSqrt2()
	1/sqrt(2)==sqrt(2)/2 as Real
static const Real &	Sqrt3 = NTraits<Real>::getSqrt3()
	Real(sqrt(3))
static const Real &	OneOverSqrt3 = NTraits<Real>::getOneOverSqrt3()
	Real(1/sqrt(3))
static const Real &	CubeRoot2 = NTraits<Real>::getCubeRoot2()
	Real(2^(1/3)) (cube root of 2)
static const Real &	CubeRoot3 = NTraits<Real>::getCubeRoot3()
	Real(3^(1/3)) (cube root of 3)
static const Real &	Ln2 = NTraits<Real>::getLn2()
	Real(ln(2)) (natural log of 2)
static const Real &	Ln10 = NTraits<Real>::getLn10()
	Real(ln(10)) (natural log of 10)
static const Complex &	I = NTraits<Complex>::getI()
	We only need one complex constant, i = sqrt(-1). For the rest just multiply the real constant by i, or convert with Complex(the Real constant), or if you need an address you can use NTraits<Complex>::getPi(), etc.
static const double	DefaultRecpCondition = 1e-12

---

Detailed Description

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

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 ForceSubsystem::Guts SimTK::ForceSubsystemRep

typedef Visualizer SimTK::VTKVisualizer

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

typedef Visualizer::Reporter SimTK::VTKEventReporter

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

typedef Vector_<Real> SimTK::Vector

typedef Vector_<float> SimTK::fVector

typedef Vector_<double> SimTK::dVector

typedef Vector_<Complex> SimTK::ComplexVector

typedef Vector_<fComplex> SimTK::fComplexVector

typedef Vector_<dComplex> SimTK::dComplexVector

typedef VectorView_<Real> SimTK::VectorView

typedef VectorView_<float> SimTK::fVectorView

typedef VectorView_<double> SimTK::dVectorView

typedef VectorView_<Complex> SimTK::ComplexVectorView

typedef VectorView_<fComplex> SimTK::fComplexVectorView

typedef VectorView_<dComplex> SimTK::dComplexVectorView

typedef RowVector_<Real> SimTK::RowVector

typedef RowVector_<float> SimTK::fRowVector

typedef RowVector_<double> SimTK::dRowVector

typedef RowVector_<Complex> SimTK::ComplexRowVector

typedef RowVector_<fComplex> SimTK::fComplexRowVector

typedef RowVector_<dComplex> SimTK::dComplexRowVector

typedef RowVectorView_<Real> SimTK::RowVectorView

typedef RowVectorView_<float> SimTK::fRowVectorView

typedef RowVectorView_<double> SimTK::dRowVectorView

typedef RowVectorView_<Complex> SimTK::ComplexRowVectorView

typedef RowVectorView_<fComplex> SimTK::fComplexRowVectorView

typedef RowVectorView_<dComplex> SimTK::dComplexRowVectorView

typedef Matrix_<Real> SimTK::Matrix

typedef Matrix_<float> SimTK::fMatrix

typedef Matrix_<double> SimTK::dMatrix

typedef Matrix_<Complex> SimTK::ComplexMatrix

typedef Matrix_<fComplex> SimTK::fComplexMatrix

typedef Matrix_<dComplex> SimTK::dComplexMatrix

typedef MatrixView_<Real> SimTK::MatrixView

typedef MatrixView_<float> SimTK::fMatrixView

typedef MatrixView_<double> SimTK::dMatrixView

typedef MatrixView_<Complex> SimTK::ComplexMatrixView

typedef MatrixView_<fComplex> SimTK::fComplexMatrixView

typedef MatrixView_<dComplex> SimTK::dComplexMatrixView

typedef Function_<Real> SimTK::Function

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

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

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

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

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

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

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

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

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

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

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

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

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

typedef UnitInertia_<Real> SimTK::UnitInertia

A unit inertia (gyration) tensor at default precision.

typedef UnitInertia_<float> SimTK::fUnitInertia

A unit inertia (gyration) tensor at float precision.

typedef UnitInertia_<double> SimTK::dUnitInertia

A unit inertia (gyration) tensor at double precision.

typedef Inertia_<Real> SimTK::Inertia

An inertia tensor at default precision.

typedef Inertia_<float> SimTK::fInertia

An inertia tensor at float precision.

typedef Inertia_<double> SimTK::dInertia

An inertia tensor at double precision.

typedef MassProperties_<Real> SimTK::MassProperties

Rigid body mass properties at default precision.

typedef MassProperties_<float> SimTK::fMassProperties

Rigid body mass properties at float precision.

typedef MassProperties_<double> SimTK::dMassProperties

Rigid body mass properties at double precision.

typedef SpatialInertia_<Real> SimTK::SpatialInertia

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

typedef SpatialInertia_<float> SimTK::fSpatialInertia

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

typedef SpatialInertia_<double> SimTK::dSpatialInertia

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

typedef ArticulatedInertia_<Real> SimTK::ArticulatedInertia

An articulated body inertia matrix at default precision.

typedef ArticulatedInertia_<float> SimTK::fArticulatedInertia

An articulated body inertia matrix at float precision.

typedef ArticulatedInertia_<double> SimTK::dArticulatedInertia

An articulated body inertia matrix at double precision.

typedef UnitInertia SimTK::Gyration

For backwards compatibility only; use UnitInertia instead.

typedef Quaternion_<Real> SimTK::Quaternion

typedef Quaternion_<float> SimTK::fQuaternion

typedef Quaternion_<double> SimTK::dQuaternion

typedef Rotation_<Real> SimTK::Rotation

typedef Rotation_<float> SimTK::fRotation

typedef Rotation_<double> SimTK::dRotation

typedef InverseRotation_<Real> SimTK::InverseRotation

typedef InverseRotation_<float> SimTK::fInverseRotation

typedef InverseRotation_<double> SimTK::dInverseRotation

typedef Transform_<Real> SimTK::Transform

typedef Transform_<float> SimTK::fTransform

typedef Transform_<double> SimTK::dTransform

typedef UnitVec<Real,1> SimTK::UnitVec3

typedef UnitVec<float,1> SimTK::fUnitVec3

typedef UnitVec<double,1> SimTK::dUnitVec3

typedef conjugate<Real> SimTK::Conjugate

typedef Measure_<Real> SimTK::Measure

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

typedef int SimTK::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 Vec<1> SimTK::Vec1

typedef Vec<2> SimTK::Vec2

typedef Vec<3> SimTK::Vec3

typedef Vec<4> SimTK::Vec4

typedef Vec<5> SimTK::Vec5

typedef Vec<6> SimTK::Vec6

typedef Vec<7> SimTK::Vec7

typedef Vec<8> SimTK::Vec8

typedef Vec<9> SimTK::Vec9

typedef Vec<1,float> SimTK::fVec1

typedef Vec<2,float> SimTK::fVec2

typedef Vec<3,float> SimTK::fVec3

typedef Vec<4,float> SimTK::fVec4

typedef Vec<5,float> SimTK::fVec5

typedef Vec<6,float> SimTK::fVec6

typedef Vec<7,float> SimTK::fVec7

typedef Vec<8,float> SimTK::fVec8

typedef Vec<9,float> SimTK::fVec9

typedef Row<1> SimTK::Row1

typedef Row<2> SimTK::Row2

typedef Row<3> SimTK::Row3

typedef Row<4> SimTK::Row4

typedef Row<5> SimTK::Row5

typedef Row<6> SimTK::Row6

typedef Row<7> SimTK::Row7

typedef Row<8> SimTK::Row8

typedef Row<9> SimTK::Row9

typedef Row<1,float> SimTK::fRow1

typedef Row<2,float> SimTK::fRow2

typedef Row<3,float> SimTK::fRow3

typedef Row<4,float> SimTK::fRow4

typedef Row<5,float> SimTK::fRow5

typedef Row<6,float> SimTK::fRow6

typedef Row<7,float> SimTK::fRow7

typedef Row<8,float> SimTK::fRow8

typedef Row<9,float> SimTK::fRow9

typedef SymMat<1> SimTK::SymMat11

typedef SymMat<2> SimTK::SymMat22

typedef SymMat<3> SimTK::SymMat33

typedef SymMat<4> SimTK::SymMat44

typedef SymMat<5> SimTK::SymMat55

typedef SymMat<6> SimTK::SymMat66

typedef SymMat<7> SimTK::SymMat77

typedef SymMat<8> SimTK::SymMat88

typedef SymMat<9> SimTK::SymMat99

typedef SymMat<1,float> SimTK::fSymMat11

typedef SymMat<2,float> SimTK::fSymMat22

typedef SymMat<3,float> SimTK::fSymMat33

typedef SymMat<4,float> SimTK::fSymMat44

typedef SymMat<5,float> SimTK::fSymMat55

typedef SymMat<6,float> SimTK::fSymMat66

typedef SymMat<7,float> SimTK::fSymMat77

typedef SymMat<8,float> SimTK::fSymMat88

typedef SymMat<9,float> SimTK::fSymMat99

typedef Mat<1,1> SimTK::Mat11

typedef Mat<1,2> SimTK::Mat12

typedef Mat<1,3> SimTK::Mat13

typedef Mat<1,4> SimTK::Mat14

typedef Mat<1,5> SimTK::Mat15

typedef Mat<1,6> SimTK::Mat16

typedef Mat<1,7> SimTK::Mat17

typedef Mat<1,8> SimTK::Mat18

typedef Mat<1,9> SimTK::Mat19

typedef Mat<2,1> SimTK::Mat21

typedef Mat<2,2> SimTK::Mat22

typedef Mat<2,3> SimTK::Mat23

typedef Mat<2,4> SimTK::Mat24

typedef Mat<2,5> SimTK::Mat25

typedef Mat<2,6> SimTK::Mat26

typedef Mat<2,7> SimTK::Mat27

typedef Mat<2,8> SimTK::Mat28

typedef Mat<2,9> SimTK::Mat29

typedef Mat<3,1> SimTK::Mat31

typedef Mat<3,2> SimTK::Mat32

typedef Mat<3,3> SimTK::Mat33

typedef Mat<3,4> SimTK::Mat34

typedef Mat<3,5> SimTK::Mat35

typedef Mat<3,6> SimTK::Mat36

typedef Mat<3,7> SimTK::Mat37

typedef Mat<3,8> SimTK::Mat38

typedef Mat<3,9> SimTK::Mat39

typedef Mat<4,1> SimTK::Mat41

typedef Mat<4,2> SimTK::Mat42

typedef Mat<4,3> SimTK::Mat43

typedef Mat<4,4> SimTK::Mat44

typedef Mat<4,5> SimTK::Mat45

typedef Mat<4,6> SimTK::Mat46

typedef Mat<4,7> SimTK::Mat47

typedef Mat<4,8> SimTK::Mat48

typedef Mat<4,9> SimTK::Mat49

typedef Mat<5,1> SimTK::Mat51

typedef Mat<5,2> SimTK::Mat52

typedef Mat<5,3> SimTK::Mat53

typedef Mat<5,4> SimTK::Mat54

typedef Mat<5,5> SimTK::Mat55

typedef Mat<5,6> SimTK::Mat56

typedef Mat<5,7> SimTK::Mat57

typedef Mat<5,8> SimTK::Mat58

typedef Mat<5,9> SimTK::Mat59

typedef Mat<6,1> SimTK::Mat61

typedef Mat<6,2> SimTK::Mat62

typedef Mat<6,3> SimTK::Mat63

typedef Mat<6,4> SimTK::Mat64

typedef Mat<6,5> SimTK::Mat65

typedef Mat<6,6> SimTK::Mat66

typedef Mat<6,7> SimTK::Mat67

typedef Mat<6,8> SimTK::Mat68

typedef Mat<6,9> SimTK::Mat69

typedef Mat<7,1> SimTK::Mat71

typedef Mat<7,2> SimTK::Mat72

typedef Mat<7,3> SimTK::Mat73

typedef Mat<7,4> SimTK::Mat74

typedef Mat<7,5> SimTK::Mat75

typedef Mat<7,6> SimTK::Mat76

typedef Mat<7,7> SimTK::Mat77

typedef Mat<7,8> SimTK::Mat78

typedef Mat<7,9> SimTK::Mat79

typedef Mat<8,1> SimTK::Mat81

typedef Mat<8,2> SimTK::Mat82

typedef Mat<8,3> SimTK::Mat83

typedef Mat<8,4> SimTK::Mat84

typedef Mat<8,5> SimTK::Mat85

typedef Mat<8,6> SimTK::Mat86

typedef Mat<8,7> SimTK::Mat87

typedef Mat<8,8> SimTK::Mat88

typedef Mat<8,9> SimTK::Mat89

typedef Mat<9,1> SimTK::Mat91

typedef Mat<9,2> SimTK::Mat92

typedef Mat<9,3> SimTK::Mat93

typedef Mat<9,4> SimTK::Mat94

typedef Mat<9,5> SimTK::Mat95

typedef Mat<9,6> SimTK::Mat96

typedef Mat<9,7> SimTK::Mat97

typedef Mat<9,8> SimTK::Mat98

typedef Mat<9,9> SimTK::Mat99

typedef Mat<1,1,float> SimTK::fMat11

typedef Mat<2,2,float> SimTK::fMat22

typedef Mat<3,3,float> SimTK::fMat33

typedef Mat<3,4,float> SimTK::fMat34

typedef Mat<4,3,float> SimTK::fMat43

typedef Mat<4,4,float> SimTK::fMat44

typedef Mat<5,5,float> SimTK::fMat55

typedef Mat<6,6,float> SimTK::fMat66

typedef Mat<7,7,float> SimTK::fMat77

typedef Mat<8,8,float> SimTK::fMat88

typedef Mat<9,9,float> SimTK::fMat99

typedef Spline_<Real> SimTK::Spline

---

Enumeration Type Documentation

enum SimTK::BodyOrSpaceType

Enumerator:

BodyRotationSequence
SpaceRotationSequence

anonymous enum

Enumerator:

SCALAR_DEPTH
SCALAR_COMPOSITE_DEPTH
COMPOSITE_COMPOSITE_DEPTH
COMPOSITE_3_DEPTH
MAX_RESOLVED_DEPTH

enum SimTK::OptimizerAlgorithm

Enumerator:

BestAvailiable
InteriorPoint
LBFGS
LBFGSB
CFSQP

---

Function Documentation

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

AssemblyConditionIndex

)

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

MobilizedBodyIndex

)

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

ConstraintIndex

)

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

ParticleIndex

)

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

AncestorConstrainedBodyPoolIndex

)

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

USquaredIndex

)

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

QuaternionPoolIndex

)

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

AnglePoolIndex

)

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

PresQPoolIndex

)

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

PresUPoolIndex

)

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

PresUDotPoolIndex

)

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

PresForcePoolIndex

)

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

MobilizerQIndex

)

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

MobilizerUIndex

)

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

ConstrainedBodyIndex

)

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

ConstrainedMobilizerIndex

)

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

ConstrainedQIndex

)

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

ConstrainedUIndex

)

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

ParticipatingQIndex

)

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

ParticipatingUIndex

)

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

SubtreeBodyIndex

)

static const SubtreeBodyIndex SimTK::SubtreeAncestorIndex

(

0

)

[static]

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

SubtreeQIndex

)

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

SubtreeUIndex

)

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

ForceIndex

)

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

ContactSetIndex

)

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

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

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

ContactSurfaceIndex

)

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

ContactId

)

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

ContactTypeId

)

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

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

ContactGeometryTypeId

)

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

ContactCliqueId

)

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

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

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

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

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

template<class E1 , class E2 >

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

template<class E >

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

template<class E >

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

template<class E1 , class E2 >

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

template<class E >

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

template<class E >

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

template<class E >

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

template<class E >

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

template<class E >

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

template<class E >

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

template<class E >

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

template<class E >

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

template<class E1 , class E2 >

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

template<class E >

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

template<class E >

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

template<class E1 , class E2 >

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

template<class E >

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

template<class E >

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

template<class E >

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

template<class E >

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

template<class E >

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

template<class E >

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

template<class E >

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

template<class E >

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

template<class E1 , class E2 >

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

template<class E >

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

template<class E >

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

template<class E1 , class E2 >

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

template<class E >

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

template<class E >

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

template<class E >

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

template<class E >

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

template<class E >

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

template<class E >

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

template<class E >

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

template<class E >

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

template<class E1 , class E2 >

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

template<class E1 , class E2 >

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

template<class E1 , class E2 >

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

template<class T >

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

template<class T , class X >

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

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

template<class T >

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

template<class H , class IMPL , bool PTR>

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

template<class HANDLE , class IMPL , bool PTR>

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

template<class T >

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

template<>

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

template<>

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

template<class T >

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

template<class T >

static void SimTK::cleanUpThreadLocalStorage

(

void *

value

)

[static]

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

SimTK::SimTK_ELEMENTWISE_FUNCTION

(

exp

)

template<class ELEM >

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

(

const RowVectorBase< ELEM >

v

)

template<class ELEM >

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

(

const MatrixBase< ELEM >

v

)

template<int N, class ELEM >

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

(

const Vec< N, ELEM >

v

)

template<int N, class ELEM >

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

(

const Row< N, ELEM >

v

)

template<int M, int N, class ELEM >

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

(

const Mat< M, N, ELEM >

v

)

template<int N, class ELEM >

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

(

const SymMat< N, ELEM >

v

)

template<class ELEM >

ELEM SimTK::sum

(

const VectorBase< ELEM >

v

)

template<class ELEM >

ELEM SimTK::sum

(

const RowVectorBase< ELEM >

v

)

template<class ELEM >

RowVectorBase<ELEM> SimTK::sum

(

const MatrixBase< ELEM >

v

)

template<int N, class ELEM >

ELEM SimTK::sum

(

const Vec< N, ELEM >

v

)

template<int N, class ELEM >

ELEM SimTK::sum

(

const Row< N, ELEM >

v

)

template<int M, int N, class ELEM >

Row<N, ELEM> SimTK::sum

(

const Mat< M, N, ELEM >

v

)

template<int N, class ELEM >

Row<N, ELEM> SimTK::sum

(

const SymMat< N, ELEM >

v

)

template<class ELEM >

ELEM SimTK::min

(

const VectorBase< ELEM >

v

)

template<class ELEM >

ELEM SimTK::min

(

const RowVectorBase< ELEM >

v

)

template<class ELEM >

RowVectorBase<ELEM> SimTK::min

(

const MatrixBase< ELEM >

v

)

template<int N, class ELEM >

ELEM SimTK::min

(

const Vec< N, ELEM >

v

)

template<int N, class ELEM >

ELEM SimTK::min

(

Row< N, ELEM >

v

)

template<int M, int N, class ELEM >

Row<N, ELEM> SimTK::min

(

const Mat< M, N, ELEM >

v

)

template<int N, class ELEM >

Row<N, ELEM> SimTK::min

(

SymMat< N, ELEM >

v

)

template<class ELEM >

ELEM SimTK::max

(

const VectorBase< ELEM >

v

)

template<class ELEM >

ELEM SimTK::max

(

const RowVectorBase< ELEM >

v

)

template<class ELEM >

RowVectorBase<ELEM> SimTK::max

(

const MatrixBase< ELEM >

v

)

template<int N, class ELEM >

ELEM SimTK::max

(

Vec< N, ELEM >

v

)

template<int N, class ELEM >

ELEM SimTK::max

(

const Row< N, ELEM >

v

)

template<int M, int N, class ELEM >

Row<N, ELEM> SimTK::max

(

const Mat< M, N, ELEM >

v

)

template<int N, class ELEM >

Row<N, ELEM> SimTK::max

(

const SymMat< N, ELEM >

v

)

template<class ELEM >

ELEM SimTK::mean

(

const VectorBase< ELEM >

v

)

template<class ELEM >

ELEM SimTK::mean

(

const RowVectorBase< ELEM >

v

)

template<class ELEM >

RowVectorBase<ELEM> SimTK::mean

(

const MatrixBase< ELEM >

v

)

template<int N, class ELEM >

ELEM SimTK::mean

(

const Vec< N, ELEM >

v

)

template<int N, class ELEM >

ELEM SimTK::mean

(

const Row< N, ELEM >

v

)

template<int M, int N, class ELEM >

Row<N, ELEM> SimTK::mean

(

const Mat< M, N, ELEM >

v

)

template<int N, class ELEM >

Row<N, ELEM> SimTK::mean

(

const SymMat< N, ELEM >

v

)

template<class ELEM >

VectorBase<ELEM> SimTK::sort

(

const VectorBase< ELEM >

v

)

template<class ELEM >

RowVectorBase<ELEM> SimTK::sort

(

const RowVectorBase< ELEM >

v

)

template<class ELEM >

MatrixBase<ELEM> SimTK::sort

(

const MatrixBase< ELEM >

v

)

template<int N, class ELEM >

Vec<N, ELEM> SimTK::sort

(

Vec< N, ELEM >

v

)

template<int N, class ELEM >

Row<N, ELEM> SimTK::sort

(

Row< N, ELEM >

v

)

template<int M, int N, class ELEM >

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

(

Mat< M, N, ELEM >

v

)

template<int N, class ELEM >

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

(

const SymMat< N, ELEM >

v

)

template<class ELEM , class RandomAccessIterator >

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

template<class ELEM >

ELEM SimTK::median

(

const VectorBase< ELEM >

v

)

template<class ELEM >

ELEM SimTK::median

(

const RowVectorBase< ELEM >

v

)

template<class ELEM >

RowVectorBase<ELEM> SimTK::median

(

const MatrixBase< ELEM >

v

)

template<int N, class ELEM >

ELEM SimTK::median

(

Vec< N, ELEM >

v

)

template<int N, class ELEM >

ELEM SimTK::median

(

Row< N, ELEM >

v

)

template<int M, int N, class ELEM >

Row<N, ELEM> SimTK::median

(

const Mat< M, N, ELEM >

v

)

template<int N, class ELEM >

Row<N, ELEM> SimTK::median

(

const SymMat< N, ELEM >

v

)

template<class P >

static std::ostream& SimTK::operator<<	(	std::ostream &	o,
		const MassProperties_< P > &	mp
	)		[inline, static]

Output a human-readable representation of a MassProperties object to the given output stream.

template<class P >

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

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

template<class P >

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

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

template<class P , int S>

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

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

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

template<class P , int S>

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.

template<class P , int S>

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.

template<class P , int S>

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.

template<class P >

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

Composition of Rotation matrices via operator*.

template<class P >

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

Composition of Rotation matrices via operator*.

template<class P >

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

Composition of Rotation matrices via operator*.

template<class P >

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

Composition of Rotation matrices via operator*.

template<class P >

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

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

template<class P >

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

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

template<class P >

Rotation_<P> SimTK::operator/	(	const InverseRotation_< 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).

template<class P >

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

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

PhiMatrixTranspose SimTK::transpose

(

const PhiMatrix &

phi

)

[inline]

PhiMatrixTranspose SimTK::operator~

(

const PhiMatrix &

phi

)

[inline]

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

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

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

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

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

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

template<class P , int S>

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.

template<class P , int S>

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.

template<class P , int S>

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.

template<class P , int S>

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.

template<class P , int S>

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.

template<class P , int S>

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

template<class P , int S>

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

template<class P , int S>

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

template<class P , class E >

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.

template<class P , class E >

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

Multiplying a matrix or vector by a Transform_.

applies it to each element individually.

template<class P , class E >

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

Multiplying a matrix or vector by a Transform_.

applies it to each element individually.

template<class P , class E >

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

Multiplying a matrix or vector by a Transform_.

applies it to each element individually.

template<class P , class E >

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

Multiplying a matrix or vector by a Transform_.

applies it to each element individually.

template<class P , class E >

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

Multiplying a matrix or vector by a Transform_.

applies it to each element individually.

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

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

Multiplying a matrix or vector by a Transform_.

applies it to each element individually.

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

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

Multiplying a matrix or vector by a Transform_.

applies it to each element individually.

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

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

Multiplying a matrix or vector by a Transform_.

applies it to each element individually.

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

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

Multiplying a matrix or vector by a Transform_.

applies it to each element individually.

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

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

Multiplying a matrix or vector by a Transform_.

applies it to each element individually.

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

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

Multiplying a matrix or vector by a Transform_.

applies it to each element individually.

template<class P >

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.

template<class P >

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

Composition of transforms.

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

template<class P >

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

Composition of transforms.

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

template<class P >

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

Composition of transforms.

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

template<class P >

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.

template<class P >

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

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

template<class P >

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

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

template<class P >

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

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

template<class P >

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

Generate formatted output of a Transform to an output stream.

template<class P >

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

Generate formatted output of an InverseTransform to an output stream.

static Real SimTK::convertRadiansToDegrees

(

const Real

rad

)

[inline, static]

static Real SimTK::convertDegreesToRadians

(

const Real

deg

)

[inline, static]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

complex<long double> SimTK::operator*	(	const complex< long double > &	c,
		int	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,
		const float &	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 double &	r
	)		[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,
		int	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,
		const float &	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 double &	r
	)		[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,
		int	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,
		const float &	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 double &	r
	)		[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,
		int	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,
		const float &	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 double &	r
	)		[inline]

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

const float& SimTK::real

(

const conjugate< float > &

c

)

[inline]

const negator<float>& SimTK::imag

(

const conjugate< float > &

c

)

[inline]

const complex<float>& SimTK::conj

(

const conjugate< float > &

c

)

[inline]

float SimTK::abs

(

const conjugate< float > &

c

)

[inline]

float SimTK::norm

(

const conjugate< float > &

c

)

[inline]

const double& SimTK::real

(

const conjugate< double > &

c

)

[inline]

const negator<double>& SimTK::imag

(

const conjugate< double > &

c

)

[inline]

const complex<double>& SimTK::conj

(

const conjugate< double > &

c

)

[inline]

double SimTK::abs

(

const conjugate< double > &

c

)

[inline]

double SimTK::norm

(

const conjugate< double > &

c

)

[inline]

const long double& SimTK::real

(

const conjugate< long double > &

c

)

[inline]

const negator<long double>& SimTK::imag

(

const conjugate< long double > &

c

)

[inline]

const complex<long double>& SimTK::conj

(

const conjugate< long double > &

c

)

[inline]

long double SimTK::abs

(

const conjugate< long double > &

c

)

[inline]

long double SimTK::norm

(

const conjugate< long double > &

c

)

[inline]

template<class R , class CHAR , class TRAITS >

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

template<class R , class CHAR , class TRAITS >

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

template<class R >

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

template<class R >

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

template<class R >

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

template<class R >

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

template<class R >

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

template<class R >

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

template<class R >

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

template<class R >

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

template<class R >

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

template<class R >

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

template<class R >

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

template<class R >

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

template<class R >

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

template<class R >

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

template<class R >

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

template<class R >

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

template<class R >

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

template<class R >

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

template<class R >

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

template<class R >

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

template<class R >

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

template<class R >

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

template<class R >

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

template<class R >

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

template<class R >

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

template<class R >

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

template<class R >

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

template<class R >

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

template<class R >

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

template<class R >

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

template<class R >

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

template<class R >

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

template<class R >

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

template<class R >

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

template<class R >

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

template<class R >

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

template<class R , class S >

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

template<class R , class S >

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

template<class R , class S >

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

template<class R , class S >

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

template<class R , class S >

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

template<class R , class S >

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

template<class R , class S >

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

template<class R , class S >

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

template<class R , class S >

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

template<class R , class S >

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

template<class R , class S >

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

template<class R , class S >

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

template<class R , class S >

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

template<class R , class S >

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

template<class R , class S >

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

template<class R , class S >

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

template<class R , class S >

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

template<class R , class S >

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

template<class R , class S >

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

template<class R , class S >

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

template<class DEST , class SRC >

static const DEST& SimTK::negRecast

(

const SRC &

s

)

[inline, static]

template<class A , class B >

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

template<class A , class B >

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

template<class A , class B >

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

template<class A , class B >

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

template<class A , class B >

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

template<class A , class B >

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

template<class A , class B >

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

template<class A , class B >

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

template<class A , class B >

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

template<class A , class B >

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

template<class A , class B >

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

template<class A , class B >

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

template<class A , class B >

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

template<class A , class B >

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

template<class A , class B >

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

template<class A , class B >

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

template<class A , class B >

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

template<class A , class B >

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

template<class NUM , class CHAR , class TRAITS >

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

template<class NUM , class CHAR , class TRAITS >

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

static const complex<long double> SimTK::zeroes

(

0

)

[static]

SimTK::SimTK_BNTCMPLX_SPEC	(	float	,
		float
	)

SimTK::SimTK_BNTCMPLX_SPEC	(	float	,
		double
	)

SimTK::SimTK_BNTCMPLX_SPEC	(	float	,
		long	double
	)

SimTK::SimTK_BNTCMPLX_SPEC	(	double	,
		float
	)

SimTK::SimTK_BNTCMPLX_SPEC	(	double	,
		double
	)

SimTK::SimTK_BNTCMPLX_SPEC	(	double	,
		long	double
	)

SimTK::SimTK_BNTCMPLX_SPEC	(	long	double,
		float
	)

SimTK::SimTK_BNTCMPLX_SPEC	(	long	double,
		double
	)

SimTK::SimTK_BNTCMPLX_SPEC	(	long	double,
		long	double
	)

SimTK::SimTK_NTRAITS_CONJ_SPEC	(	float	,
		float
	)

SimTK::SimTK_NTRAITS_CONJ_SPEC	(	float	,
		double
	)

SimTK::SimTK_NTRAITS_CONJ_SPEC	(	float	,
		long	double
	)

SimTK::SimTK_NTRAITS_CONJ_SPEC	(	double	,
		float
	)

SimTK::SimTK_NTRAITS_CONJ_SPEC	(	double	,
		double
	)

SimTK::SimTK_NTRAITS_CONJ_SPEC	(	double	,
		long	double
	)

SimTK::SimTK_NTRAITS_CONJ_SPEC	(	long	double,
		float
	)

SimTK::SimTK_NTRAITS_CONJ_SPEC	(	long	double,
		double
	)

SimTK::SimTK_NTRAITS_CONJ_SPEC	(	long	double,
		long	double
	)

SimTK::SimTK_DEFINE_REAL_NTRAITS

(

float

)

SimTK::SimTK_DEFINE_REAL_NTRAITS

(

double

)

SimTK::SimTK_DEFINE_REAL_NTRAITS

(

long

double

)

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

(

EventIndex

)

Unique integer type for Subsystem-local event indexing.

See also:

SystemEventIndex

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

(

EventTriggerIndex

)

Unique integer type for Subsystem-local 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

(

EventTriggerByStageIndex

)

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

See also:

SystemEventTriggerIndex

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

EventId

)

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

MeasureIndex

)

Define a unique integral type for safe indexing of Measures.

template<class T >

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

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

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

SubsystemIndex

)

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

SystemYIndex

)

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

SystemQIndex

)

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

QIndex

)

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

SystemUIndex

)

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

UIndex

)

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

SystemZIndex

)

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

ZIndex

)

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

DiscreteVariableIndex

)

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

CacheEntryIndex

)

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

SystemYErrIndex

)

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

SystemQErrIndex

)

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

QErrIndex

)

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

SystemUErrIndex

)

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

UErrIndex

)

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

SystemUDotErrIndex

)

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

UDotErrIndex

)

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

SystemMultiplierIndex

)

SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE

(

MultiplierIndex

)

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

static System::ProjectOptions SimTK::operator|	(	System::ProjectOptions::Option	o1,
		System::ProjectOptions::Option	o2
	)		[inline, static]

static System::ProjectOptions SimTK::operator|	(	System::ProjectOptions	opts,
		System::ProjectOptions::Option	o
	)		[inline, static]

static System::ProjectOptions SimTK::operator|	(	System::ProjectOptions::Option	o,
		System::ProjectOptions	opts
	)		[inline, static]

static System::ProjectOptions SimTK::operator&	(	System::ProjectOptions::Option	o1,
		System::ProjectOptions::Option	o2
	)		[inline, static]

static System::ProjectOptions SimTK::operator&	(	System::ProjectOptions	opts,
		System::ProjectOptions::Option	o
	)		[inline, static]

static System::ProjectOptions SimTK::operator&	(	System::ProjectOptions::Option	o,
		System::ProjectOptions	opts
	)		[inline, static]

static System::ProjectOptions SimTK::operator~

(

System::ProjectOptions::Option

o

)

[inline, static]

static System::ProjectOptions SimTK::operator-	(	System::ProjectOptions	opts,
		System::ProjectOptions::Option	o
	)		[inline, static]

static System::ProjectOptions SimTK::operator-	(	System::ProjectOptions	opts1,
		System::ProjectOptions	opts2
	)		[inline, static]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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]

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

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]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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]

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

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]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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]

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

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]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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]

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

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]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

template<int M, int N, class E , int CS, int RS, class CHAR , class TRAITS >

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

template<int M, int N, class E , int CS, int RS, class CHAR , class TRAITS >

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

template<int N, class E , int S>

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

template<int N, class E , int S>

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

template<int N, class E , int S>

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

template<int N, class E , int S>

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

template<int N, class E , int S>

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

template<int N, class E , int S>

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

template<int N, class E , int S>

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

template<int N, class E , int S>

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

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

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

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

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

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

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

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

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

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

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

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

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

template<int N, class E , int S>

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

template<int N, class E , int S>

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

template<int N, class E , int S>

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

template<int N, class E , int S>

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

template<int N, class E , int S>

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

template<int N, class E , int S>

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

template<int N, class E , int S>

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

template<int N, class E , int S>

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

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

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

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

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

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

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

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

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

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

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

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

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

template<int N, class E , int S>

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

template<int N, class E , int S>

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

template<int N, class E , int S>

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

template<int N, class E , int S>

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

template<int N, class E , int S>

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

template<int N, class E , int S>

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

template<int N, class E , int S>

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

template<int N, class E , int S>

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

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

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

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

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

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

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

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

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

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

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

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

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

template<int N, class E , int S>

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

template<int N, class E , int S>

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

template<int N, class E , int S>

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

template<int N, class E , int S>

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

template<int N, class E , int S>

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

template<int N, class E , int S>

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

template<int N, class E , int S>

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

template<int N, class E , int S>

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

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

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

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

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

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

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

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

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

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

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

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

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

template<int N, class E , int S, class CHAR , class TRAITS >

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

template<int N, class E , int S, class CHAR , class TRAITS >

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Mat<M,M, typename CNT<E1>::template Result<E2>::Mul> SimTK::outer	(	const Row< M, E1, S1 > &	r,
		const Row< M, E2, S2 > &	s
	)		[inline]

template<int M, int N, class ME , int CS, int RS, class E , int S>

Mat<M,N,ME,CS,RS>::template Result<Vec<N,E,S> >::Mul SimTK::operator*	(	const Mat< M, N, ME, CS, RS > &	m,
		const Vec< N, E, S > &	v
	)		[inline]

template<int M, class E , int S, int N, class ME , int CS, int RS>

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

template<int N, class ME , int RS, class E , int S>

SymMat<N,ME,RS>::template Result<Vec<N,E,S> >::Mul SimTK::operator*	(	const SymMat< N, ME, RS > &	m,
		const Vec< N, E, S > &	v
	)		[inline]

template<class ME , int RS, class E , int S>

SymMat<1,ME,RS>::template Result<Vec<1,E,S> >::Mul SimTK::operator*	(	const SymMat< 1, ME, RS > &	m,
		const Vec< 1, E, S > &	v
	)		[inline]

template<class ME , int RS, class E , int S>

SymMat<2,ME,RS>::template Result<Vec<2,E,S> >::Mul SimTK::operator*	(	const SymMat< 2, ME, RS > &	m,
		const Vec< 2, E, S > &	v
	)		[inline]

template<class ME , int RS, class E , int S>

SymMat<3,ME,RS>::template Result<Vec<3,E,S> >::Mul SimTK::operator*	(	const SymMat< 3, ME, RS > &	m,
		const Vec< 3, E, S > &	v
	)		[inline]

template<int M, class E , int S, class ME , int RS>

Row<M,E,S>::template Result<SymMat<M,ME,RS> >::Mul SimTK::operator*	(	const Row< M, E, S > &	r,
		const SymMat< M, ME, RS > &	m
	)		[inline]

template<class E , int S, class ME , int RS>

Row<1,E,S>::template Result<SymMat<1,ME,RS> >::Mul SimTK::operator*	(	const Row< 1, E, S > &	r,
		const SymMat< 1, ME, RS > &	m
	)		[inline]

template<class E , int S, class ME , int RS>

Row<2,E,S>::template Result<SymMat<2,ME,RS> >::Mul SimTK::operator*	(	const Row< 2, E, S > &	r,
		const SymMat< 2, ME, RS > &	m
	)		[inline]

template<class E , int S, class ME , int RS>

Row<3,E,S>::template Result<SymMat<3,ME,RS> >::Mul SimTK::operator*	(	const Row< 3, E, S > &	r,
		const SymMat< 3, ME, RS > &	m
	)		[inline]

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

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

template<int M, class E1 , int S1, int MM, int NN, class E2 , int CS2, int RS2>

Vec<M,E1,S1>::template Result<Mat<MM,NN,E2,CS2,RS2> >::MulNon SimTK::operator*	(	const Vec< M, E1, S1 > &	v,
		const Mat< MM, NN, E2, CS2, RS2 > &	m
	)		[inline]

template<int M, class E1 , int S1, int MM, class E2 , int RS2>

Vec<M,E1,S1>::template Result<SymMat<MM,E2,RS2> >::MulNon SimTK::operator*	(	const Vec< M, E1, S1 > &	v,
		const SymMat< MM, E2, RS2 > &	m
	)		[inline]

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

Vec<M,E1,S1>::template Result<Vec<MM,E2,S2> >::MulNon SimTK::operator*	(	const Vec< M, E1, S1 > &	v1,
		const Vec< MM, E2, S2 > &	v2
	)		[inline]

template<int M, class E , int S, int MM, int NN, class ME , int CS, int RS>

Row<M,E,S>::template Result<Mat<MM,NN,ME,CS,RS> >::MulNon SimTK::operator*	(	const Row< M, E, S > &	r,
		const Mat< MM, NN, ME, CS, RS > &	m
	)		[inline]

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

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

template<int N1, class E1 , int S1, int N2, class E2 , int S2>

Row<N1,E1,S1>::template Result<Row<N2,E2,S2> >::MulNon SimTK::operator*	(	const Row< N1, E1, S1 > &	r1,
		const Row< N2, E2, S2 > &	r2
	)		[inline]

template<int M, int N, class ME , int CS, int RS, int MM, class E , int S>

Mat<M,N,ME,CS,RS>::template Result<Vec<MM,E,S> >::MulNon SimTK::operator*	(	const Mat< M, N, ME, CS, RS > &	m,
		const Vec< MM, E, S > &	v
	)		[inline]

template<int M, int N, class ME , int CS, int RS, int NN, class E , int S>

Mat<M,N,ME,CS,RS>::template Result<Row<NN,E,S> >::MulNon SimTK::operator*	(	const Mat< M, N, ME, CS, RS > &	m,
		const Row< NN, E, S > &	r
	)		[inline]

template<int M, int N, class ME , int CS, int RS, int Dim, class E , int S>

Mat<M,N,ME,CS,RS>::template Result<SymMat<Dim,E,S> >::MulNon SimTK::operator*	(	const Mat< M, N, ME, CS, RS > &	m,
		const SymMat< Dim, E, S > &	sy
	)		[inline]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

template<class E1 , int S1, int N, class E2 , int CS, int RS>

Mat<3,N,typename CNT<E1>::template Result<E2>::Mul> SimTK::cross	(	const Vec< 3, E1, S1 > &	v,
		const Mat< 3, N, E2, CS, RS > &	m
	)		[inline]

template<class E1 , int S1, int N, class E2 , int CS, int RS>

Mat<3,N,typename CNT<E1>::template Result<E2>::Mul> SimTK::operator%	(	const Vec< 3, E1, S1 > &	v,
		const Mat< 3, N, E2, CS, RS > &	m
	)		[inline]

template<class EV , int SV, class EM , int RS>

Mat<3,3,typename CNT<EV>::template Result<EM>::Mul> SimTK::cross	(	const Vec< 3, EV, SV > &	v,
		const SymMat< 3, EM, RS > &	s
	)		[inline]

template<class EV , int SV, class EM , int RS>

Mat<3,3,typename CNT<EV>::template Result<EM>::Mul> SimTK::operator%	(	const Vec< 3, EV, SV > &	v,
		const SymMat< 3, EM, RS > &	s
	)		[inline]

template<class E1 , int S1, int N, class E2 , int CS, int RS>

Mat<3,N,typename CNT<E1>::template Result<E2>::Mul> SimTK::cross	(	const Row< 3, E1, S1 > &	r,
		const Mat< 3, N, E2, CS, RS > &	m
	)		[inline]

template<class E1 , int S1, int N, class E2 , int CS, int RS>

Mat<3,N,typename CNT<E1>::template Result<E2>::Mul> SimTK::operator%	(	const Row< 3, E1, S1 > &	r,
		const Mat< 3, N, E2, CS, RS > &	m
	)		[inline]

template<class EV , int SV, class EM , int RS>

Mat<3,3,typename CNT<EV>::template Result<EM>::Mul> SimTK::cross	(	const Row< 3, EV, SV > &	r,
		const SymMat< 3, EM, RS > &	s
	)		[inline]

template<class EV , int SV, class EM , int RS>

Mat<3,3,typename CNT<EV>::template Result<EM>::Mul> SimTK::operator%	(	const Row< 3, EV, SV > &	r,
		const SymMat< 3, EM, RS > &	s
	)		[inline]

template<int M, class EM , int CS, int RS, class EV , int S>

Mat<M,3,typename CNT<EM>::template Result<EV>::Mul> SimTK::cross	(	const Mat< M, 3, EM, CS, RS > &	m,
		const Vec< 3, EV, S > &	v
	)		[inline]

template<int M, class EM , int CS, int RS, class EV , int S>

Mat<M,3,typename CNT<EM>::template Result<EV>::Mul> SimTK::operator%	(	const Mat< M, 3, EM, CS, RS > &	m,
		const Vec< 3, EV, S > &	v
	)		[inline]

template<class EM , int RS, class EV , int SV>

Mat<3,3,typename CNT<EM>::template Result<EV>::Mul> SimTK::cross	(	const SymMat< 3, EM, RS > &	s,
		const Vec< 3, EV, SV > &	v
	)		[inline]

template<class EM , int RS, class EV , int SV>

Mat<3,3,typename CNT<EM>::template Result<EV>::Mul> SimTK::operator%	(	const SymMat< 3, EM, RS > &	s,
		const Vec< 3, EV, SV > &	v
	)		[inline]

template<int M, class EM , int CS, int RS, class ER , int S>

Mat<M,3,typename CNT<EM>::template Result<ER>::Mul> SimTK::cross	(	const Mat< M, 3, EM, CS, RS > &	m,
		const Row< 3, ER, S > &	r
	)		[inline]

template<int M, class EM , int CS, int RS, class ER , int S>

Mat<M,3,typename CNT<EM>::template Result<ER>::Mul> SimTK::operator%	(	const Mat< M, 3, EM, CS, RS > &	m,
		const Row< 3, ER, S > &	r
	)		[inline]

template<class EM , int RS, class EV , int SV>

Mat<3,3,typename CNT<EM>::template Result<EV>::Mul> SimTK::cross	(	const SymMat< 3, EM, RS > &	s,
		const Row< 3, EV, SV > &	r
	)		[inline]

template<class EM , int RS, class EV , int SV>

Mat<3,3,typename CNT<EM>::template Result<EV>::Mul> SimTK::operator%	(	const SymMat< 3, EM, RS > &	s,
		const Row< 3, EV, SV > &	r
	)		[inline]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

template<class E , int S>

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

(

const Vec< 3, E, S > &

v

)

[inline]

Calculate matrix M(v) such that M(v)*w = v % w.

We produce the same M regardless of whether v is a column or row. Requires 3 flops to form.

template<class E , int S>

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

(

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

v

)

[inline]

Specialize crossMat() for negated scalar types.

Returned matrix loses negator. Requires 3 flops to form.

template<class E , int S>

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

(

const Row< 3, E, S > &

r

)

[inline]

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

template<class E , int S>

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

(

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

r

)

[inline]

Form cross product matrix from a Row vector whose elements are negated scalars; 3 flops.

template<class E , int S>

Row<2,E> SimTK::crossMat

(

const Vec< 2, E, S > &

v

)

[inline]

Calculate 2D cross product matrix M(v) such that M(v)*w = v0*w1-v1*w0 = v % w (a scalar).

Whether v is a Vec<2> or Row<2> we create the same M, which will be a 2-element Row. Requires 1 flop to form.

template<class E , int S>

Row<2,E> SimTK::crossMat

(

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

v

)

[inline]

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

template<class E , int S>

Row<2,E> SimTK::crossMat

(

const Row< 2, E, S > &

r

)

[inline]

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

template<class E , int S>

Row<2,E> SimTK::crossMat

(

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

r

)

[inline]

Form 2D cross product matrix from a Row<2> with negated scalar elements; 1 flop.

template<class E , int S>

SymMat<3,E> SimTK::crossMatSq

(

const Vec< 3, E, S > &

v

)

[inline]

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

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

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

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

where "T" indicates that the element is identical to the symmetric one. 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.

template<class E , int S>

SymMat<3,E> SimTK::crossMatSq

(

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

v

)

[inline]

template<class E , int S>

SymMat<3,E> SimTK::crossMatSq

(

const Row< 3, E, S > &

r

)

[inline]

template<class E , int S>

SymMat<3,E> SimTK::crossMatSq

(

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

r

)

[inline]

template<class E , int CS, int RS>

E SimTK::det

(

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

m

)

[inline]

Special case Mat 1x1 determinant. No computation.

template<class E , int RS>

E SimTK::det

(

const SymMat< 1, E, RS > &

s

)

[inline]

Special case SymMat 1x1 determinant. No computation.

template<class E , int CS, int RS>

E SimTK::det

(

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

m

)

[inline]

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

template<class E , int RS>

E SimTK::det

(

const SymMat< 2, E, RS > &

s

)

[inline]

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

template<class E , int CS, int RS>

E SimTK::det

(

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

m

)

[inline]

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

template<class E , int RS>

E SimTK::det

(

const SymMat< 3, E, RS > &

s

)

[inline]

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

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

E SimTK::det

(

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

m

)

[inline]

Calculate the determinant of a square matrix larger than 3x3 by recursive template expansion.

The matrix elements must be multiplication compatible for this to compile successfully. All scalar element types are acceptable; some composite types will also work but the result is probably meaningless. The determinant suffers from increasingly bad scaling as the matrices get bigger; you should consider an alternative if possible (see Golub and van Loan, "Matrix Computations"). This uses M*det(M-1) + 4*M flops. For 4x4 that's 60 flops, for 5x5 it's 320, and it grows really fast from there! TODO: this is not the right way to calculate determinant -- should calculate LU factorization at 2/3 n^3 flops, then determinant is product of LU's diagonals.

template<int M, class E , int RS>

E SimTK::det

(

const SymMat< M, E, RS > &

s

)

[inline]

Determinant of SymMat larger than 3x3.

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

template<class E , int CS, int RS>

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

(

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

m

)

[inline]

Specialized 1x1 lapackInverse(): costs one divide.

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

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

(

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

m

)

[inline]

General inverse of small, fixed-size, square (mXm), non-singular matrix with scalar elements: use Lapack's LU routine with pivoting.

This will only work if the element type E is a scalar type, although negator<> and conjugate<> are OK. This routine is not specialized for small matrix sizes other than 1x1, while the inverse() method is specialized for other small sizes for speed, possibly losing some numerical stability. The inverse() function ends up calling this one at sizes for which it has no specialization. Normally you should call inverse(), but you can call lapackInverse() explicitly if you want to ensure that the most stable algorithm is used.

See also:

inverse()

template<class E , int CS, int RS>

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

(

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

m

)

[inline]

Specialized 1x1 Mat inverse: costs one divide.

template<class E , int RS>

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

(

const SymMat< 1, E, RS > &

s

)

[inline]

Specialized 1x1 SymMat inverse: costs one divide.

template<class E , int CS, int RS>

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

(

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

m

)

[inline]

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

template<class E , int RS>

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

(

const SymMat< 2, E, RS > &

s

)

[inline]

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

template<class E , int CS, int RS>

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

(

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

m

)

[inline]

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

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

See also:

lapackInverse()

template<class E , int RS>

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

(

const SymMat< 3, E, RS > &

s

)

[inline]

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

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

See also:

lapackSymInverse()

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

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

(

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

m

)

[inline]

For any matrix larger than 3x3, we just punt to the Lapack implementation.

See also:

lapackInverse()

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

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

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

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

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

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

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

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

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

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

template<int M, class E , int S>

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

template<int M, class E , int S>

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

template<int M, class E , int S>

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

template<int M, class E , int S>

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

template<int M, class E , int S>

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

template<int M, class E , int S>

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

template<int M, class E , int S>

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

template<int M, class E , int S>

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

template<int M, class E , int S, class R >

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

template<int M, class E , int S, class R >

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

template<int M, class E , int S, class R >

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

template<int M, class E , int S, class R >

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

template<int M, class E , int S, class R >

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

template<int M, class E , int S, class R >

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

template<int M, class E , int S>

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

template<int M, class E , int S>

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

template<int M, class E , int S>

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

template<int M, class E , int S>

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

template<int M, class E , int S>

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

template<int M, class E , int S>

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

template<int M, class E , int S>

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

template<int M, class E , int S>

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

template<int M, class E , int S, class R >

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

template<int M, class E , int S, class R >

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

template<int M, class E , int S, class R >

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

template<int M, class E , int S, class R >

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

template<int M, class E , int S, class R >

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

template<int M, class E , int S, class R >

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

template<int M, class E , int S>

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

template<int M, class E , int S>

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

template<int M, class E , int S>

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

template<int M, class E , int S>

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

template<int M, class E , int S>

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

template<int M, class E , int S>

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

template<int M, class E , int S>

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

template<int M, class E , int S>

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

template<int M, class E , int S, class R >

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

template<int M, class E , int S, class R >

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

template<int M, class E , int S, class R >

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

template<int M, class E , int S, class R >

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

template<int M, class E , int S, class R >

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

template<int M, class E , int S, class R >

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

template<int M, class E , int S>

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

template<int M, class E , int S>

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

template<int M, class E , int S>

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

template<int M, class E , int S>

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

template<int M, class E , int S>

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

template<int M, class E , int S>

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

template<int M, class E , int S>

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

template<int M, class E , int S>

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

template<int M, class E , int S, class R >

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

template<int M, class E , int S, class R >

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

template<int M, class E , int S, class R >

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

template<int M, class E , int S, class R >

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

template<int M, class E , int S, class R >

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

template<int M, class E , int S, class R >

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

template<int M, class E , int RS, class CHAR , class TRAITS >

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

template<int M, class E , int RS, class CHAR , class TRAITS >

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

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

Vec<M,E1,S1>::template Result< Vec<M,E2,S2> >::Add SimTK::operator+	(	const Vec< M, E1, S1 > &	l,
		const Vec< M, E2, S2 > &	r
	)		[inline]

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

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

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

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

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

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

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

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

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

bool SimTK::operator==	(	const Vec< M, E1, S1 > &	v,
		const E2 &	e
	)		[inline]

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

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

bool SimTK::operator!=	(	const Vec< M, E1, S1 > &	v,
		const E2 &	e
	)		[inline]

bool = v[i] != e, for any element v[i] and element e

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

bool SimTK::operator<=	(	const Vec< M, E1, S1 > &	v,
		const E2 &	e
	)		[inline]

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

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

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

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

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

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

bool SimTK::operator>=	(	const Vec< M, E1, S1 > &	v,
		const E2 &	e
	)		[inline]

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

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

template<int M, class E , int S>

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

template<int M, class E , int S>

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

template<int M, class E , int S>

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

template<int M, class E , int S>

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

template<int M, class E , int S>

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

template<int M, class E , int S>

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

template<int M, class E , int S>

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

template<int M, class E , int S>

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

template<int M, class E , int S, class R >

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

template<int M, class E , int S, class R >

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

template<int M, class E , int S, class R >

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

template<int M, class E , int S, class R >

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

template<int M, class E , int S, class R >

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

template<int M, class E , int S, class R >

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

template<int M, class E , int S>

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

template<int M, class E , int S>

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

template<int M, class E , int S>

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

template<int M, class E , int S>

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

template<int M, class E , int S>

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

template<int M, class E , int S>

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

template<int M, class E , int S>

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

template<int M, class E , int S>

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

template<int M, class E , int S, class R >

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

template<int M, class E , int S, class R >

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

template<int M, class E , int S, class R >

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

template<int M, class E , int S, class R >

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

template<int M, class E , int S, class R >

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

template<int M, class E , int S, class R >

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

template<int M, class E , int S>

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

template<int M, class E , int S>

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

template<int M, class E , int S>

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

template<int M, class E , int S>

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

template<int M, class E , int S>

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

template<int M, class E , int S>

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

template<int M, class E , int S>

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

template<int M, class E , int S>

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

template<int M, class E , int S, class R >

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

template<int M, class E , int S, class R >

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

template<int M, class E , int S, class R >

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

template<int M, class E , int S, class R >

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

template<int M, class E , int S, class R >

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

template<int M, class E , int S, class R >

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

template<int M, class E , int S>

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

template<int M, class E , int S>

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

template<int M, class E , int S>

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

template<int M, class E , int S>

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

template<int M, class E , int S>

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

template<int M, class E , int S>

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

template<int M, class E , int S>

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

template<int M, class E , int S>

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

template<int M, class E , int S, class R >

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

template<int M, class E , int S, class R >

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

template<int M, class E , int S, class R >

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

template<int M, class E , int S, class R >

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

template<int M, class E , int S, class R >

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

template<int M, class E , int S, class R >

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

template<int M, class E , int S, class CHAR , class TRAITS >

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

template<int M, class E , int S, class CHAR , class TRAITS >

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

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

static int SimTK::explicitODE_static	(	const CPodesSystem &	sys,
		Real	t,
		const Vector &	y,
		Vector &	fout
	)		[static]

static int SimTK::implicitODE_static	(	const CPodesSystem &	sys,
		Real	t,
		const Vector &	y,
		const Vector &	yp,
		Vector &	fout
	)		[static]

static int SimTK::constraint_static	(	const CPodesSystem &	sys,
		Real	t,
		const Vector &	y,
		Vector &	cout
	)		[static]

static int SimTK::project_static	(	const CPodesSystem &	sys,
		Real	t,
		const Vector &	ycur,
		Vector &	corr,
		Real	epsProj,
		Vector &	err
	)		[static]

static int SimTK::quadrature_static	(	const CPodesSystem &	sys,
		Real	t,
		const Vector &	y,
		Vector &	qout
	)		[static]

static int SimTK::root_static	(	const CPodesSystem &	sys,
		Real	t,
		const Vector &	y,
		const Vector &	yp,
		Vector &	gout
	)		[static]

static int SimTK::weight_static	(	const CPodesSystem &	sys,
		const Vector &	y,
		Vector &	weights
	)		[static]

static void SimTK::errorHandler_static	(	const CPodesSystem &	sys,
		int	error_code,
		const char *	module,
		const char *	function,
		char *	msg
	)		[static]

---

Variable Documentation

const Vec3 SimTK::Black = Vec3( 0, 0, 0) [static]

const Vec3 SimTK::Gray = Vec3(.5,.5,.5) [static]

const Vec3 SimTK::Red = Vec3( 1, 0, 0) [static]

const Vec3 SimTK::Green = Vec3( 0, 1, 0) [static]

const Vec3 SimTK::Blue = Vec3( 0, 0, 1) [static]

const Vec3 SimTK::Yellow = Vec3( 1, 1, 0) [static]

const Vec3 SimTK::Orange = Vec3( 1,.5, 0) [static]

const Vec3 SimTK::Magenta = Vec3( 1, 0, 1) [static]

const Vec3 SimTK::Purple = Vec3(.5, 0,.5) [static]

const Vec3 SimTK::Cyan = Vec3( 0, 1, 1) [static]

const Vec3 SimTK::White = Vec3( 1, 1, 1) [static]

std::map<void*, pthread_key_t> SimTK::instanceMap [static]

std::map<pthread_key_t, std::set<void*> > SimTK::keyInstances [static]

pthread_mutex_t SimTK::keyLock = PTHREAD_MUTEX_INITIALIZER [static]

const CoordinateAxis::XCoordinateAxis SimTK::XAxis [static]

Constant representing the X coordinate axis; will implicitly convert to the integer 0 when used in a context requiring an integer.

const CoordinateAxis::YCoordinateAxis SimTK::YAxis [static]

Constant representing the Y coordinate axis; will implicitly convert to the integer 1 when used in a context requiring an integer.

const CoordinateAxis::ZCoordinateAxis SimTK::ZAxis [static]

Constant representing the Z coordinate axis; will implicitly convert to the integer 2 when used in a context requiring an integer.

const CoordinateDirection::NegXDirection SimTK::NegXAxis [static]

const CoordinateDirection::NegYDirection SimTK::NegYAxis [static]

const CoordinateDirection::NegZDirection SimTK::NegZAxis [static]

const double SimTK::DefaultRecpCondition = 1e-12 [static]