Simbody  3.6
SimTK Namespace Reference

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

Namespaces

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

Classes

class  AbstractMeasure
 This is the base class for all Measure handle classes. More...
 
class  AbstractValue
 Abstract base class representing an arbitrary value of unknown type. More...
 
struct  AndOpType
 This is an operator for and-ing compile-time truth types. More...
 
struct  AndOpType< FalseType, FalseType >
 
struct  AndOpType< FalseType, TrueType >
 
struct  AndOpType< TrueType, FalseType >
 
struct  AndOpType< TrueType, TrueType >
 
class  Array_
 The Array_<T> container class is a plug-compatible replacement for the C++ standard template library (STL) std::vector<T> class, but with some important advantages in performance, and functionality, and binary compatibility. More...
 
struct  ArrayIndexTraits
 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< bool >
 Specialization of ArrayIndexTraits for bool used as an index. More...
 
struct  ArrayIndexTraits< char >
 Specialization of ArrayIndexTraits for char used as an index. More...
 
struct  ArrayIndexTraits< int >
 Specialization of ArrayIndexTraits for (signed) int used as an index. More...
 
struct  ArrayIndexTraits< long >
 Specialization of ArrayIndexTraits for (signed) long used as an index. More...
 
struct  ArrayIndexTraits< long long >
 Specialization of ArrayIndexTraits for long long used as an index. More...
 
struct  ArrayIndexTraits< short >
 Specialization of ArrayIndexTraits for (signed) short used as an index. More...
 
struct  ArrayIndexTraits< signed char >
 Specialization of ArrayIndexTraits for signed char used as an index. More...
 
struct  ArrayIndexTraits< unsigned >
 Specialization of ArrayIndexTraits for unsigned (that is, unsigned int) used as an index. More...
 
struct  ArrayIndexTraits< unsigned char >
 Specialization of ArrayIndexTraits for unsigned char used as an index. More...
 
struct  ArrayIndexTraits< unsigned long >
 Specialization of ArrayIndexTraits for unsigned long used as an index. More...
 
struct  ArrayIndexTraits< unsigned long long >
 Specialization of ArrayIndexTraits for unsigned long long used as an index. More...
 
struct  ArrayIndexTraits< unsigned short >
 Specialization of ArrayIndexTraits for unsigned short used as an index. 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  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  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  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  BicubicFunction
 This is a two-argument Function built using a shared BicubicSurface and managing current state to optimize for localized access. More...
 
class  BicubicSurface
 This class will create a smooth surface that approximates a two-argument function F(X,Y) from a given set of samples of that function on a rectangular grid with regular or irregular spacing. More...
 
class  Body
 The Body class represents a reference frame that can be used to describe mass properties and geometry. More...
 
class  BoundedSpeedConstraint
 TODO: not implemented yet. More...
 
class  BrickHalfSpaceContact
 This subclass of Contact is used when one ContactGeometry object is a half plane and the other is a Brick. More...
 
class  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  CableObstacle
 An obstacle is any significant object along the cable path – one of the end points, a via point, or a surface. More...
 
class  CableObstacleIndex
 This is a unique integer type for identifying obstacles comprising a particular cable path. More...
 
class  CablePath
 This class represents the path of a frictionless cable from an origin point fixed to a body, through via points and over geometric obstacles fixed to other bodies, to a final termination point. More...
 
class  CablePathIndex
 This is a unique integer type for quickly identifying specific cables for fast lookup purposes. More...
 
class  CableSpring
 This force element implements a passive elastic element (like a rubber band) that follows a frictionless CablePath across a set of "obstacles". More...
 
class  CableTrackerSubsystem
 This subsystem tracks the paths of massless, frictionless cables that take the shortest route between two distant points of a multibody system, passing smoothly over geometric obstacles that are attached to intermediate bodies. More...
 
class  CacheEntryIndex
 This unique integer type is for selecting non-shared cache entries. 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  CloneOnWritePtr
 Smart pointer with deep copy semantics but with the copying delayed until an attempt is made to write on the contained object. More...
 
class  ClonePtr
 Smart pointer with deep copy semantics. More...
 
class  CNT
 Specialized information about Composite Numerical Types which allows us to define appropriate templatized classes using them. More...
 
class  CNT< complex< R > >
 Specializations of CNT for numeric types. More...
 
class  CNT< conjugate< R > >
 
class  CNT< double >
 
class  CNT< float >
 
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  ConditionalConstraint
 TODO: Simbody model element representing a conditionally-enforced constraint. More...
 
class  conjugate
 SimTK::conjugate<R> should be instantiated only for float, double. More...
 
class  conjugate< double >
 
class  conjugate< float >
 
class  Constraint
 This is the base class for all Constraint classes, which is just a handle for the underlying hidden implementation. 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  Contact
 A Contact contains information about the spatial relationship between two surfaces that are near, or in contact with, each other. 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  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  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  ContactGeometry
 A ContactGeometry object describes the shape of all or part of the boundary of a solid object, for the purpose of modeling with Simbody physical effects that occur at the surface of that object, such as contact and wrapping forces. More...
 
class  ContactGeometryTypeId
 This is a unique integer type for quickly identifying specific types of contact geometry for fast lookup purposes. More...
 
class  ContactId
 This is a unique integer Id assigned to each contact pair when we first begin to track it. 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  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  ContactSnapshot
 Objects of this class represent collections of surface-pair interactions that are being tracked at a particular instant during a simulation. 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  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  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  ContactTrackerSubsystem
 This subsystem identifies and tracks potential contacts between the mobilized bodies of a multibody system. More...
 
class  ContactTypeId
 This is a small integer that serves as the unique typeid for each type of concrete Contact class. 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  CPodes
 This is a straightforward translation of the Sundials CPODES C interface into C++. More...
 
class  CPodesIntegrator
 This is an Integrator based on the CPODES library. More...
 
class  CPodesSystem
 This abstract class defines the system to be integrated with SimTK CPodes. More...
 
class  DecorationGenerator
 A DecorationGenerator is used to define geometry that may change over the course of a simulation. More...
 
class  Decorations
 This defines a single DecorativeGeometry object that is composed of a collection of other DecorativeGeometry objects. More...
 
class  DecorationSubsystem
 This is the client-side handle class encapsulating the hidden implementation of the DecorationSubsystem. More...
 
class  DecorativeArrow
 An arrow with start point, end point and tip-length. More...
 
class  DecorativeBrick
 This defines a rectangular solid centered at the origin and aligned with the local frame axes. More...
 
class  DecorativeCircle
 This defines a circle in the x-y plane, centered at the origin. More...
 
class  DecorativeCone
 A cone with origin point, direction, height and base radius. More...
 
class  DecorativeCylinder
 This defines a cylinder centered on the origin and aligned in the y direction. More...
 
class  DecorativeEllipsoid
 This defines an ellipsoidal solid centered at the origin and aligned with the local frame axes. More...
 
class  DecorativeFrame
 This defines geometry to represent a coordinate frame. More...
 
class  DecorativeGeometry
 This is the client-side interface to an implementation-independent representation of "Decorations" suitable for visualization, annotation, logging, or debugging but which cannot have any effect on the behavior of a System or the evolution of a Study. More...
 
class  DecorativeGeometryImplementation
 Use this abstract class to connect your implementation of decorative geometry to the implementation-independent classes above. More...
 
class  DecorativeLine
 A line between two points. More...
 
class  DecorativeMesh
 This defines a displayable mesh by referencing an already-existing PolygonalMesh object. More...
 
class  DecorativeMeshFile
 This defines a displayable mesh by referencing a file name containing the mesh. More...
 
class  DecorativePoint
 A point of interest. More...
 
class  DecorativeSphere
 This defines a sphere centered at the origin. More...
 
class  DecorativeText
 This defines a text label with its base at the origin. More...
 
class  DecorativeTorus
 This defines a displayable torus, the torus is centered at the origin with the axial direction aligned to the z-axis. More...
 
class  DefaultOptimizer
 
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  Differentiator
 Given a function f(y), where f, y or both can be vectors, calculate the derivative (gradient, Jacobian) df/dy. More...
 
class  DiscreteVariableIndex
 This unique integer type is for selecting discrete variables. More...
 
struct  DontCopy
 This is a special type used for causing invocation of a particular constructor or method overload that will avoid making a copy of the source (that is, perform a "shallow" copy rather than a "deep" copy). More...
 
class  EdgeEdgeContact
 (Experimental – API will change – use at your own risk) Define an edge on each of two bodies, by providing an "edge frame" where the origin is the edge center, x axis is aligned with the edge, and z axis points in the "outward" direction away from the solid whose edge it is. More...
 
class  Eigen
 Class to compute Eigen values and Eigen vectors of a matrix. More...
 
class  ElasticFoundationForce
 This class implements an elastic foundation or "bed of springs" contact model. 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  Event
 An Event is "something that happens" during a Study that is advancing through time. More...
 
class  EventHandler
 An EventHandler is an object that defines an event that can occur within a system. More...
 
class  EventId
 This is a class to represent unique IDs for events in a type-safe way. More...
 
class  EventReporter
 An EventReporter is an object that defines an event that can occur within a system. More...
 
class  EventTriggerByStageIndex
 Unique integer type for Subsystem-local, per-stage event indexing. 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  ExplicitEulerIntegrator
 This is an Integrator based on the explicit Euler algorithm. 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  FactorSVD
 Class to compute a singular value decomposition of a matrix. More...
 
struct  FalseType
 This is a compile-time equivalent of "false", used in compile-time condition checking in templatized implementations. More...
 
class  Force
 This is the base class from which all Force element handle classes derive. More...
 
class  ForceIndex
 This type represents the index of a Force element within its subsystem. More...
 
class  ForceSubsystem
 This is logically an abstract class, more specialized than "Subsystem" but not yet concrete. More...
 
class  Function_
 This abstract class represents a mathematical function that calculates a value of arbitrary type based on M real arguments. More...
 
class  GCVSPLUtil
 This class provides entry points for using the GCVSPL algorithm in terms of SimTK data types. More...
 
class  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  Geo
 The Geo class collects geometric primitives intended to deal with raw, fixed-size geometric shapes occupying minimal memory and providing maximum performance through small inline methods and larger high performance algorithms. More...
 
class  Geodesic
 This class stores a geodesic curve after it has been determined. More...
 
class  GeodesicDecorator
 This class generates decoration (line segments) for a geodesic curve. More...
 
class  GeodesicIntegrator
 This is a stripped-down numerical integrator for small ODE or DAE problems whose size is known at compile time, with no provision for discrete variables, event detection, or interpolation. More...
 
class  GeodesicOptions
 This class stores options for calculating geodesics. More...
 
class  GeodHitPlaneEvent
 A event handler to terminate integration when geodesic hits the plane. More...
 
class  HandleEventsOptions
 Options for the handleEvent() method. More...
 
class  HandleEventsResults
 Results returned by the handleEvent() method. More...
 
class  HardStopLower
 (Experimental – API will change – use at your own risk) Set a hard limit on the minimum value of a generalized coordinate q. More...
 
class  HardStopUpper
 (Experimental – API will change – use at your own risk) Set a hard limit on the maximum value of a generalized coordinate q. More...
 
class  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  ImpulseSolver
 This is the abstract base class for impulse solvers, which solve an important subproblem of the contact and impact equations. More...
 
class  Inertia_
 The physical meaning of an inertia is the distribution of a rigid body's mass about a particular point. More...
 
class  Integrator
 An Integrator is an object that can advance the State of a System through time. More...
 
class  InverseRotation_
 (Advanced) This InverseRotation class is the inverse of a Rotation. More...
 
class  InverseTransform_
 Transform from frame B to frame F, but with the internal representation inverted. More...
 
struct  Is64BitHelper
 
struct  Is64BitHelper< false >
 
struct  Is64BitHelper< true >
 
struct  IsArithmeticType
 Compile-time test: is this one of the built-in "arithmetic" types, meaning an integral or floating type? More...
 
struct  IsFloatingType
 Compile-time type test: is this one of the built-in floating point types?. More...
 
struct  IsIntegralType
 Compile-time type test: is this one of the built-in integral types?. More...
 
struct  IsVoidType
 Compile-time type test: is this the void type?. More...
 
struct  IsVoidType< void >
 
class  IteratorRange
 Helper class to use range-based for loops with a pair of iterators. More...
 
class  Lapack
 
class  LocalEnergyMinimizer
 This class performs local potential energy minimization of a MultibodySystem. More...
 
class  Markers
 This AssemblyCondition specifies a correspondence between stations on mobilized bodies ("markers") and fixed ground-frame locations ("observations"). More...
 
class  MassProperties_
 This class contains the mass, center of mass, and unit inertia matrix of a rigid body B. More...
 
class  Mat
 This class represents a small matrix whose size is known at compile time, containing elements of any Composite Numerical Type (CNT) and engineered to have no runtime overhead whatsoever. More...
 
class  Matrix_
 This is the matrix class intended to appear in user code for large, variable size matrices. More...
 
class  MatrixBase
 This is the common base class for Simbody's Vector_ and Matrix_ classes for handling large, variable-sized vectors and matrices. More...
 
class  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  MatrixCondition
 Matrix "condition" is a statement about the numerical characteristics of a Matrix. 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  MatrixHelperRep
 
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  MatrixStorage
 Matrix "storage" refers to the physical layout of data in the computer's memory. 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  MatrixView_
 (Advanced) This class is identical to Matrix_ except that it has shallow (reference) copy and assignment semantics. More...
 
class  Measure_
 This is the base handle class for all Measures whose value type is known, including all the Simbody built-in Measure types. More...
 
class  MobilizedBody
 A MobilizedBody is Simbody's fundamental body-and-joint object used to parameterize a system's motion by constructing a multibody tree containing each body and its unique mobilizer (internal coordinate joint). More...
 
class  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  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  Motion
 A Motion object belongs to a particular MobilizedBody and prescribes how the associated motion is to be calculated. More...
 
class  MultibodyGraphMaker
 Construct a reasonably good spanning-tree-plus-constraints structure for modeling a given set of bodies and joints with a generalized coordinate multibody system like Simbody. More...
 
class  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  MultiplierIndex
 Unique integer type for Subsystem-local multiplier indexing. More...
 
struct  Narrowest
 This class is specialized for all 16 combinations of standard types (that is, real and complex types in each of two precisions) and has typedefs "Type" which is the appropriate "narrowed" type for use when R1 & R2 appear in an operation together where the result must be of the narrower precision, and "Precision" which is the expected precision of the result (float, double). More...
 
struct  Narrowest< complex< R1 >, complex< R2 > >
 
struct  Narrowest< complex< R1 >, R2 >
 
struct  Narrowest< double, double >
 
struct  Narrowest< double, float >
 
struct  Narrowest< float, double >
 
struct  Narrowest< float, float >
 
struct  Narrowest< R1, complex< R2 > >
 
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  NiceTypeName
 Obtain human-readable and XML-usable names for arbitrarily-complicated C++ types. More...
 
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  OBBLeaf
 TODO. More...
 
class  OBBNode
 TODO. More...
 
class  OBBTree
 TODO. More...
 
class  ObservedPointFitter
 This class attempts to find the configuration of an internal coordinate model which best fits a set of observed data. More...
 
class  Optimizer
 API for SimTK Simmath's optimizers. More...
 
class  OptimizerSystem
 Abstract class which defines an objective/cost function which is optimized by and Optimizer object. More...
 
class  OrientationSensors
 This AssemblyCondition specifies a correspondence between orientation sensors fixed on mobilized bodies ("osensors") and Ground-relative orientation sensor readings ("observations"). More...
 
class  OrientedBoundingBox
 This class represents a rectangular box with arbitrary position and orientation. More...
 
struct  OrOpType
 This is an operator for or-ing compile-time truth types. More...
 
struct  OrOpType< FalseType, FalseType >
 
struct  OrOpType< FalseType, TrueType >
 
struct  OrOpType< TrueType, FalseType >
 
struct  OrOpType< TrueType, TrueType >
 
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  ParticleConSurfaceSystem
 
class  ParticleConSurfaceSystemGuts
 
class  PathDecorator
 This class generates decoration for contact points and straight line path segments. More...
 
class  Pathname
 This class encapsulates the handling of file and directory pathnames in a platform-independent manner. More...
 
class  PeriodicEventHandler
 PeriodicEventHandler is a subclass of ScheduledEventHandler which generates a series of uniformly spaced events at regular intervals. More...
 
class  PeriodicEventReporter
 PeriodicEventReporter is a subclass of ScheduledEventReporter which generates a series of uniformly spaced events at regular intervals. More...
 
class  PGSImpulseSolver
 Projected Gauss Seidel impulse solver. More...
 
class  PhiMatrix
 
class  PhiMatrixTranspose
 
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  Plane
 A simple plane class. More...
 
class  PlaneDecorator
 This class generates decoration for a plane. 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  PLUSImpulseSolver
 TODO: PLUS (Poisson-Lankarani-Uchida-Sherman) impulse solver. More...
 
class  PointContact
 OBSOLETE – use CircularPointContact or EllipticalPointContact. More...
 
class  PointPlaneContact
 (Experimental – API will change – use at your own risk) Define a point on one body that cannot penetrate a plane attached to another body. More...
 
class  PointPlaneFrictionlessContact
 (Experimental – API will change – use at your own risk) Define a point on one body that cannot penetrate a plane attached to another body. More...
 
class  PolygonalMesh
 This class provides a description of a mesh made of polygonal faces (not limited to triangles). More...
 
class  PolynomialRootFinder
 This class provides static methods for finding the roots of polynomials. More...
 
class  ProjectOptions
 Options for the advanced project() methods. More...
 
class  ProjectResults
 Results for advanced users of project() methods. More...
 
class  QErrIndex
 Unique integer type for Subsystem-local qErr indexing. More...
 
class  QIndex
 Unique integer type for Subsystem-local q indexing. More...
 
class  Quaternion_
 A Quaternion is a Vec4 with the following behavior: More...
 
class  QValue
 This AssemblyCondition requests that a particular generalized coordinate end up with a specified value. More...
 
class  Random
 This class defines the interface for pseudo-random number generators. More...
 
class  RealizeOptions
 (NOT USED YET) Options for the advanced realize() methods. More...
 
class  RealizeResults
 (NOT USED YET) Results for advanced users of realize() methods. More...
 
class  ReferencePtr
 This is a smart pointer that implements "cross reference" semantics where a pointer data member of some object is intended to refer to some target object in a larger data structure. More...
 
class  ReinitOnCopy
 Ensures that a data member of type T is automatically reinitialized to a given initial value upon copy construction or copy assignment. This allows the compiler-generated default copy methods to be used. More...
 
class  ReinitOnCopyHelper
 This helper class is used only by ReinitOnCopy and is specialized as necessary to support a variety of template types T. More...
 
class  ResetOnCopy
 Ensures that a data member of type T is automatically reset to its default value upon copy construction or copy assignment. This allows the compiler-generated default copy methods to be used. More...
 
class  ResetOnCopyHelper
 This helper class is used only by ResetOnCopy and is specialized as necessary to support a variety of template types T. More...
 
class  Rope
 (Experimental – API will change – use at your own risk) Set a hard upper limit on the separation between a point P on one body and a point Q on another. More...
 
class  Rotation_
 The Rotation class is a Mat33 that guarantees that the matrix can be interpreted as a legitimate 3x3 rotation matrix giving the relative orientation of two right-handed, orthogonal, unit vector bases. More...
 
class  Row
 This is a fixed-length row vector designed for no-overhead inline computation. More...
 
class  RowVector_
 Represents a variable size row vector; much less common than the column vector type Vector_. More...
 
class  RowVectorBase
 This is a dataless rehash of the MatrixBase class to specialize it for RowVectors. More...
 
class  RowVectorView_
 (Advanced) This class is identical to RowVector_ except that it has shallow (reference) copy and assignment semantics. More...
 
class  RTraits
 RTraits is a helper class for NTraits. More...
 
class  RTraits< double >
 
class  RTraits< float >
 
class  RungeKutta2Integrator
 This is a 2nd order Runge-Kutta Integrator using coefficients that are also known as the explicit trapezoid rule. More...
 
class  RungeKutta3Integrator
 This is a 3rd order Runge-Kutta Integrator using coefficients from J.C. More...
 
class  RungeKuttaFeldbergIntegrator
 
class  RungeKuttaMersonIntegrator
 
class  ScheduledEventHandler
 ScheduledEventHandler is a subclass of EventHandler for events that occur at a particular time that is known in advance. More...
 
class  ScheduledEventReporter
 ScheduledEventReporter is a subclass of EventReporter for events that occur at a particular time that is known in advance. More...
 
struct  Segment
 A convenient struct for anything requiring an offset and length to specify a segment of some larger sequence. More...
 
class  SemiExplicitEuler2Integrator
 This is an implementation of a variable-step, first-order semi-explicit Euler method, also known as semi-implicit Euler or symplectic Euler. More...
 
class  SemiExplicitEulerIntegrator
 This is an implementation of the fixed-step Semi-Explicit Euler method, also known as Semi-Implicit Euler or Symplectic Euler. More...
 
class  SemiExplicitEulerTimeStepper
 A low-accuracy, high performance, velocity-level time stepper for models containing unilateral rigid contacts or other conditional constraints. More...
 
class  SimbodyMatterSubsystem
 This subsystem contains the bodies ("matter") in the multibody system, the mobilizers (joints) that define the generalized coordinates used to represent the motion of those bodies, and constraints that must be satisfied by the values of those coordinates. More...
 
class  SimbodyMatterSubtree
 A SimbodyMatterSubtree is a view of a connected subgraph of the tree of mobilized bodies in a SimbodyMatterSubsystem. More...
 
class  SimbodyMatterSubtreeResults
 
class  SpatialInertia_
 A spatial inertia contains the mass, center of mass point, and inertia matrix for a rigid body. More...
 
class  SpherePlaneContact
 (Experimental – API will change – use at your own risk) Define a sphere on one body that cannot penetrate a plane attached to another body. More...
 
class  SphereSphereContact
 (Experimental – API will change – use at your own risk) Define a sphere on each of two bodies. More...
 
class  Spline_
 This class implements a non-uniform Bezier curve. More...
 
class  SplineFitter
 Given a set of data points, this class creates a Spline_ which interpolates or approximates them. More...
 
class  StableArray
 StableArray<T> is like std::vector<T> (or SimTK::Array_<T>) but more stable in two ways: More...
 
class  Stage
 This class is basically a glorified enumerated type, type-safe and range checked but permitting convenient (if limited) arithmetic. More...
 
class  State
 This object is intended to contain all state information for a SimTK::System, except topological information which is stored in the System itself. More...
 
class  StateLimitedFriction
 TODO: not implemented yet. More...
 
class  String
 SimTK::String is a plug-compatible std::string replacement (plus some additional functionality) intended to be suitable for passing through the SimTK API without introducing binary compatibility problems the way std::string does, especially on Windows. More...
 
class  Study
 
class  Subsystem
 A Subsystem is expected to be part of a larger System and to have interdependencies with other subsystems of that same System. More...
 
class  SubsystemIndex
 Provide a unique integer type for identifying Subsystems. More...
 
class  SymMat
 This is a small, fixed-size symmetric or Hermitian matrix designed for no-overhead inline computation. More...
 
class  SysConstraintFunc
 
class  SysObjectiveFunc
 
class  System
 This is the base class that serves as the parent of all SimTK System objects; most commonly Simbody's MultibodySystem class. More...
 
class  SystemEventTriggerByStageIndex
 This unique integer type is for identifying a triggered event within a particular Stage of the full System-level view of the State. More...
 
class  SystemEventTriggerIndex
 This unique integer type is for identifying a triggered event in the full System-level view of the State. 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  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  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  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  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  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  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  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  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  Test
 This is the main class to support testing. More...
 
class  TextDataEventReporter
 This is an EventReporter which prints out numeric data at regular intervals in tabular form. More...
 
class  TimeStepper
 This class uses an Integrator to advance a System through time. More...
 
class  Transform_
 This class represents the rotate-and-shift transform which gives the location and orientation of a new frame F in a base (reference) frame B. More...
 
class  TriangleMeshContact
 This subclass of Contact is used when one or both of the ContactGeometry objects is a TriangleMesh. More...
 
class  TriggeredEventHandler
 TriggeredEventHandler is a subclass of EventHandler for events that occur when some condition is satisfied within the system. More...
 
class  TriggeredEventReporter
 TriggeredEventReporter is a subclass of EventReporter for events that occur when some condition is satisfied within the system. More...
 
struct  TrueType
 This is a compile-time equivalent of "true", used in compile-time condition checking in templatized implementations. More...
 
struct  TrustMe
 This is a special type used for forcing invocation of a particularly dangerous constructor or method overload; don't use this unless you are an advanced user and know exactly what you're getting into. More...
 
class  UDotErrIndex
 Unique integer type for Subsystem-local uDotErr indexing. More...
 
class  UErrIndex
 Unique integer type for Subsystem-local uErr indexing. More...
 
class  UIndex
 Unique integer type for Subsystem-local u indexing. More...
 
class  UnilateralContact
 (Experimental – API will change – use at your own risk) A unilateral contact constraint uses a single holonomic (position) constraint equation to prevent motion in one direction while leaving it unrestricted in the other direction. More...
 
class  UnilateralSpeedConstraint
 TODO: not implemented yet. More...
 
class  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  UnitRow
 This type is used for the transpose of UnitVec, and as the returned row type of a Rotation. More...
 
class  UnitVec
 This class is a Vec3 plus an ironclad guarantee either that: 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  Value
 Concrete templatized class derived from AbstractValue, adding generic value type-specific functionality, with implicit conversion to the underlying type T. More...
 
class  Vec
 This is a fixed-length column vector designed for no-overhead inline computation. More...
 
class  Vector_
 This is the vector class intended to appear in user code for large, variable size column vectors. More...
 
class  VectorBase
 This is a dataless rehash of the MatrixBase class to specialize it for Vectors. More...
 
class  VectorIterator
 This is an iterator for iterating over the elements of a Vector_ or Vec object. More...
 
class  VectorView_
 (Advanced) This class is identical to Vector_ except that it has shallow (reference) copy and assignment semantics. More...
 
class  VerletIntegrator
 This is an Integrator based on the velocity Verlet algorithm. 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...
 
struct  Wider
 
struct  Wider< double, double >
 
struct  Wider< double, float >
 
struct  Wider< float, double >
 
struct  Wider< float, float >
 
struct  Widest
 This class is specialized for all 16 combinations of standard types (that is, real and complex types in each of two precisions) and has typedefs "Type" which is the appropriate "widened" type for use when R1 & R2 appear in an operation together, and "Precision" which is the wider precision (float,double). More...
 
struct  Widest< complex< R1 >, complex< R2 > >
 
struct  Widest< complex< R1 >, R2 >
 
struct  Widest< double, double >
 
struct  Widest< double, float >
 
struct  Widest< float, double >
 
struct  Widest< float, float >
 
struct  Widest< R1, complex< R2 > >
 
struct  XorOpType
 This is an operator for exclusive or-ing compile-time truth types. More...
 
struct  XorOpType< FalseType, FalseType >
 
struct  XorOpType< FalseType, TrueType >
 
struct  XorOpType< TrueType, FalseType >
 
struct  XorOpType< TrueType, TrueType >
 
class  ZIndex
 Unique integer type for Subsystem-local z 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. More...
 
typedef ForceSubsystem::Guts ForceSubsystemRep
 
typedef Visualizer VTKVisualizer
 OBSOLETE: This provides limited backwards compatibility with the old VTK Visualizer that is no longer supported. Switch to Visualizer instead. More...
 
typedef Visualizer::Reporter VTKEventReporter
 OBSOLETE: This provides limited backwards compatibility with the old VTK Visualizer that is no longer supported. Switch to Visualizer::Reporter instead. More...
 
typedef SimTK_Real Real
 This is the default compiled-in floating point type for SimTK, either float or double. More...
 
typedef std::complex< RealComplex
 This is the default complex type for SimTK, with precision for the real and imaginary parts set to the compiled-in Real type. More...
 
typedef std::complex< float > fComplex
 An abbreviation for std::complex<float> for consistency with others. More...
 
typedef std::complex< double > dComplex
 An abbreviation for std::complex<double> for consistency with others. More...
 
typedef Is64BitHelper< Is64BitPlatform >::Result Is64BitPlatformType
 
typedef Function_< RealFunction
 This typedef is used for the very common case that the return type of the Function object is Real. More...
 
typedef Vec< 2, Vec3SpatialVec
 Spatial vectors are used for (rotation,translation) quantities and consist of a pair of Vec3 objects, arranged as a 2-vector of 3-vectors. More...
 
typedef Vec< 2, Vec< 3, float > > fSpatialVec
 A SpatialVec that is always single (float) precision regardless of the compiled-in precision of Real. More...
 
typedef Vec< 2, Vec< 3, double > > dSpatialVec
 A SpatialVec that is always double precision regardless of the compiled-in precision of Real. More...
 
typedef Row< 2, Row3SpatialRow
 This is the type of a transposed SpatialVec; it does not usually appear explicitly in user programs. More...
 
typedef Row< 2, Row< 3, float > > fSpatialRow
 A SpatialRow that is always single (float) precision regardless of the compiled-in precision of Real. More...
 
typedef Row< 2, Row< 3, double > > dSpatialRow
 A SpatialRow that is always double precision regardless of the compiled-in precision of Real. More...
 
typedef Mat< 2, 2, Mat33SpatialMat
 Spatial matrices are used to hold 6x6 matrices that are best viewed as 2x2 matrices of 3x3 matrices; most commonly for spatial and articulated body inertias and spatial shift matrices. More...
 
typedef Mat< 2, 2, Mat< 3, 3, float > > fSpatialMat
 A SpatialMat that is always single (float) precision regardless of the compiled-in precision of Real. More...
 
typedef Mat< 2, 2, Mat< 3, 3, double > > dSpatialMat
 A SpatialMat that is always double precision regardless of the compiled-in precision of Real. More...
 
typedef UnitInertia_< RealUnitInertia
 A unit inertia (gyration) tensor at default precision. More...
 
typedef UnitInertia_< float > fUnitInertia
 A unit inertia (gyration) tensor at float precision. More...
 
typedef UnitInertia_< double > dUnitInertia
 A unit inertia (gyration) tensor at double precision. More...
 
typedef Inertia_< RealInertia
 An inertia tensor at default precision. More...
 
typedef Inertia_< float > fInertia
 An inertia tensor at float precision. More...
 
typedef Inertia_< double > dInertia
 An inertia tensor at double precision. More...
 
typedef MassProperties_< RealMassProperties
 Rigid body mass properties at default precision. More...
 
typedef MassProperties_< float > fMassProperties
 Rigid body mass properties at float precision. More...
 
typedef MassProperties_< double > dMassProperties
 Rigid body mass properties at double precision. More...
 
typedef SpatialInertia_< RealSpatialInertia
 A spatial (rigid body) inertia matrix at default precision. More...
 
typedef SpatialInertia_< float > fSpatialInertia
 A spatial (rigid body) inertia matrix at float precision. More...
 
typedef SpatialInertia_< double > dSpatialInertia
 A spatial (rigid body) inertia matrix at double precision. More...
 
typedef ArticulatedInertia_< RealArticulatedInertia
 An articulated body inertia matrix at default precision. More...
 
typedef ArticulatedInertia_< float > fArticulatedInertia
 An articulated body inertia matrix at float precision. More...
 
typedef ArticulatedInertia_< double > dArticulatedInertia
 An articulated body inertia matrix at double precision. More...
 
typedef UnitInertia Gyration
 For backwards compatibility only; use UnitInertia instead. More...
 
typedef Quaternion_< RealQuaternion
 
typedef Quaternion_< float > fQuaternion
 
typedef Quaternion_< double > dQuaternion
 
typedef Rotation_< RealRotation
 
typedef Rotation_< float > fRotation
 
typedef Rotation_< double > dRotation
 
typedef InverseRotation_< RealInverseRotation
 
typedef InverseRotation_< float > fInverseRotation
 
typedef InverseRotation_< double > dInverseRotation
 
typedef Transform_< RealTransform
 
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< RealConjugate
 
typedef Measure_< RealMeasure
 This typedef is a convenient abbreviation for the most common kind of Measure – one that returns a single Real result; the underlying class is Measure_; look there for documentation. More...
 
typedef long long StageVersion
 This is the type to use for Stage version numbers that get incremented whenever a state variable change invalidates a Stage. More...
 
typedef long long ValueVersion
 This is the type to use for state variable version numbers that get incremented whenever a state value changes. More...
 
using CacheEntryKey = std::pair< SubsystemIndex, CacheEntryIndex >
 
using DiscreteVarKey = std::pair< SubsystemIndex, DiscreteVariableIndex >
 
typedef Vec< 2 > Vec2
 This is the most common 2D vector type: a column of 2 Real values stored consecutively in memory (packed). More...
 
typedef Vec< 3 > Vec3
 This is the most common 3D vector type: a column of 3 Real values stored consecutively in memory (packed). More...
 
typedef Vec< 4 > Vec4
 This is the most common 4D vector type: a column of 4 Real values stored consecutively in memory (packed). More...
 
typedef Mat< 2, 2 > Mat22
 This is the most common 2x2 matrix type: two packed columns of 2 Real values each. More...
 
typedef Mat< 3, 3 > Mat33
 This is the most common 3x3 matrix type: three packed columns of 3 Real values each. More...
 
typedef Mat< 4, 4 > Mat44
 This is the most common 4x4 matrix type: four packed columns of 4 Real values each. More...
 
typedef SymMat< 2 > SymMat22
 A compact, 2x2 Real symmetric matrix; only 3 elements are stored. More...
 
typedef SymMat< 3 > SymMat33
 A compact, 3x3 Real symmetric matrix; only 6 elements are stored. More...
 
typedef SymMat< 4 > SymMat44
 A compact, 2x2 Real symmetric matrix; only 10 elements are stored. More...
 
typedef Row< 2 > Row2
 Packed, 2-element row of Real values. More...
 
typedef Row< 3 > Row3
 Packed, 3-element row of Real values. More...
 
typedef Row< 4 > Row4
 Packed, 4-element row of Real values. More...
 
typedef Vec< 1 > Vec1
 A vector of just one Real element (not too useful). More...
 
typedef Vec< 5 > Vec5
 Packed, 5-element vector of Real values. More...
 
typedef Vec< 6 > Vec6
 Packed, 6-element vector of Real values. More...
 
typedef Vec< 7 > Vec7
 Packed, 7-element vector of Real values. More...
 
typedef Vec< 8 > Vec8
 Packed, 8-element vector of Real values. More...
 
typedef Vec< 9 > Vec9
 Packed, 9-element vector of Real values. More...
 
typedef Mat< 1, 1 > Mat11
 1x1 Real matrix, that is, a scalar. More...
 
typedef Mat< 1, 2 > Mat12
 1x2 Real row matrix. More...
 
typedef Mat< 1, 3 > Mat13
 1x3 Real row matrix. More...
 
typedef Mat< 1, 4 > Mat14
 1x4 Real row matrix. More...
 
typedef Mat< 1, 5 > Mat15
 1x5 Real row matrix. More...
 
typedef Mat< 1, 6 > Mat16
 1x6 Real row matrix. More...
 
typedef Mat< 1, 7 > Mat17
 1x7 Real row matrix. More...
 
typedef Mat< 1, 8 > Mat18
 1x8 Real row matrix. More...
 
typedef Mat< 1, 9 > Mat19
 1x9 Real row matrix. More...
 
typedef Mat< 2, 1 > Mat21
 2x1 Real column matrix. More...
 
typedef Mat< 2, 3 > Mat23
 2x3 Real matrix, packed by columns. More...
 
typedef Mat< 2, 4 > Mat24
 2x4 Real matrix, packed by columns. More...
 
typedef Mat< 2, 5 > Mat25
 2x5 Real matrix, packed by columns. More...
 
typedef Mat< 2, 6 > Mat26
 2x6 Real matrix, packed by columns. More...
 
typedef Mat< 2, 7 > Mat27
 2x7 Real matrix, packed by columns. More...
 
typedef Mat< 2, 8 > Mat28
 2x8 Real matrix, packed by columns. More...
 
typedef Mat< 2, 9 > Mat29
 2x9 Real matrix, packed by columns. More...
 
typedef Mat< 3, 1 > Mat31
 3x1 Real column matrix. More...
 
typedef Mat< 3, 2 > Mat32
 3x2 Real matrix, packed by columns. More...
 
typedef Mat< 3, 4 > Mat34
 3x4 Real matrix, packed by columns. More...
 
typedef Mat< 3, 5 > Mat35
 3x5 Real matrix, packed by columns. More...
 
typedef Mat< 3, 6 > Mat36
 3x6 Real matrix, packed by columns. More...
 
typedef Mat< 3, 7 > Mat37
 3x7 Real matrix, packed by columns. More...
 
typedef Mat< 3, 8 > Mat38
 3x8 Real matrix, packed by columns. More...
 
typedef Mat< 3, 9 > Mat39
 3x9 Real matrix, packed by columns. More...
 
typedef Mat< 4, 1 > Mat41
 4x1 Real column matrix. More...
 
typedef Mat< 4, 2 > Mat42
 4x2 Real matrix, packed by columns. More...
 
typedef Mat< 4, 3 > Mat43
 4x3 Real matrix, packed by columns. More...
 
typedef Mat< 4, 5 > Mat45
 4x5 Real matrix, packed by columns. More...
 
typedef Mat< 4, 6 > Mat46
 4x6 Real matrix, packed by columns. More...
 
typedef Mat< 4, 7 > Mat47
 4x7 Real matrix, packed by columns. More...
 
typedef Mat< 4, 8 > Mat48
 4x8 Real matrix, packed by columns. More...
 
typedef Mat< 4, 9 > Mat49
 4x9 Real matrix, packed by columns. More...
 
typedef Mat< 5, 1 > Mat51
 5x1 Real column matrix. More...
 
typedef Mat< 5, 2 > Mat52
 5x2 Real matrix, packed by columns. More...
 
typedef Mat< 5, 3 > Mat53
 5x3 Real matrix, packed by columns. More...
 
typedef Mat< 5, 4 > Mat54
 5x4 Real matrix, packed by columns. More...
 
typedef Mat< 5, 5 > Mat55
 5x5 Real matrix, packed by columns. More...
 
typedef Mat< 5, 6 > Mat56
 5x6 Real matrix, packed by columns. More...
 
typedef Mat< 5, 7 > Mat57
 5x7 Real matrix, packed by columns. More...
 
typedef Mat< 5, 8 > Mat58
 5x8 Real matrix, packed by columns. More...
 
typedef Mat< 5, 9 > Mat59
 5x9 Real matrix, packed by columns. More...
 
typedef Mat< 6, 1 > Mat61
 6x1 Real column matrix. More...
 
typedef Mat< 6, 2 > Mat62
 6x2 Real matrix, packed by columns. More...
 
typedef Mat< 6, 3 > Mat63
 6x3 Real matrix, packed by columns. More...
 
typedef Mat< 6, 4 > Mat64
 6x4 Real matrix, packed by columns. More...
 
typedef Mat< 6, 5 > Mat65
 6x5 Real matrix, packed by columns. More...
 
typedef Mat< 6, 6 > Mat66
 6x6 Real matrix, packed by columns. More...
 
typedef Mat< 6, 7 > Mat67
 6x7 Real matrix, packed by columns. More...
 
typedef Mat< 6, 8 > Mat68
 6x8 Real matrix, packed by columns. More...
 
typedef Mat< 6, 9 > Mat69
 6x9 Real matrix, packed by columns. More...
 
typedef Mat< 7, 1 > Mat71
 7x1 Real column matrix. More...
 
typedef Mat< 7, 2 > Mat72
 7x2 Real matrix, packed by columns. More...
 
typedef Mat< 7, 3 > Mat73
 7x3 Real matrix, packed by columns. More...
 
typedef Mat< 7, 4 > Mat74
 7x4 Real matrix, packed by columns. More...
 
typedef Mat< 7, 5 > Mat75
 7x5 Real matrix, packed by columns. More...
 
typedef Mat< 7, 6 > Mat76
 7x6 Real matrix, packed by columns. More...
 
typedef Mat< 7, 7 > Mat77
 7x7 Real matrix, packed by columns. More...
 
typedef Mat< 7, 8 > Mat78
 7x8 Real matrix, packed by columns. More...
 
typedef Mat< 7, 9 > Mat79
 7x9 Real matrix, packed by columns. More...
 
typedef Mat< 8, 1 > Mat81
 8x1 Real column matrix. More...
 
typedef Mat< 8, 2 > Mat82
 8x2 Real matrix, packed by columns. More...
 
typedef Mat< 8, 3 > Mat83
 8x3 Real matrix, packed by columns. More...
 
typedef Mat< 8, 4 > Mat84
 8x4 Real matrix, packed by columns. More...
 
typedef Mat< 8, 5 > Mat85
 8x5 Real matrix, packed by columns. More...
 
typedef Mat< 8, 6 > Mat86
 8x6 Real matrix, packed by columns. More...
 
typedef Mat< 8, 7 > Mat87
 8x7 Real matrix, packed by columns. More...
 
typedef Mat< 8, 8 > Mat88
 8x8 Real matrix, packed by columns. More...
 
typedef Mat< 8, 9 > Mat89
 8x9 Real matrix, packed by columns. More...
 
typedef Mat< 9, 1 > Mat91
 9x1 Real column matrix. More...
 
typedef Mat< 9, 2 > Mat92
 9x2 Real matrix, packed by columns. More...
 
typedef Mat< 9, 3 > Mat93
 9x3 Real matrix, packed by columns. More...
 
typedef Mat< 9, 4 > Mat94
 9x4 Real matrix, packed by columns. More...
 
typedef Mat< 9, 5 > Mat95
 9x5 Real matrix, packed by columns. More...
 
typedef Mat< 9, 6 > Mat96
 9x6 Real matrix, packed by columns. More...
 
typedef Mat< 9, 7 > Mat97
 9x7 Real matrix, packed by columns. More...
 
typedef Mat< 9, 8 > Mat98
 9x8 Real matrix, packed by columns. More...
 
typedef Mat< 9, 9 > Mat99
 9x9 Real matrix, packed by columns. More...
 
typedef SymMat< 1 > SymMat11
 1x1 Real symmetric matrix, that is, a scalar. More...
 
typedef SymMat< 5 > SymMat55
 5x5 compact Real symmetric matrix. More...
 
typedef SymMat< 6 > SymMat66
 6x6 compact Real symmetric matrix. More...
 
typedef SymMat< 7 > SymMat77
 7x7 compact Real symmetric matrix. More...
 
typedef SymMat< 8 > SymMat88
 8x8 compact Real symmetric matrix. More...
 
typedef SymMat< 9 > SymMat99
 9x9 compact Real symmetric matrix. More...
 
typedef Row< 1 > Row1
 A row vector of one Real element (not too useful). More...
 
typedef Row< 5 > Row5
 Packed, 5-element row of Real values. More...
 
typedef Row< 6 > Row6
 Packed, 6-element row of Real values. More...
 
typedef Row< 7 > Row7
 Packed, 7-element row of Real values. More...
 
typedef Row< 8 > Row8
 Packed, 8-element row of Real values. More...
 
typedef Row< 9 > Row9
 Packed, 9-element row of Real values. More...
 
typedef Vec< 1, float > fVec1
 A vector of one float element (not too useful). More...
 
typedef Vec< 2, float > fVec2
 Packed, 2-element vector of float values. More...
 
typedef Vec< 3, float > fVec3
 Packed, 3-element vector of float values. More...
 
typedef Vec< 4, float > fVec4
 Packed, 4-element vector of float values. More...
 
typedef Vec< 5, float > fVec5
 Packed, 5-element vector of float values. More...
 
typedef Vec< 6, float > fVec6
 Packed, 6-element vector of float values. More...
 
typedef Vec< 7, float > fVec7
 Packed, 7-element vector of float values. More...
 
typedef Vec< 8, float > fVec8
 Packed, 8-element vector of float values. More...
 
typedef Vec< 9, float > fVec9
 Packed, 9-element vector of float values. More...
 
typedef Mat< 1, 1, float > fMat11
 1x1 float matrix, that is, a scalar. More...
 
typedef Mat< 2, 2, float > fMat22
 2x2 float matrix, packed by columns. More...
 
typedef Mat< 3, 3, float > fMat33
 3x3 float matrix, packed by columns. More...
 
typedef Mat< 3, 4, float > fMat34
 3x4 float matrix, packed by columns. More...
 
typedef Mat< 4, 3, float > fMat43
 4x3 float matrix, packed by columns. More...
 
typedef Mat< 4, 4, float > fMat44
 4x4 float matrix, packed by columns. More...
 
typedef Mat< 5, 5, float > fMat55
 5x5 float matrix, packed by columns. More...
 
typedef Mat< 6, 6, float > fMat66
 6x6 float matrix, packed by columns. More...
 
typedef Mat< 7, 7, float > fMat77
 7x7 float matrix, packed by columns. More...
 
typedef Mat< 8, 8, float > fMat88
 8x8 float matrix, packed by columns. More...
 
typedef Mat< 9, 9, float > fMat99
 9x9 float matrix, packed by columns. More...
 
typedef SymMat< 1, float > fSymMat11
 A 1x1 float symmetric matrix, that is, a scalar. More...
 
typedef SymMat< 2, float > fSymMat22
 2x2 compact float symmetric matrix. More...
 
typedef SymMat< 3, float > fSymMat33
 3x3 compact float symmetric matrix. More...
 
typedef SymMat< 4, float > fSymMat44
 4x4 compact float symmetric matrix. More...
 
typedef SymMat< 5, float > fSymMat55
 5x5 compact float symmetric matrix. More...
 
typedef SymMat< 6, float > fSymMat66
 6x6 compact float symmetric matrix. More...
 
typedef SymMat< 7, float > fSymMat77
 7x7 compact float symmetric matrix. More...
 
typedef SymMat< 8, float > fSymMat88
 8x8 compact float symmetric matrix. More...
 
typedef SymMat< 9, float > fSymMat99
 9x9 compact float symmetric matrix. More...
 
typedef Row< 1, float > fRow1
 A row vector of one float element (not too useful). More...
 
typedef Row< 2, float > fRow2
 Packed, 2-element row vector of float values. More...
 
typedef Row< 3, float > fRow3
 Packed, 3-element row vector of float values. More...
 
typedef Row< 4, float > fRow4
 Packed, 4-element row vector of float values. More...
 
typedef Row< 5, float > fRow5
 Packed, 5-element row vector of float values. More...
 
typedef Row< 6, float > fRow6
 Packed, 6-element row vector of float values. More...
 
typedef Row< 7, float > fRow7
 Packed, 7-element row vector of float values. More...
 
typedef Row< 8, float > fRow8
 Packed, 8-element row vector of float values. More...
 
typedef Row< 9, float > fRow9
 Packed, 9-element row vector of float values. More...
 
typedef Spline_< RealSpline
 Provide a convenient name for a scalar-valued Spline_. More...
 
typedef Vector_< RealVector
 Variable-size column vector of Real elements; abbreviation for Vector_<Real>. More...
 
typedef Matrix_< RealMatrix
 Variable-size 2D matrix of Real elements; abbreviation for Matrix_<Real>. More...
 
typedef RowVector_< RealRowVector
 Variable-size row vector of Real elements; abbreviation for RowVector_<Real>. More...
 
typedef Vector_< ComplexComplexVector
 Variable-size column vector of Complex (std::complex<Real>) elements. More...
 
typedef Matrix_< ComplexComplexMatrix
 Variable-size 2D matrix of Complex (std::complex<Real>) elements. More...
 
typedef RowVector_< ComplexComplexRowVector
 Variable-size row vector of Complex (std::complex<Real>) elements. More...
 
typedef VectorView_< RealVectorView
 Non-owner column vector sharing Real elements. More...
 
typedef MatrixView_< RealMatrixView
 Non-owner matrix sharing Real elements. More...
 
typedef RowVectorView_< RealRowVectorView
 Non-owner row vector sharing Real elements. More...
 
typedef VectorView_< ComplexComplexVectorView
 Non-owner column vector sharing Complex (std::complex<Real>) elements. More...
 
typedef MatrixView_< ComplexComplexMatrixView
 Non-owner matrix sharing Complex (std::complex<Real>) elements. More...
 
typedef RowVectorView_< ComplexComplexRowVectorView
 Non-owner row vector sharing Complex (std::complex<Real>) elements. More...
 
typedef Vector_< float > fVector
 Abbreviation for Vector_<float>. More...
 
typedef Vector_< double > dVector
 Abbreviation for Vector_<double>. More...
 
typedef Vector_< fComplexfComplexVector
 Abbreviation for Vector_<std::complex<float>>. More...
 
typedef Vector_< dComplexdComplexVector
 Abbreviation for Vector_<std::complex<double>>. More...
 
typedef VectorView_< float > fVectorView
 Abbreviation for VectorView_<float>. More...
 
typedef VectorView_< double > dVectorView
 Abbreviation for VectorView_<double>. More...
 
typedef VectorView_< fComplexfComplexVectorView
 Abbreviation for VectorView_<std::complex<float>>. More...
 
typedef VectorView_< dComplexdComplexVectorView
 Abbreviation for VectorView_<std::complex<double>>. More...
 
typedef RowVector_< float > fRowVector
 Abbreviation for RowVector_<float>. More...
 
typedef RowVector_< double > dRowVector
 Abbreviation for RowVector_<double>. More...
 
typedef RowVector_< fComplexfComplexRowVector
 Abbreviation for RowVector_<std::complex<float>>. More...
 
typedef RowVector_< dComplexdComplexRowVector
 Abbreviation for RowVector_<std::complex<double>>. More...
 
typedef RowVectorView_< float > fRowVectorView
 Abbreviation for RowVectorView_<float>. More...
 
typedef RowVectorView_< double > dRowVectorView
 Abbreviation for RowVectorView_<double>. More...
 
typedef RowVectorView_< fComplexfComplexRowVectorView
 Abbreviation for RowVectorView_<std::complex<float>>. More...
 
typedef RowVectorView_< dComplexdComplexRowVectorView
 Abbreviation for RowVectorView_<std::complex<double>>. More...
 
typedef Matrix_< float > fMatrix
 Abbreviation for Matrix_<float>. More...
 
typedef Matrix_< double > dMatrix
 Abbreviation for Matrix_<double>. More...
 
typedef Matrix_< fComplexfComplexMatrix
 Abbreviation for Matrix_<std::complex<float>>. More...
 
typedef Matrix_< dComplexdComplexMatrix
 Abbreviation for Matrix_<std::complex<double>>. More...
 
typedef MatrixView_< float > fMatrixView
 Abbreviation for MatrixView_<float>. More...
 
typedef MatrixView_< double > dMatrixView
 Abbreviation for MatrixView_<double>. More...
 
typedef MatrixView_< fComplexfComplexMatrixView
 Abbreviation for MatrixView_<std::complex<float>>. More...
 
typedef MatrixView_< dComplexdComplexMatrixView
 Abbreviation for MatrixView_<std::complex<double>>. More...
 

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 {
  BestAvailable = 0,
  InteriorPoint = 1,
  LBFGS = 2,
  LBFGSB = 3,
  CFSQP = 4,
  CMAES = 5,
  UnknownOptimizerAlgorithm = 6,
  UserSuppliedOptimizerAlgorithm = 7
}
 The available Optimizer algorithms. More...
 

Functions

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