Simbody
3.6
|
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< Real > | Complex |
This is the default complex type for SimTK, with precision for the real and imaginary parts set to the compiled-in Real type. More... | |
typedef std::complex< float > | fComplex |
An abbreviation for std::complex<float> for consistency with others. More... | |
typedef std::complex< double > | dComplex |
An abbreviation for std::complex<double> for consistency with others. More... | |
typedef Is64BitHelper< Is64BitPlatform >::Result | Is64BitPlatformType |
typedef Function_< Real > | Function |
This typedef is used for the very common case that the return type of the Function object is Real. More... | |
typedef Vec< 2, Vec3 > | SpatialVec |
Spatial vectors are used for (rotation,translation) quantities and consist of a pair of Vec3 objects, arranged as a 2-vector of 3-vectors. More... | |
typedef Vec< 2, Vec< 3, float > > | fSpatialVec |
A SpatialVec that is always single (float) precision regardless of the compiled-in precision of Real. More... | |
typedef Vec< 2, Vec< 3, double > > | dSpatialVec |
A SpatialVec that is always double precision regardless of the compiled-in precision of Real. More... | |
typedef Row< 2, Row3 > | SpatialRow |
This is the type of a transposed SpatialVec; it does not usually appear explicitly in user programs. More... | |
typedef Row< 2, Row< 3, float > > | fSpatialRow |
A SpatialRow that is always single (float) precision regardless of the compiled-in precision of Real. More... | |
typedef Row< 2, Row< 3, double > > | dSpatialRow |
A SpatialRow that is always double precision regardless of the compiled-in precision of Real. More... | |
typedef Mat< 2, 2, Mat33 > | SpatialMat |
Spatial matrices are used to hold 6x6 matrices that are best viewed as 2x2 matrices of 3x3 matrices; most commonly for spatial and articulated body inertias and spatial shift matrices. More... | |
typedef Mat< 2, 2, Mat< 3, 3, float > > | fSpatialMat |
A SpatialMat that is always single (float) precision regardless of the compiled-in precision of Real. More... | |
typedef Mat< 2, 2, Mat< 3, 3, double > > | dSpatialMat |
A SpatialMat that is always double precision regardless of the compiled-in precision of Real. More... | |
typedef UnitInertia_< Real > | UnitInertia |
A unit inertia (gyration) tensor at default precision. More... | |
typedef UnitInertia_< float > | fUnitInertia |
A unit inertia (gyration) tensor at float precision. More... | |
typedef UnitInertia_< double > | dUnitInertia |
A unit inertia (gyration) tensor at double precision. More... | |
typedef Inertia_< Real > | Inertia |
An inertia tensor at default precision. More... | |
typedef Inertia_< float > | fInertia |
An inertia tensor at float precision. More... | |
typedef Inertia_< double > | dInertia |
An inertia tensor at double precision. More... | |
typedef MassProperties_< Real > | MassProperties |
Rigid body mass properties at default precision. More... | |
typedef MassProperties_< float > | fMassProperties |
Rigid body mass properties at float precision. More... | |
typedef MassProperties_< double > | dMassProperties |
Rigid body mass properties at double precision. More... | |
typedef SpatialInertia_< Real > | SpatialInertia |
A spatial (rigid body) inertia matrix at default precision. More... | |
typedef SpatialInertia_< float > | fSpatialInertia |
A spatial (rigid body) inertia matrix at float precision. More... | |
typedef SpatialInertia_< double > | dSpatialInertia |
A spatial (rigid body) inertia matrix at double precision. More... | |
typedef ArticulatedInertia_< Real > | ArticulatedInertia |
An articulated body inertia matrix at default precision. More... | |
typedef ArticulatedInertia_< float > | fArticulatedInertia |
An articulated body inertia matrix at float precision. More... | |
typedef ArticulatedInertia_< double > | dArticulatedInertia |
An articulated body inertia matrix at double precision. More... | |
typedef UnitInertia | Gyration |
For backwards compatibility only; use UnitInertia instead. More... | |
typedef Quaternion_< Real > | Quaternion |
typedef Quaternion_< float > | fQuaternion |
typedef Quaternion_< double > | dQuaternion |
typedef Rotation_< Real > | Rotation |
typedef Rotation_< float > | fRotation |
typedef Rotation_< double > | dRotation |
typedef InverseRotation_< Real > | InverseRotation |
typedef InverseRotation_< float > | fInverseRotation |
typedef InverseRotation_< double > | dInverseRotation |
typedef Transform_< Real > | Transform |
typedef Transform_< float > | fTransform |
typedef Transform_< double > | dTransform |
typedef UnitVec< Real, 1 > | UnitVec3 |
typedef UnitVec< float, 1 > | fUnitVec3 |
typedef UnitVec< double, 1 > | dUnitVec3 |
typedef conjugate< Real > | Conjugate |
typedef Measure_< Real > | Measure |
This typedef is a convenient abbreviation for the most common kind of Measure – one that returns a single Real result; the underlying class is Measure_; look there for documentation. More... | |
typedef long long | StageVersion |
This is the type to use for Stage version numbers that get incremented whenever a state variable change invalidates a Stage. More... | |
typedef long long | ValueVersion |
This is the type to use for state variable version numbers that get incremented whenever a state value changes. More... | |
using | CacheEntryKey = std::pair< SubsystemIndex, CacheEntryIndex > |
using | DiscreteVarKey = std::pair< SubsystemIndex, DiscreteVariableIndex > |
typedef Vec< 2 > | Vec2 |
This is the most common 2D vector type: a column of 2 Real values stored consecutively in memory (packed). More... | |
typedef Vec< 3 > | Vec3 |
This is the most common 3D vector type: a column of 3 Real values stored consecutively in memory (packed). More... | |
typedef Vec< 4 > | Vec4 |
This is the most common 4D vector type: a column of 4 Real values stored consecutively in memory (packed). More... | |
typedef Mat< 2, 2 > | Mat22 |
This is the most common 2x2 matrix type: two packed columns of 2 Real values each. More... | |
typedef Mat< 3, 3 > | Mat33 |
This is the most common 3x3 matrix type: three packed columns of 3 Real values each. More... | |
typedef Mat< 4, 4 > | Mat44 |
This is the most common 4x4 matrix type: four packed columns of 4 Real values each. More... | |
typedef SymMat< 2 > | SymMat22 |
A compact, 2x2 Real symmetric matrix; only 3 elements are stored. More... | |
typedef SymMat< 3 > | SymMat33 |
A compact, 3x3 Real symmetric matrix; only 6 elements are stored. More... | |
typedef SymMat< 4 > | SymMat44 |
A compact, 2x2 Real symmetric matrix; only 10 elements are stored. More... | |
typedef Row< 2 > | Row2 |
Packed, 2-element row of Real values. More... | |
typedef Row< 3 > | Row3 |
Packed, 3-element row of Real values. More... | |
typedef Row< 4 > | Row4 |
Packed, 4-element row of Real values. More... | |
typedef Vec< 1 > | Vec1 |
A vector of just one Real element (not too useful). More... | |
typedef Vec< 5 > | Vec5 |
Packed, 5-element vector of Real values. More... | |
typedef Vec< 6 > | Vec6 |
Packed, 6-element vector of Real values. More... | |
typedef Vec< 7 > | Vec7 |
Packed, 7-element vector of Real values. More... | |
typedef Vec< 8 > | Vec8 |
Packed, 8-element vector of Real values. More... | |
typedef Vec< 9 > | Vec9 |
Packed, 9-element vector of Real values. More... | |
typedef Mat< 1, 1 > | Mat11 |
1x1 Real matrix, that is, a scalar. More... | |
typedef Mat< 1, 2 > | Mat12 |
1x2 Real row matrix. More... | |
typedef Mat< 1, 3 > | Mat13 |
1x3 Real row matrix. More... | |
typedef Mat< 1, 4 > | Mat14 |
1x4 Real row matrix. More... | |
typedef Mat< 1, 5 > | Mat15 |
1x5 Real row matrix. More... | |
typedef Mat< 1, 6 > | Mat16 |
1x6 Real row matrix. More... | |
typedef Mat< 1, 7 > | Mat17 |
1x7 Real row matrix. More... | |
typedef Mat< 1, 8 > | Mat18 |
1x8 Real row matrix. More... | |
typedef Mat< 1, 9 > | Mat19 |
1x9 Real row matrix. More... | |
typedef Mat< 2, 1 > | Mat21 |
2x1 Real column matrix. More... | |
typedef Mat< 2, 3 > | Mat23 |
2x3 Real matrix, packed by columns. More... | |
typedef Mat< 2, 4 > | Mat24 |
2x4 Real matrix, packed by columns. More... | |
typedef Mat< 2, 5 > | Mat25 |
2x5 Real matrix, packed by columns. More... | |
typedef Mat< 2, 6 > | Mat26 |
2x6 Real matrix, packed by columns. More... | |
typedef Mat< 2, 7 > | Mat27 |
2x7 Real matrix, packed by columns. More... | |
typedef Mat< 2, 8 > | Mat28 |
2x8 Real matrix, packed by columns. More... | |
typedef Mat< 2, 9 > | Mat29 |
2x9 Real matrix, packed by columns. More... | |
typedef Mat< 3, 1 > | Mat31 |
3x1 Real column matrix. More... | |
typedef Mat< 3, 2 > | Mat32 |
3x2 Real matrix, packed by columns. More... | |
typedef Mat< 3, 4 > | Mat34 |
3x4 Real matrix, packed by columns. More... | |
typedef Mat< 3, 5 > | Mat35 |
3x5 Real matrix, packed by columns. More... | |
typedef Mat< 3, 6 > | Mat36 |
3x6 Real matrix, packed by columns. More... | |
typedef Mat< 3, 7 > | Mat37 |
3x7 Real matrix, packed by columns. More... | |
typedef Mat< 3, 8 > | Mat38 |
3x8 Real matrix, packed by columns. More... | |
typedef Mat< 3, 9 > | Mat39 |
3x9 Real matrix, packed by columns. More... | |
typedef Mat< 4, 1 > | Mat41 |
4x1 Real column matrix. More... | |
typedef Mat< 4, 2 > | Mat42 |
4x2 Real matrix, packed by columns. More... | |
typedef Mat< 4, 3 > | Mat43 |
4x3 Real matrix, packed by columns. More... | |
typedef Mat< 4, 5 > | Mat45 |
4x5 Real matrix, packed by columns. More... | |
typedef Mat< 4, 6 > | Mat46 |
4x6 Real matrix, packed by columns. More... | |
typedef Mat< 4, 7 > | Mat47 |
4x7 Real matrix, packed by columns. More... | |
typedef Mat< 4, 8 > | Mat48 |
4x8 Real matrix, packed by columns. More... | |
typedef Mat< 4, 9 > | Mat49 |
4x9 Real matrix, packed by columns. More... | |
typedef Mat< 5, 1 > | Mat51 |
5x1 Real column matrix. More... | |
typedef Mat< 5, 2 > | Mat52 |
5x2 Real matrix, packed by columns. More... | |
typedef Mat< 5, 3 > | Mat53 |
5x3 Real matrix, packed by columns. More... | |
typedef Mat< 5, 4 > | Mat54 |
5x4 Real matrix, packed by columns. More... | |
typedef Mat< 5, 5 > | Mat55 |
5x5 Real matrix, packed by columns. More... | |
typedef Mat< 5, 6 > | Mat56 |
5x6 Real matrix, packed by columns. More... | |
typedef Mat< 5, 7 > | Mat57 |
5x7 Real matrix, packed by columns. More... | |
typedef Mat< 5, 8 > | Mat58 |
5x8 Real matrix, packed by columns. More... | |
typedef Mat< 5, 9 > | Mat59 |
5x9 Real matrix, packed by columns. More... | |
typedef Mat< 6, 1 > | Mat61 |
6x1 Real column matrix. More... | |
typedef Mat< 6, 2 > | Mat62 |
6x2 Real matrix, packed by columns. More... | |
typedef Mat< 6, 3 > | Mat63 |
6x3 Real matrix, packed by columns. More... | |
typedef Mat< 6, 4 > | Mat64 |
6x4 Real matrix, packed by columns. More... | |
typedef Mat< 6, 5 > | Mat65 |
6x5 Real matrix, packed by columns. More... | |
typedef Mat< 6, 6 > | Mat66 |
6x6 Real matrix, packed by columns. More... | |
typedef Mat< 6, 7 > | Mat67 |
6x7 Real matrix, packed by columns. More... | |
typedef Mat< 6, 8 > | Mat68 |
6x8 Real matrix, packed by columns. More... | |
typedef Mat< 6, 9 > | Mat69 |
6x9 Real matrix, packed by columns. More... | |
typedef Mat< 7, 1 > | Mat71 |
7x1 Real column matrix. More... | |
typedef Mat< 7, 2 > | Mat72 |
7x2 Real matrix, packed by columns. More... | |
typedef Mat< 7, 3 > | Mat73 |
7x3 Real matrix, packed by columns. More... | |
typedef Mat< 7, 4 > | Mat74 |
7x4 Real matrix, packed by columns. More... | |
typedef Mat< 7, 5 > | Mat75 |
7x5 Real matrix, packed by columns. More... | |
typedef Mat< 7, 6 > | Mat76 |
7x6 Real matrix, packed by columns. More... | |
typedef Mat< 7, 7 > | Mat77 |
7x7 Real matrix, packed by columns. More... | |
typedef Mat< 7, 8 > | Mat78 |
7x8 Real matrix, packed by columns. More... | |
typedef Mat< 7, 9 > | Mat79 |
7x9 Real matrix, packed by columns. More... | |
typedef Mat< 8, 1 > | Mat81 |
8x1 Real column matrix. More... | |
typedef Mat< 8, 2 > | Mat82 |
8x2 Real matrix, packed by columns. More... | |
typedef Mat< 8, 3 > | Mat83 |
8x3 Real matrix, packed by columns. More... | |
typedef Mat< 8, 4 > | Mat84 |
8x4 Real matrix, packed by columns. More... | |
typedef Mat< 8, 5 > | Mat85 |
8x5 Real matrix, packed by columns. More... | |
typedef Mat< 8, 6 > | Mat86 |
8x6 Real matrix, packed by columns. More... | |
typedef Mat< 8, 7 > | Mat87 |
8x7 Real matrix, packed by columns. More... | |
typedef Mat< 8, 8 > | Mat88 |
8x8 Real matrix, packed by columns. More... | |
typedef Mat< 8, 9 > | Mat89 |
8x9 Real matrix, packed by columns. More... | |
typedef Mat< 9, 1 > | Mat91 |
9x1 Real column matrix. More... | |
typedef Mat< 9, 2 > | Mat92 |
9x2 Real matrix, packed by columns. More... | |
typedef Mat< 9, 3 > | Mat93 |
9x3 Real matrix, packed by columns. More... | |
typedef Mat< 9, 4 > | Mat94 |
9x4 Real matrix, packed by columns. More... | |
typedef Mat< 9, 5 > | Mat95 |
9x5 Real matrix, packed by columns. More... | |
typedef Mat< 9, 6 > | Mat96 |
9x6 Real matrix, packed by columns. More... | |
typedef Mat< 9, 7 > | Mat97 |
9x7 Real matrix, packed by columns. More... | |
typedef Mat< 9, 8 > | Mat98 |
9x8 Real matrix, packed by columns. More... | |
typedef Mat< 9, 9 > | Mat99 |
9x9 Real matrix, packed by columns. More... | |
typedef SymMat< 1 > | SymMat11 |
1x1 Real symmetric matrix, that is, a scalar. More... | |
typedef SymMat< 5 > | SymMat55 |
5x5 compact Real symmetric matrix. More... | |
typedef SymMat< 6 > | SymMat66 |
6x6 compact Real symmetric matrix. More... | |
typedef SymMat< 7 > | SymMat77 |
7x7 compact Real symmetric matrix. More... | |
typedef SymMat< 8 > | SymMat88 |
8x8 compact Real symmetric matrix. More... | |
typedef SymMat< 9 > | SymMat99 |
9x9 compact Real symmetric matrix. More... | |
typedef Row< 1 > | Row1 |
A row vector of one Real element (not too useful). More... | |
typedef Row< 5 > | Row5 |
Packed, 5-element row of Real values. More... | |
typedef Row< 6 > | Row6 |
Packed, 6-element row of Real values. More... | |
typedef Row< 7 > | Row7 |
Packed, 7-element row of Real values. More... | |
typedef Row< 8 > | Row8 |
Packed, 8-element row of Real values. More... | |
typedef Row< 9 > | Row9 |
Packed, 9-element row of Real values. More... | |
typedef Vec< 1, float > | fVec1 |
A vector of one float element (not too useful). More... | |
typedef Vec< 2, float > | fVec2 |
Packed, 2-element vector of float values. More... | |
typedef Vec< 3, float > | fVec3 |
Packed, 3-element vector of float values. More... | |
typedef Vec< 4, float > | fVec4 |
Packed, 4-element vector of float values. More... | |
typedef Vec< 5, float > | fVec5 |
Packed, 5-element vector of float values. More... | |
typedef Vec< 6, float > | fVec6 |
Packed, 6-element vector of float values. More... | |
typedef Vec< 7, float > | fVec7 |
Packed, 7-element vector of float values. More... | |
typedef Vec< 8, float > | fVec8 |
Packed, 8-element vector of float values. More... | |
typedef Vec< 9, float > | fVec9 |
Packed, 9-element vector of float values. More... | |
typedef Mat< 1, 1, float > | fMat11 |
1x1 float matrix, that is, a scalar. More... | |
typedef Mat< 2, 2, float > | fMat22 |
2x2 float matrix, packed by columns. More... | |
typedef Mat< 3, 3, float > | fMat33 |
3x3 float matrix, packed by columns. More... | |
typedef Mat< 3, 4, float > | fMat34 |
3x4 float matrix, packed by columns. More... | |
typedef Mat< 4, 3, float > | fMat43 |
4x3 float matrix, packed by columns. More... | |
typedef Mat< 4, 4, float > | fMat44 |
4x4 float matrix, packed by columns. More... | |
typedef Mat< 5, 5, float > | fMat55 |
5x5 float matrix, packed by columns. More... | |
typedef Mat< 6, 6, float > | fMat66 |
6x6 float matrix, packed by columns. More... | |
typedef Mat< 7, 7, float > | fMat77 |
7x7 float matrix, packed by columns. More... | |
typedef Mat< 8, 8, float > | fMat88 |
8x8 float matrix, packed by columns. More... | |
typedef Mat< 9, 9, float > | fMat99 |
9x9 float matrix, packed by columns. More... | |
typedef SymMat< 1, float > | fSymMat11 |
A 1x1 float symmetric matrix, that is, a scalar. More... | |
typedef SymMat< 2, float > | fSymMat22 |
2x2 compact float symmetric matrix. More... | |
typedef SymMat< 3, float > | fSymMat33 |
3x3 compact float symmetric matrix. More... | |
typedef SymMat< 4, float > | fSymMat44 |
4x4 compact float symmetric matrix. More... | |
typedef SymMat< 5, float > | fSymMat55 |
5x5 compact float symmetric matrix. More... | |
typedef SymMat< 6, float > | fSymMat66 |
6x6 compact float symmetric matrix. More... | |
typedef SymMat< 7, float > | fSymMat77 |
7x7 compact float symmetric matrix. More... | |
typedef SymMat< 8, float > | fSymMat88 |
8x8 compact float symmetric matrix. More... | |
typedef SymMat< 9, float > | fSymMat99 |
9x9 compact float symmetric matrix. More... | |
typedef Row< 1, float > | fRow1 |
A row vector of one float element (not too useful). More... | |
typedef Row< 2, float > | fRow2 |
Packed, 2-element row vector of float values. More... | |
typedef Row< 3, float > | fRow3 |
Packed, 3-element row vector of float values. More... | |
typedef Row< 4, float > | fRow4 |
Packed, 4-element row vector of float values. More... | |
typedef Row< 5, float > | fRow5 |
Packed, 5-element row vector of float values. More... | |
typedef Row< 6, float > | fRow6 |
Packed, 6-element row vector of float values. More... | |
typedef Row< 7, float > | fRow7 |
Packed, 7-element row vector of float values. More... | |
typedef Row< 8, float > | fRow8 |
Packed, 8-element row vector of float values. More... | |
typedef Row< 9, float > | fRow9 |
Packed, 9-element row vector of float values. More... | |
typedef Spline_< Real > | Spline |
Provide a convenient name for a scalar-valued Spline_. More... | |
typedef Vector_< Real > | Vector |
Variable-size column vector of Real elements; abbreviation for Vector_<Real>. More... | |
typedef Matrix_< Real > | Matrix |
Variable-size 2D matrix of Real elements; abbreviation for Matrix_<Real>. More... | |
typedef RowVector_< Real > | RowVector |
Variable-size row vector of Real elements; abbreviation for RowVector_<Real>. More... | |
typedef Vector_< Complex > | ComplexVector |
Variable-size column vector of Complex (std::complex<Real>) elements. More... | |
typedef Matrix_< Complex > | ComplexMatrix |
Variable-size 2D matrix of Complex (std::complex<Real>) elements. More... | |
typedef RowVector_< Complex > | ComplexRowVector |
Variable-size row vector of Complex (std::complex<Real>) elements. More... | |
typedef VectorView_< Real > | VectorView |
Non-owner column vector sharing Real elements. More... | |
typedef MatrixView_< Real > | MatrixView |
Non-owner matrix sharing Real elements. More... | |
typedef RowVectorView_< Real > | RowVectorView |
Non-owner row vector sharing Real elements. More... | |
typedef VectorView_< Complex > | ComplexVectorView |
Non-owner column vector sharing Complex (std::complex<Real>) elements. More... | |
typedef MatrixView_< Complex > | ComplexMatrixView |
Non-owner matrix sharing Complex (std::complex<Real>) elements. More... | |
typedef RowVectorView_< Complex > | ComplexRowVectorView |
Non-owner row vector sharing Complex (std::complex<Real>) elements. More... | |
typedef Vector_< float > | fVector |
Abbreviation for Vector_<float>. More... | |
typedef Vector_< double > | dVector |
Abbreviation for Vector_<double>. More... | |
typedef Vector_< fComplex > | fComplexVector |
Abbreviation for Vector_<std::complex<float>>. More... | |
typedef Vector_< dComplex > | dComplexVector |
Abbreviation for Vector_<std::complex<double>>. More... | |
typedef VectorView_< float > | fVectorView |
Abbreviation for VectorView_<float>. More... | |
typedef VectorView_< double > | dVectorView |
Abbreviation for VectorView_<double>. More... | |
typedef VectorView_< fComplex > | fComplexVectorView |
Abbreviation for VectorView_<std::complex<float>>. More... | |
typedef VectorView_< dComplex > | dComplexVectorView |
Abbreviation for VectorView_<std::complex<double>>. More... | |
typedef RowVector_< float > | fRowVector |
Abbreviation for RowVector_<float>. More... | |
typedef RowVector_< double > | dRowVector |
Abbreviation for RowVector_<double>. More... | |
typedef RowVector_< fComplex > | fComplexRowVector |
Abbreviation for RowVector_<std::complex<float>>. More... | |
typedef RowVector_< dComplex > | dComplexRowVector |
Abbreviation for RowVector_<std::complex<double>>. More... | |
typedef RowVectorView_< float > | fRowVectorView |
Abbreviation for RowVectorView_<float>. More... | |
typedef RowVectorView_< double > | dRowVectorView |
Abbreviation for RowVectorView_<double>. More... | |
typedef RowVectorView_< fComplex > | fComplexRowVectorView |
Abbreviation for RowVectorView_<std::complex<float>>. More... | |
typedef RowVectorView_< dComplex > | dComplexRowVectorView |
Abbreviation for RowVectorView_<std::complex<double>>. More... | |
typedef Matrix_< float > | fMatrix |
Abbreviation for Matrix_<float>. More... | |
typedef Matrix_< double > | dMatrix |
Abbreviation for Matrix_<double>. More... | |
typedef Matrix_< fComplex > | fComplexMatrix |
Abbreviation for Matrix_<std::complex<float>>. More... | |
typedef Matrix_< dComplex > | dComplexMatrix |
Abbreviation for Matrix_<std::complex<double>>. More... | |
typedef MatrixView_< float > | fMatrixView |
Abbreviation for MatrixView_<float>. More... | |
typedef MatrixView_< double > | dMatrixView |
Abbreviation for MatrixView_<double>. More... | |
typedef MatrixView_< fComplex > | fComplexMatrixView |
Abbreviation for MatrixView_<std::complex<float>>. More... | |
typedef MatrixView_< dComplex > | dComplexMatrixView |
Abbreviation for MatrixView_<std::complex<double>>. More... | |
Enumerations | |
enum | 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_< E > | operator* (const VectorBase< E > &v, const Transform_< P > &X) |
template<class P , class E > | |
RowVector_< E > | operator* (const Transform_< P > &X, const RowVectorBase< E > &v) |
template<class P , class E > | |
RowVector_< E > | operator* (const RowVectorBase< E > &v, const Transform_< P > &X) |
template<class P , class E > | |
Matrix_< E > | operator* (const Transform_< P > &X, const MatrixBase< E > &v) |
template<class P , class E > | |
Matrix_< E > | operator* (const MatrixBase< E > &v, const Transform_< P > &X) |
template<class P , int N, class E , int S> | |
Vec< N, E > | operator* (const Transform_< P > &X, const Vec< N, E, S > &v) |
template<class P , int N, class E , int S> | |
Vec< N, E > | operator* (const Vec< N, E, S > &v, const Transform_< P > &X) |
template<class P , int N, class E , int S> | |
Row< N, E > | operator* (const Transform_< P > &X, const Row< N, E, S > &v) |
template<class P , int N, class E , int S> | |
Row< N, E > | operator* (const Row< N, E, S > &v, const Transform_< P > &X) |
template<class P , int M, int N, class E , int CS, int RS> | |
Mat< M, N, E > | operator* (const Transform_< P > &X, const Mat< M, N, E, CS, RS > &v) |
template<class P , int M, int N, class E , int CS, int RS> | |
Mat< M, N, E > | operator* (const Mat< M, N, E, CS, RS > &v, const Transform_< P > &X) |
template<class P > | |
Transform_< P > | operator* (const Transform_< P > &X1, const InverseTransform_< P > &X2) |
template<class P > | |
Transform_< P > | operator* (const InverseTransform_< P > &X1, const Transform_< P > &X2) |
template<class P > | |
Transform_< P > | operator* (const InverseTransform_< P > &X1, const InverseTransform_< P > &X2) |
template<class P > | |
bool | operator== (const InverseTransform_< P > &X1, const InverseTransform_< P > &X2) |
template<class P > | |
bool | operator== (const Transform_< P > &X1, const InverseTransform_< P > &X2) |
template<class P > | |
bool | operator== (const InverseTransform_< P > &X1, const Transform_< P > &X2) |
static Real | convertRadiansToDegrees (const Real rad) |
static Real | convertDegreesToRadians (const Real deg) |
complex< float > | operator* (const complex< float > &c, int r) |
complex< float > | operator* (int r, const complex< float > &c) |
complex< double > | operator* (const complex< float > &c, const double &r) |
complex< double > | operator* (const double &r, const complex< float > &c) |
complex< float > | operator/ (const complex< float > &c, int r) |
complex< float > | operator/ (int r, const complex< float > &c) |
complex< double > | operator/ (const complex< float > &c, const double &r) |
complex< double > | operator/ (const double &r, const complex< float > &c) |
complex< float > | operator+ (const complex< float > &c, int r) |
complex< float > | operator+ (int r, const complex< float > &c) |
complex< double > | operator+ (const complex< float > &c, const double &r) |
complex< double > | operator+ (const double &r, const complex< float > &c) |
complex< float > | operator- (const complex< float > &c, int r) |
complex< float > | operator- (int r, const complex< float > &c) |
complex< double > | operator- (const complex< float > &c, const double &r) |
complex< double > | operator- (const double &r, const complex< float > &c) |
complex< double > | operator* (const complex< double > &c, int r) |
complex< double > | operator* (int r, const complex< double > &c) |
complex< double > | operator* (const complex< double > &c, const float &r) |
complex< double > | operator* (const float &r, const complex< double > &c) |
complex< double > | operator/ (const complex< double > &c, int r) |
complex< double > | operator/ (int r, const complex< double > &c) |
complex< double > | operator/ (const complex< double > &c, const float &r) |
complex< double > | operator/ (const float &r, const complex< double > &c) |
complex< double > | operator+ (const complex< double > &c, int r) |
complex< double > | operator+ (int r, const complex< double > &c) |
complex< double > | operator+ (const complex< double > &c, const float &r) |
complex< double > | operator+ (const float &r, const complex< double > &c) |
complex< double > | operator- (const complex< double > &c, int r) |
complex< double > | operator- (int r, const complex< double > &c) |
complex< double > | operator- (const complex< double > &c, const float &r) |
complex< double > | operator- (const float &r, const complex< double > &c) |
const float & | real (const conjugate< float > &c) |
const negator< float > & | imag (const conjugate< float > &c) |
const complex< float > & | conj (const conjugate< float > &c) |
float | abs (const conjugate< float > &c) |
float | norm (const conjugate< float > &c) |
const double & | real (const conjugate< double > &c) |
const negator< double > & | imag (const conjugate< double > &c) |
const complex< double > & | conj (const conjugate< double > &c) |
double | abs (const conjugate< double > &c) |
double | norm (const conjugate< double > &c) |
template<class R , class CHAR , class TRAITS > | |
std::basic_istream< CHAR, TRAITS > & | operator>> (std::basic_istream< CHAR, TRAITS > &is, conjugate< R > &c) |
template<class R , class CHAR , class TRAITS > | |
std::basic_ostream< CHAR, TRAITS > & | operator<< (std::basic_ostream< CHAR, TRAITS > &os, const conjugate< R > &c) |
template<class R > | |
conjugate< R > | operator+ (const conjugate< R > &a, const float &b) |
template<class R > | |
Wider< R, double >::WConj | operator+ (const conjugate< R > &a, const double &b) |
template<class R > | |
conjugate< R > | operator+ (const float &a, const conjugate< R > &b) |
template<class R > | |
Wider< R, double >::WConj | operator+ (const double &a, const conjugate< R > &b) |
template<class R > | |
conjugate< R > | operator* (const conjugate< R > &a, const float &b) |
template<class R > | |
Wider< R, double >::WConj | operator* (const conjugate< R > &a, const double &b) |
template<class R > | |
conjugate< R > | operator* (const float &a, const conjugate< R > &b) |
template<class R > | |
Wider< R, double >::WConj | operator* (const double &a, const conjugate< R > &b) |
template<class R > | |
bool | operator== (const conjugate< R > &a, const float &b) |
template<class R > | |
bool | operator== (const conjugate< R > &a, const double &b) |
template<class R > | |
bool | operator== (const float &a, const conjugate< R > &b) |
template<class R > | |
bool | operator== (const double &a, const conjugate< R > &b) |
template<class R > | |
bool | operator!= (const conjugate< R > &a, const float &b) |
template<class R > | |
bool | operator!= (const conjugate< R > &a, const double &b) |
template<class R > | |
bool | operator!= (const float &a, const conjugate< R > &b) |
template<class R > | |
bool | operator!= (const double &a, const conjugate< R > &b) |
template<class R > | |
conjugate< R > | operator- (const conjugate< R > &a, const float &b) |
template<class R > | |
Wider< R, double >::WConj | operator- (const conjugate< R > &a, const double &b) |
template<class R > | |
complex< R > | operator- (const float &a, const conjugate< R > &b) |
template<class R > | |
Wider< R, double >::WCplx | operator- (const double &a, const conjugate< R > &b) |
template<class R > | |
conjugate< R > | operator/ (const conjugate< R > &a, const float &b) |
template<class R > | |
Wider< R, double >::WConj | operator/ (const conjugate< R > &a, const double &b) |
template<class R > | |
complex< R > | operator/ (const float &a, const conjugate< R > &b) |
template<class R > | |
Wider< R, double >::WCplx | operator/ (const double &a, const conjugate< R > &b) |
template<class R , class S > | |
Wider< R, S >::WConj | operator+ (const conjugate< R > &a, const conjugate< S > &r) |
template<class R , class S > | |
Wider< R, S >::WCplx | operator+ (const conjugate< R > &a, const complex< S > &r) |
template<class R , class S > | |
Wider< R, S >::WCplx | operator+ (const complex< R > &a, const conjugate< S > &r) |
template<class R , class S > | |
Wider< R, S >::WCplx | operator- (const conjugate< R > &a, const conjugate< S > &r) |
template<class R , class S > | |
negator< typename Wider< R, S >::WCplx > | operator- (const conjugate< R > &a, const complex< S > &r) |
template<class R , class S > | |
Wider< R, S >::WCplx | operator- (const complex< R > &a, const conjugate< S > &r) |
template<class R , class S > | |
negator< typename Wider< R, S >::WCplx > | operator* (const conjugate< R > &a, const conjugate< S > &r) |
template<class R , class S > | |
Wider< R, S >::WCplx | operator* (const conjugate< R > &a, const complex< S > &r) |
template<class R , class S > | |
Wider< R, S >::WCplx | operator* (const complex< R > &a, const conjugate< S > &r) |
template<class R , class S > | |
Wider< R, S >::WCplx | operator* (const negator< complex< R > > &a, const conjugate< S > &r) |
template<class R , class S > | |
Wider< R, S >::WCplx | operator* (const conjugate< R > &a, const negator< complex< S > > &r) |
template<class R , class S > | |
Wider< R, S >::WCplx | operator/ (const conjugate< R > &a, const conjugate< S > &r) |
template<class R , class S > | |
Wider< R, S >::WCplx | operator/ (const conjugate< R > &a, const complex< S > &r) |
template<class R , class S > | |
Wider< R, S >::WCplx | operator/ (const complex< R > &a, const conjugate< S > &r) |
template<class R , class S > | |
bool | operator== (const conjugate< R > &a, const conjugate< S > &r) |
template<class R , class S > | |
bool | operator== (const conjugate< R > &a, const complex< S > &r) |
template<class R , class S > | |
bool | operator== (const complex< R > &a, const conjugate< S > &r) |
template<class R , class S > | |
bool | operator!= (const conjugate< R > &a, const conjugate< S > &r) |
template<class R , class S > | |
bool | operator!= (const conjugate< R > &a, const complex< S > &r) |
template<class R , class S > | |
bool | operator!= (const complex< R > &a, const conjugate< S > &r) |
bool | isNaN (const negator< float > &x) |
bool | isNaN (const negator< double > &x) |
template<class P > | |
bool | isNaN (const negator< std::complex< P > > &x) |
template<class P > | |
bool | isNaN (const negator< conjugate< P > > &x) |
bool | isFinite (const negator< float > &x) |
bool | isFinite (const negator< double > &x) |
template<class P > | |
bool | isFinite (const negator< std::complex< P > > &x) |
template<class P > | |
bool | isFinite (const negator< conjugate< P > > &x) |
bool | isInf (const negator< float > &x) |
bool | isInf (const negator< double > &x) |
template<class P > | |
bool | isInf (const negator< std::complex< P > > &x) |
template<class P > | |
bool | isInf (const negator< conjugate< P > > &x) |
template<class DEST , class SRC > | |
static const DEST & | negRecast (const SRC &s) |
template<class A , class B > | |
negator< A >::template Result< B >::Add | operator+ (const negator< A > &l, const B &r) |
template<class A , class B > | |
CNT< A >::template Result< negator< B > >::Add | operator+ (const A &l, const negator< B > &r) |
template<class A , class B > | |
negator< A >::template Result< negator< B > >::Add | operator+ (const negator< A > &l, const negator< B > &r) |
template<class A , class B > | |
negator< A >::template Result< B >::Sub | operator- (const negator< A > &l, const B &r) |
template<class A , class B > | |
CNT< A >::template Result< negator< B > >::Sub | operator- (const A &l, const negator< B > &r) |
template<class A , class B > | |
negator< A >::template Result< negator< B > >::Sub | operator- (const negator< A > &l, const negator< B > &r) |
template<class A , class B > | |
negator< A >::template Result< B >::Mul | operator* (const negator< A > &l, const B &r) |
template<class A , class B > | |
CNT< A >::template Result< negator< B > >::Mul | operator* (const A &l, const negator< B > &r) |
template<class A , class B > | |
negator< A >::template Result< negator< B > >::Mul | operator* (const negator< A > &l, const negator< B > &r) |
template<class A , class B > | |
negator< A >::template Result< B >::Dvd | operator/ (const negator< A > &l, const B &r) |
template<class A , class B > | |
CNT< A >::template Result< negator< B > >::Dvd | operator/ (const A &l, const negator< B > &r) |
template<class A , class B > | |
negator< A >::template Result< negator< B > >::Dvd | operator/ (const negator< A > &l, const negator< B > &r) |
template<class A , class B > | |
bool | operator== (const negator< A > &l, const B &r) |
template<class A , class B > | |
bool | operator== (const A &l, const negator< B > &r) |
template<class A , class B > | |
bool | operator== (const negator< A > &l, const negator< B > &r) |
template<class A , class B > | |
bool | operator!= (const negator< A > &l, const B &r) |
template<class A , class B > | |
bool | operator!= (const A &l, const negator< B > &r) |
template<class A , class B > | |
bool | operator!= (const negator< A > &l, const negator< B > &r) |
template<class NUM , class CHAR , class TRAITS > | |
std::basic_istream< CHAR, TRAITS > & | operator>> (std::basic_istream< CHAR, TRAITS > &is, negator< NUM > &nn) |
template<class NUM , class CHAR , class TRAITS > | |
std::basic_ostream< CHAR, TRAITS > & | operator<< (std::basic_ostream< CHAR, TRAITS > &os, const negator< NUM > &nn) |
bool | isNaN (const float &x) |
bool | isNaN (const double &x) |
template<class P > | |
bool | isNaN (const std::complex< P > &x) |
template<class P > | |
bool | isNaN (const conjugate< P > &x) |
bool | isFinite (const float &x) |
bool | isFinite (const double &x) |
template<class P > | |
bool | isFinite (const std::complex< P > &x) |
template<class P > | |
bool | isFinite (const conjugate< P > &x) |
bool | isInf (const float &x) |
bool | isInf (const double &x) |
template<class P > | |
bool | isInf (const std::complex< P > &x) |
template<class P > | |
bool | isInf (const conjugate< P > &x) |
bool | isNumericallyEqual (const float &a, const float &b, double tol=RTraits< float >::getDefaultTolerance()) |
Compare two floats for approximate equality. More... | |
bool | isNumericallyEqual (const double &a, const double &b, double tol=RTraits< double >::getDefaultTolerance()) |
Compare two doubles for approximate equality. More... | |
bool | isNumericallyEqual (const float &a, const double &b, double tol=RTraits< float >::getDefaultTolerance()) |
Compare a float and a double for approximate equality at float precision. More... | |
bool | isNumericallyEqual (const double &a, const float &b, double tol=RTraits< float >::getDefaultTolerance()) |
Compare a float and a double for approximate equality at float precision. More... | |
bool | isNumericallyEqual (const float &a, int b, double tol=RTraits< float >::getDefaultTolerance()) |
Test a float for approximate equality to an integer. More... | |
bool | isNumericallyEqual (int a, const float &b, double tol=RTraits< float >::getDefaultTolerance()) |
Test a float for approximate equality to an integer. More... | |
bool | isNumericallyEqual (const double &a, int b, double tol=RTraits< double >::getDefaultTolerance()) |
Test a double for approximate equality to an integer. More... | |
bool | isNumericallyEqual (int a, const double &b, double tol=RTraits< double >::getDefaultTolerance()) |
Test a double for approximate equality to an integer. More... | |
template<class P , class Q > | |
bool | isNumericallyEqual (const std::complex< P > &a, const std::complex< Q > &b, double tol=RTraits< typename Narrowest< P, Q >::Precision >::getDefaultTolerance()) |
Compare two complex numbers for approximate equality, using the numerical accuracy expectation of the narrower of the two precisions in the case of mixed precision. More... | |
template<class P , class Q > | |
bool | isNumericallyEqual (const conjugate< P > &a, const conjugate< Q > &b, double tol=RTraits< typename Narrowest< P, Q >::Precision >::getDefaultTolerance()) |
Compare two conjugate numbers for approximate equality, using the numerical accuracy expectation of the narrower of the two precisions in the case of mixed precision. More... | |
template<class P , class Q > | |
bool | isNumericallyEqual (const std::complex< P > &a, const conjugate< Q > &b, double tol=RTraits< typename Narrowest< P, Q >::Precision >::getDefaultTolerance()) |
Compare a complex and a conjugate number for approximate equality, using the numerical accuracy expectation of the narrower of the two precisions in the case of mixed precision. More... | |
template<class P , class Q > | |
bool | isNumericallyEqual (const conjugate< P > &a, const std::complex< Q > &b, double tol=RTraits< typename Narrowest< P, Q >::Precision >::getDefaultTolerance()) |
Compare a complex and a conjugate number for approximate equality, using the numerical accuracy expectation of the narrower of the two precisions in the case of mixed precision. More... | |
template<class P > | |
bool | isNumericallyEqual (const std::complex< P > &a, const float &b, double tol=RTraits< float >::getDefaultTolerance()) |
Test whether a complex number is approximately equal to a particular real float. More... | |
template<class P > | |
bool | isNumericallyEqual (const float &a, const std::complex< P > &b, double tol=RTraits< float >::getDefaultTolerance()) |
Test whether a complex number is approximately equal to a particular real float. More... | |
template<class P > | |
bool | isNumericallyEqual (const std::complex< P > &a, const double &b, double tol=RTraits< typename Narrowest< P, double >::Precision >::getDefaultTolerance()) |
Test whether a complex number is approximately equal to a particular real double. More... | |
template<class P > | |
bool | isNumericallyEqual (const double &a, const std::complex< P > &b, double tol=RTraits< typename Narrowest< P, double >::Precision >::getDefaultTolerance()) |
Test whether a complex number is approximately equal to a particular real double. More... | |
template<class P > | |
bool | isNumericallyEqual (const std::complex< P > &a, int b, double tol=RTraits< P >::getDefaultTolerance()) |
Test whether a complex number is approximately equal to a particular integer. More... | |
template<class P > | |
bool | isNumericallyEqual (int a, const std::complex< P > &b, double tol=RTraits< P >::getDefaultTolerance()) |
Test whether a complex number is approximately equal to a particular integer. More... | |
template<class P > | |
bool | isNumericallyEqual (const conjugate< P > &a, const float &b, double tol=RTraits< float >::getDefaultTolerance()) |
Test whether a conjugate number is approximately equal to a particular real float. More... | |
template<class P > | |
bool | isNumericallyEqual (const float &a, const conjugate< P > &b, double tol=RTraits< float >::getDefaultTolerance()) |
Test whether a conjugate number is approximately equal to a particular real float. More... | |
template<class P > | |
bool | isNumericallyEqual (const conjugate< P > &a, const double &b, double tol=RTraits< typename Narrowest< P, double >::Precision >::getDefaultTolerance()) |
Test whether a conjugate number is approximately equal to a particular real double. More... | |
template<class P > | |
bool | isNumericallyEqual (const double &a, const conjugate< P > &b, double tol=RTraits< typename Narrowest< P, double >::Precision >::getDefaultTolerance()) |
Test whether a conjugate number is approximately equal to a particular real double. More... | |
template<class P > | |
bool | isNumericallyEqual (const conjugate< P > &a, int b, double tol=RTraits< P >::getDefaultTolerance()) |
Test whether a conjugate number is approximately equal to a particular integer. More... | |
template<class P > | |
bool | isNumericallyEqual (int a, const conjugate< P > &b, double tol=RTraits< P >::getDefaultTolerance()) |
Test whether a conjugate number is approximately equal to a particular integer. More... | |
SimTK_BNTCMPLX_SPEC (float, float) | |
SimTK_BNTCMPLX_SPEC (float, double) | |
SimTK_BNTCMPLX_SPEC (double, float) | |
SimTK_BNTCMPLX_SPEC (double, double) | |
SimTK_NTRAITS_CONJ_SPEC (float, float) | |
SimTK_NTRAITS_CONJ_SPEC (float, double) | |
SimTK_NTRAITS_CONJ_SPEC (double, float) | |
SimTK_NTRAITS_CONJ_SPEC (double, double) | |
SimTK_DEFINE_REAL_NTRAITS (float) | |
SimTK_DEFINE_REAL_NTRAITS (double) | |
bool | atMostOneBitIsSet (unsigned char v) |
bool | atMostOneBitIsSet (unsigned short v) |
bool | atMostOneBitIsSet (unsigned int v) |
bool | atMostOneBitIsSet (unsigned long v) |
bool | atMostOneBitIsSet (unsigned long long v) |
bool | atMostOneBitIsSet (signed char v) |
bool | atMostOneBitIsSet (char v) |
bool | atMostOneBitIsSet (short v) |
bool | atMostOneBitIsSet (int v) |
bool | atMostOneBitIsSet (long v) |
bool | atMostOneBitIsSet (long long v) |
bool | exactlyOneBitIsSet (unsigned char v) |
bool | exactlyOneBitIsSet (unsigned short v) |
bool | exactlyOneBitIsSet (unsigned int v) |
bool | exactlyOneBitIsSet (unsigned long v) |
bool | exactlyOneBitIsSet (unsigned long long v) |
bool | exactlyOneBitIsSet (signed char v) |
bool | exactlyOneBitIsSet (char v) |
bool | exactlyOneBitIsSet (short v) |
bool | exactlyOneBitIsSet (int v) |
bool | exactlyOneBitIsSet (long v) |
bool | exactlyOneBitIsSet (long long v) |
bool | signBit (unsigned char u) |
bool | signBit (unsigned short u) |
bool | signBit (unsigned int u) |
bool | signBit (unsigned long u) |
bool | signBit (unsigned long long u) |
bool | signBit (signed char i) |
bool | signBit (short i) |
bool | signBit (int i) |
bool | signBit (long long i) |
bool | signBit (long i) |
bool | signBit (const float &f) |
bool | signBit (const double &d) |
bool | signBit (const negator< float > &nf) |
bool | signBit (const negator< double > &nd) |
unsigned int | sign (unsigned char u) |
unsigned int | sign (unsigned short u) |
unsigned int | sign (unsigned int u) |
unsigned int | sign (unsigned long u) |
unsigned int | sign (unsigned long long u) |
int | sign (signed char i) |
int | sign (short i) |
int | sign (int i) |
int | sign (long i) |
int | sign (long long i) |
int | sign (const float &x) |
int | sign (const double &x) |
int | sign (const negator< float > &x) |
int | sign (const negator< double > &x) |
unsigned char | square (unsigned char u) |
unsigned short | square (unsigned short u) |
unsigned int | square (unsigned int u) |
unsigned long | square (unsigned long u) |
unsigned long long | square (unsigned long long u) |
char | square (char c) |
signed char | square (signed char i) |
short | square (short i) |
int | square (int i) |
long | square (long i) |
long long | square (long long i) |
float | square (const float &x) |
double | square (const double &x) |
float | square (const negator< float > &x) |
double | square (const negator< double > &x) |
template<class P > | |
std::complex< P > | square (const std::complex< P > &x) |
template<class P > | |
std::complex< P > | square (const conjugate< P > &x) |
template<class P > | |
std::complex< P > | square (const negator< std::complex< P > > &x) |
template<class P > | |
std::complex< P > | square (const negator< conjugate< P > > &x) |
unsigned char | cube (unsigned char u) |
unsigned short | cube (unsigned short u) |
unsigned int | cube (unsigned int u) |
unsigned long | cube (unsigned long u) |
unsigned long long | cube (unsigned long long u) |
char | cube (char c) |
signed char | cube (signed char i) |
short | cube (short i) |
int | cube (int i) |
long | cube (long i) |
long long | cube (long long i) |
float | cube (const float &x) |
double | cube (const double &x) |
negator< float > | cube (const negator< float > &x) |
negator< double > | cube (const negator< double > &x) |
template<class P > | |
std::complex< P > | cube (const std::complex< P > &x) |
template<class P > | |
std::complex< P > | cube (const negator< std::complex< P > > &x) |
template<class P > | |
std::complex< P > | cube (const conjugate< P > &x) |
template<class P > | |
std::complex< P > | cube (const negator< conjugate< P > > &x) |
double & | clampInPlace (double low, double &v, double high) |
Check that low <= v <= high and modify v in place if necessary to bring it into that range. More... | |
float & | clampInPlace (float low, float &v, float high) |
Check that low <= v <= high and modify v in place if necessary to bring it into that range. More... | |
double & | clampInPlace (int low, double &v, int high) |
Check that low <= v <= high and modify v in place if necessary to bring it into that range. More... | |
float & | clampInPlace (int low, float &v, int high) |
Check that low <= v <= high and modify v in place if necessary to bring it into that range. More... | |
double & | clampInPlace (int low, double &v, double high) |
Check that low <= v <= high and modify v in place if necessary to bring it into that range. More... | |
float & | clampInPlace (int low, float &v, float high) |
Check that low <= v <= high and modify v in place if necessary to bring it into that range. More... | |
double & | clampInPlace (double low, double &v, int high) |
Check that low <= v <= high and modify v in place if necessary to bring it into that range. More... | |
float & | clampInPlace (float low, float &v, int high) |
Check that low <= v <= high and modify v in place if necessary to bring it into that range. More... | |
unsigned char & | clampInPlace (unsigned char low, unsigned char &v, unsigned char high) |
Check that low <= v <= high and modify v in place if necessary to bring it into that range. More... | |
unsigned short & | clampInPlace (unsigned short low, unsigned short &v, unsigned short high) |
Check that low <= v <= high and modify v in place if necessary to bring it into that range. More... | |
unsigned int & | clampInPlace (unsigned int low, unsigned int &v, unsigned int high) |
Check that low <= v <= high and modify v in place if necessary to bring it into that range. More... | |
unsigned long & | clampInPlace (unsigned long low, unsigned long &v, unsigned long high) |
Check that low <= v <= high and modify v in place if necessary to bring it into that range. More... | |
unsigned long long & | clampInPlace (unsigned long long low, unsigned long long &v, unsigned long long high) |
Check that low <= v <= high and modify v in place if necessary to bring it into that range. More... | |
char & | clampInPlace (char low, char &v, char high) |
Check that low <= v <= high and modify v in place if necessary to bring it into that range. More... | |
signed char & | clampInPlace (signed char low, signed char &v, signed char high) |
Check that low <= v <= high and modify v in place if necessary to bring it into that range. More... | |
short & | clampInPlace (short low, short &v, short high) |
Check that low <= v <= high and modify v in place if necessary to bring it into that range. More... | |
int & | clampInPlace (int low, int &v, int high) |
Check that low <= v <= high and modify v in place if necessary to bring it into that range. More... | |
long & | clampInPlace (long low, long &v, long high) |
Check that low <= v <= high and modify v in place if necessary to bring it into that range. More... | |
long long & | clampInPlace (long long low, long long &v, long long high) |
Check that low <= v <= high and modify v in place if necessary to bring it into that range. More... | |
negator< float > & | clampInPlace (float low, negator< float > &v, float high) |
Check that low <= v <= high and modify v in place if necessary to bring it into that range. More... | |
negator< double > & | clampInPlace (double low, negator< double > &v, double high) |
Check that low <= v <= high and modify v in place if necessary to bring it into that range. More... | |
double | clamp (double low, double v, double high) |
If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v. More... | |
float | clamp (float low, float v, float high) |
If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v. More... | |
double | clamp (int low, double v, int high) |
If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v. More... | |
float | clamp (int low, float v, int high) |
If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v. More... | |
double | clamp (int low, double v, double high) |
If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v. More... | |
float | clamp (int low, float v, float high) |
If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v. More... | |
double | clamp (double low, double v, int high) |
If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v. More... | |
float | clamp (float low, float v, int high) |
If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v. More... | |
unsigned char | clamp (unsigned char low, unsigned char v, unsigned char high) |
If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v. More... | |
unsigned short | clamp (unsigned short low, unsigned short v, unsigned short high) |
If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v. More... | |
unsigned int | clamp (unsigned int low, unsigned int v, unsigned int high) |
If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v. More... | |
unsigned long | clamp (unsigned long low, unsigned long v, unsigned long high) |
If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v. More... | |
unsigned long long | clamp (unsigned long long low, unsigned long long v, unsigned long long high) |
If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v. More... | |
char | clamp (char low, char v, char high) |
If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v. More... | |
signed char | clamp (signed char low, signed char v, signed char high) |
If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v. More... | |
short | clamp (short low, short v, short high) |
If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v. More... | |
int | clamp (int low, int v, int high) |
If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v. More... | |
long | clamp (long low, long v, long high) |
If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v. More... | |
long long | clamp (long long low, long long v, long long high) |
If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v. More... | |
float | clamp (float low, negator< float > v, float high) |
If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v. More... | |
double | clamp (double low, negator< double > v, double high) |
If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v. More... | |
double | stepUp (double x) |
Interpolate smoothly from 0 up to 1 as the input argument goes from 0 to 1, with first and second derivatives zero at either end of the interval. More... | |
double | stepDown (double x) |
Interpolate smoothly from 1 down to 0 as the input argument goes from 0 to 1, with first and second derivatives zero at either end of the interval. More... | |
double | stepAny (double y0, double yRange, double x0, double oneOverXRange, double x) |
Interpolate smoothly from y0 to y1 as the input argument goes from x0 to x1, with first and second derivatives zero at either end of the interval. More... | |
double | dstepUp (double x) |
First derivative of stepUp(): d/dx stepUp(x). More... | |
double | dstepDown (double x) |
First derivative of stepDown(): d/dx stepDown(x). More... | |
double | dstepAny (double yRange, double x0, double oneOverXRange, double x) |
First derivative of stepAny(): d/dx stepAny(x). More... | |
double | d2stepUp (double x) |
Second derivative of stepUp(): d^2/dx^2 stepUp(x). More... | |
double | d2stepDown (double x) |
Second derivative of stepDown(): d^2/dx^2 stepDown(x). More... | |
double | d2stepAny (double yRange, double x0, double oneOverXRange, double x) |
Second derivative of stepAny(): d^2/dx^2 stepAny(x). More... | |
double | d3stepUp (double x) |
Third derivative of stepUp(): d^3/dx^3 stepUp(x). More... | |
double | d3stepDown (double x) |
Third derivative of stepDown(): d^3/dx^3 stepDown(x). More... | |
double | d3stepAny (double yRange, double x0, double oneOverXRange, double x) |
Third derivative of stepAny(): d^3/dx^3 stepAny(x). More... | |
float | stepUp (float x) |
Interpolate smoothly from 0 up to 1 as the input argument goes from 0 to 1, with first and second derivatives zero at either end of the interval. More... | |
float | stepDown (float x) |
Interpolate smoothly from 1 down to 0 as the input argument goes from 0 to 1, with first and second derivatives zero at either end of the interval. More... | |
float | stepAny (float y0, float yRange, float x0, float oneOverXRange, float x) |
Interpolate smoothly from y0 to y1 as the input argument goes from x0 to x1, with first and second derivatives zero at either end of the interval. More... | |
float | dstepUp (float x) |
First derivative of stepUp(): d/dx stepUp(x). More... | |
float | dstepDown (float x) |
First derivative of stepDown(): d/dx stepDown(x). More... | |
float | dstepAny (float yRange, float x0, float oneOverXRange, float x) |
First derivative of stepAny(): d/dx stepAny(x). More... | |
float | d2stepUp (float x) |
Second derivative of stepUp(): d^2/dx^2 stepUp(x). More... | |
float | d2stepDown (float x) |
Second derivative of stepDown(): d^2/dx^2 stepDown(x). More... | |
float | d2stepAny (float yRange, float x0, float oneOverXRange, float x) |
Second derivative of stepAny(): d^2/dx^2 stepAny(x). More... | |
float | d3stepUp (float x) |
Third derivative of stepUp(): d^3/dx^3 stepUp(x). More... | |
float | d3stepDown (float x) |
Third derivative of stepDown(): d^3/dx^3 stepDown(x). More... | |
float | d3stepAny (float yRange, float x0, float oneOverXRange, float x) |
Third derivative of stepAny(): d^3/dx^3 stepAny(x). More... | |
double | stepUp (int x) |
Interpolate smoothly from 0 up to 1 as the input argument goes from 0 to 1, with first and second derivatives zero at either end of the interval. More... | |
double | stepDown (int x) |
Interpolate smoothly from 1 down to 0 as the input argument goes from 0 to 1, with first and second derivatives zero at either end of the interval. More... | |
std::pair< double, double > | approxCompleteEllipticIntegralsKE (double m) |
Given 0<=m<=1, return complete elliptic integrals of the first and second kinds, K(m) and E(m), approximated but with a maximum error of 2e-8 so at least 7 digits are correct (same in float or double precision). See Elliptic integrals for a discussion. More... | |
std::pair< float, float > | approxCompleteEllipticIntegralsKE (float m) |
This is the single precision (float) version of the approximate calculation of elliptic integrals, still yielding about 7 digits of accuracy even though all calculations are done in float precision. More... | |
std::pair< double, double > | approxCompleteEllipticIntegralsKE (int m) |
This integer overload is present to prevent ambiguity; it converts its argument to double precision and then calls approxCompleteEllipticIntegralsKE(double). More... | |
std::pair< double, double > | completeEllipticIntegralsKE (double m) |
Given 0<=m<=1, return complete elliptic integrals of the first and second kinds, K(m) and E(m), calculated to (roughly) machine precision (float or double). See Elliptic integrals for a discussion. More... | |
std::pair< float, float > | completeEllipticIntegralsKE (float m) |
This is the single precision (float) version of the machine-precision calculation of elliptic integrals, providing accuracy to float precision (about 7 digits) which is no better than you'll get with the much faster approximate version, so use that instead! More... | |
std::pair< double, double > | completeEllipticIntegralsKE (int m) |
This integer overload is present to prevent ambiguity; it converts its argument to double precision and then calls completeEllipticIntegralsKE(double). More... | |
SimTK_DEFINE_UNIQUE_INDEX_TYPE (EventId) | |
SimTK_DEFINE_UNIQUE_INDEX_TYPE (SystemEventTriggerIndex) | |
SimTK_DEFINE_UNIQUE_INDEX_TYPE (SystemEventTriggerByStageIndex) | |
SimTK_DEFINE_UNIQUE_INDEX_TYPE (EventTriggerByStageIndex) | |
SimTK_DEFINE_UNIQUE_INDEX_TYPE (MeasureIndex) | |
Define a unique integral type for safe indexing of Measures. More... | |
std::ostream & | operator<< (std::ostream &o, Stage g) |
SimTK_DEFINE_UNIQUE_INDEX_TYPE (SubsystemIndex) | |
SimTK_DEFINE_UNIQUE_INDEX_TYPE (SystemYIndex) | |
SimTK_DEFINE_UNIQUE_INDEX_TYPE (SystemQIndex) | |
SimTK_DEFINE_UNIQUE_INDEX_TYPE (QIndex) | |
SimTK_DEFINE_UNIQUE_INDEX_TYPE (SystemUIndex) | |
SimTK_DEFINE_UNIQUE_INDEX_TYPE (UIndex) | |
SimTK_DEFINE_UNIQUE_INDEX_TYPE (SystemZIndex) | |
SimTK_DEFINE_UNIQUE_INDEX_TYPE (ZIndex) | |
SimTK_DEFINE_UNIQUE_INDEX_TYPE (DiscreteVariableIndex) | |
SimTK_DEFINE_UNIQUE_INDEX_TYPE (CacheEntryIndex) | |
SimTK_DEFINE_UNIQUE_INDEX_TYPE (SystemYErrIndex) | |
SimTK_DEFINE_UNIQUE_INDEX_TYPE (SystemQErrIndex) | |
SimTK_DEFINE_UNIQUE_INDEX_TYPE (QErrIndex) | |
SimTK_DEFINE_UNIQUE_INDEX_TYPE (SystemUErrIndex) | |
SimTK_DEFINE_UNIQUE_INDEX_TYPE (UErrIndex) | |
SimTK_DEFINE_UNIQUE_INDEX_TYPE (SystemUDotErrIndex) | |
SimTK_DEFINE_UNIQUE_INDEX_TYPE (UDotErrIndex) | |
SimTK_DEFINE_UNIQUE_INDEX_TYPE (SystemMultiplierIndex) | |
SimTK_DEFINE_UNIQUE_INDEX_TYPE (MultiplierIndex) | |
std::ostream & | operator<< (std::ostream &o, const State &s) |
template<int M, int N, class EL , int CSL, int RSL, class ER , int CSR, int RSR> | |
Mat< M, N, EL, CSL, RSL >::template Result< Mat< M, N, ER, CSR, RSR > >::Add | operator+ (const Mat< M, N, EL, CSL, RSL > &l, const Mat< M, N, ER, CSR, RSR > &r) |
template<int M, int N, class EL , int CSL, int RSL, class ER , int CSR, int RSR> | |
Mat< M, N, EL, CSL, RSL >::template Result< Mat< M, N, ER, CSR, RSR > >::Sub | operator- (const Mat< M, N, EL, CSL, RSL > &l, const Mat< M, N, ER, CSR, RSR > &r) |
template<int M, int N, class EL , int CSL, int RSL, int P, class ER , int CSR, int RSR> | |
Mat< M, N, EL, CSL, RSL >::template Result< Mat< N, P, ER, CSR, RSR > >::Mul | operator* (const Mat< M, N, EL, CSL, RSL > &l, const Mat< N, P, ER, CSR, RSR > &r) |
template<int M, int N, class EL , int CSL, int RSL, int MM, int NN, class ER , int CSR, int RSR> | |
Mat< M, N, EL, CSL, RSL >::template Result< Mat< MM, NN, ER, CSR, RSR > >::MulNon | operator* (const Mat< M, N, EL, CSL, RSL > &l, const Mat< MM, NN, ER, CSR, RSR > &r) |
template<int M, int N, class EL , int CSL, int RSL, class ER , int CSR, int RSR> | |
bool | operator== (const Mat< M, N, EL, CSL, RSL > &l, const Mat< M, N, ER, CSR, RSR > &r) |
template<int M, int N, class EL , int CSL, int RSL, class ER , int CSR, int RSR> | |
bool | operator!= (const Mat< M, N, EL, CSL, RSL > &l, const Mat< M, N, ER, CSR, RSR > &r) |
template<int M, int N, class E , int CS, int RS> | |
Mat< M, N, E, CS, RS >::template Result< float >::Mul | operator* (const Mat< M, N, E, CS, RS > &l, const float &r) |
template<int M, int N, class E , int CS, int RS> | |
Mat< M, N, E, CS, RS >::template Result< float >::Mul | operator* (const float &l, const Mat< M, N, E, CS, RS > &r) |
template<int M, int N, class E , int CS, int RS> | |
Mat< M, N, E, CS, RS >::template Result< double >::Mul | operator* (const Mat< M, N, E, CS, RS > &l, const double &r) |
template<int M, int N, class E , int CS, int RS> | |
Mat< M, N, E, CS, RS >::template Result< double >::Mul | operator* (const double &l, const Mat< M, N, E, CS, RS > &r) |
template<int M, int N, class E , int CS, int RS> | |
Mat< M, N, E, CS, RS >::template Result< typename CNT< E >::Precision >::Mul | operator* (const Mat< M, N, E, CS, RS > &l, int r) |
template<int M, int N, class E , int CS, int RS> | |
Mat< M, N, E, CS, RS >::template Result< typename CNT< E >::Precision >::Mul | operator* (int l, const Mat< M, N, E, CS, RS > &r) |
template<int M, int N, class E , int CS, int RS, class R > | |
Mat< M, N, E, CS, RS >::template Result< std::complex< R > >::Mul | operator* (const Mat< M, N, E, CS, RS > &l, const std::complex< R > &r) |
template<int M, int N, class E , int CS, int RS, class R > | |
Mat< M, N, E, CS, RS >::template Result< std::complex< R > >::Mul | operator* (const std::complex< R > &l, const Mat< M, N, E, CS, RS > &r) |
template<int M, int N, class E , int CS, int RS, class R > | |
Mat< M, N, E, CS, RS >::template Result< std::complex< R > >::Mul | operator* (const Mat< M, N, E, CS, RS > &l, const conjugate< R > &r) |
template<int M, int N, class E , int CS, int RS, class R > | |
Mat< M, N, E, CS, RS >::template Result< std::complex< R > >::Mul | operator* (const conjugate< R > &l, const Mat< M, N, E, CS, RS > &r) |
template<int M, int N, class E , int CS, int RS, class R > | |
Mat< M, N, E, CS, RS >::template Result< typename negator< R >::StdNumber >::Mul | operator* (const Mat< M, N, E, CS, RS > &l, const negator< R > &r) |
template<int M, int N, class E , int CS, int RS, class R > | |
Mat< M, N, E, CS, RS >::template Result< typename negator< R >::StdNumber >::Mul | operator* (const negator< R > &l, const Mat< M, N, E, CS, RS > &r) |
template<int M, int N, class E , int CS, int RS> | |
Mat< M, N, E, CS, RS >::template Result< float >::Dvd | operator/ (const Mat< M, N, E, CS, RS > &l, const float &r) |
template<int M, int N, class E , int CS, int RS> | |
CNT< float >::template Result< Mat< M, N, E, CS, RS > >::Dvd | operator/ (const float &l, const Mat< M, N, E, CS, RS > &r) |
template<int M, int N, class E , int CS, int RS> | |
Mat< M, N, E, CS, RS >::template Result< double >::Dvd | operator/ (const Mat< M, N, E, CS, RS > &l, const double &r) |
template<int M, int N, class E , int CS, int RS> | |
CNT< double >::template Result< Mat< M, N, E, CS, RS > >::Dvd | operator/ (const double &l, const Mat< M, N, E, CS, RS > &r) |
template<int M, int N, class E , int CS, int RS> | |
Mat< M, N, E, CS, RS >::template Result< typename CNT< E >::Precision >::Dvd | operator/ (const Mat< M, N, E, CS, RS > &l, int r) |
template<int M, int N, class E , int CS, int RS> | |
CNT< typename CNT< E >::Precision >::template Result< Mat< M, N, E, CS, RS > >::Dvd | operator/ (int l, const Mat< M, N, E, CS, RS > &r) |
template<int M, int N, class E , int CS, int RS, class R > | |
Mat< M, N, E, CS, RS >::template Result< std::complex< R > >::Dvd | operator/ (const Mat< M, N, E, CS, RS > &l, const std::complex< R > &r) |
template<int M, int N, class E , int CS, int RS, class R > | |
CNT< std::complex< R > >::template Result< Mat< M, N, E, CS, RS > >::Dvd | operator/ (const std::complex< R > &l, const Mat< M, N, E, CS, RS > &r) |
template<int M, int N, class E , int CS, int RS, class R > | |
Mat< M, N, E, CS, RS >::template Result< std::complex< R > >::Dvd | operator/ (const Mat< M, N, E, CS, RS > &l, const conjugate< R > &r) |
template<int M, int N, class E , int CS, int RS, class R > | |
CNT< std::complex< R > >::template Result< Mat< M, N, E, CS, RS > >::Dvd | operator/ (const conjugate< R > &l, const Mat< M, N, E, CS, RS > &r) |
template<int M, int N, class E , int CS, int RS, class R > | |
Mat< M, N, E, CS, RS >::template Result< typename negator< R >::StdNumber >::Dvd | operator/ (const Mat< M, N, E, CS, RS > &l, const negator< R > &r) |
template<int M, int N, class E , int CS, int RS, class R > | |
CNT< R >::template Result< Mat< M, N, E, CS, RS > >::Dvd | operator/ (const negator< R > &l, const Mat< M, N, E, CS, RS > &r) |
template<int M, int N, class E , int CS, int RS> | |
Mat< M, N, E, CS, RS >::template Result< float >::Add | operator+ (const Mat< M, N, E, CS, RS > &l, const float &r) |
template<int M, int N, class E , int CS, int RS> | |
Mat< M, N, E, CS, RS >::template Result< float >::Add | operator+ (const float &l, const Mat< M, N, E, CS, RS > &r) |
template<int M, int N, class E , int CS, int RS> | |
Mat< M, N, E, CS, RS >::template Result< double >::Add | operator+ (const Mat< M, N, E, CS, RS > &l, const double &r) |
template<int M, int N, class E , int CS, int RS> | |
Mat< M, N, E, CS, RS >::template Result< double >::Add | operator+ (const double &l, const Mat< M, N, E, CS, RS > &r) |
template<int M, int N, class E , int CS, int RS> | |
Mat< M, N, E, CS, RS >::template Result< typename CNT< E >::Precision >::Add | operator+ (const Mat< M, N, E, CS, RS > &l, int r) |
template<int M, int N, class E , int CS, int RS> | |
Mat< M, N, E, CS, RS >::template Result< typename CNT< E >::Precision >::Add | operator+ (int l, const Mat< M, N, E, CS, RS > &r) |
template<int M, int N, class E , int CS, int RS, class R > | |
Mat< M, N, E, CS, RS >::template Result< std::complex< R > >::Add | operator+ (const Mat< M, N, E, CS, RS > &l, const std::complex< R > &r) |
template<int M, int N, class E , int CS, int RS, class R > | |
Mat< M, N, E, CS, RS >::template Result< std::complex< R > >::Add | operator+ (const std::complex< R > &l, const Mat< M, N, E, CS, RS > &r) |
template<int M, int N, class E , int CS, int RS, class R > | |
Mat< M, N, E, CS, RS >::template Result< std::complex< R > >::Add | operator+ (const Mat< M, N, E, CS, RS > &l, const conjugate< R > &r) |
template<int M, int N, class E , int CS, int RS, class R > | |
Mat< M, N, E, CS, RS >::template Result< std::complex< R > >::Add | operator+ (const conjugate< R > &l, const Mat< M, N, E, CS, RS > &r) |
template<int M, int N, class E , int CS, int RS, class R > | |
Mat< M, N, E, CS, RS >::template Result< typename negator< R >::StdNumber >::Add | operator+ (const Mat< M, N, E, CS, RS > &l, const negator< R > &r) |
template<int M, int N, class E , int CS, int RS, class R > | |
Mat< M, N, E, CS, RS >::template Result< typename negator< R >::StdNumber >::Add | operator+ (const negator< R > &l, const Mat< M, N, E, CS, RS > &r) |
template<int M, int N, class E , int CS, int RS> | |
Mat< M, N, E, CS, RS >::template Result< float >::Sub | operator- (const Mat< M, N, E, CS, RS > &l, const float &r) |
template<int M, int N, class E , int CS, int RS> | |
CNT< float >::template Result< Mat< M, N, E, CS, RS > >::Sub | operator- (const float &l, const Mat< M, N, E, CS, RS > &r) |
template<int M, int N, class E , int CS, int RS> | |
Mat< M, N, E, CS, RS >::template Result< double >::Sub | operator- (const Mat< M, N, E, CS, RS > &l, const double &r) |
template<int M, int N, class E , int CS, int RS> | |
CNT< double >::template Result< Mat< M, N, E, CS, RS > >::Sub | operator- (const double &l, const Mat< M, N, E, CS, RS > &r) |
template<int M, int N, class E , int CS, int RS> | |
Mat< M, N, E, CS, RS >::template Result< typename CNT< E >::Precision >::Sub | operator- (const Mat< M, N, E, CS, RS > &l, int r) |
template<int M, int N, class E , int CS, int RS> | |
CNT< typename CNT< E >::Precision >::template Result< Mat< M, N, E, CS, RS > >::Sub | operator- (int l, const Mat< M, N, E, CS, RS > &r) |
template<int M, int N, class E , int CS, int RS, class R > | |
Mat< M, N, E, CS, RS >::template Result< std::complex< R > >::Sub | operator- (const Mat< M, N, E, CS, RS > &l, const std::complex< R > &r) |
template<int M, int N, class E , int CS, int RS, class R > | |
CNT< std::complex< R > >::template Result< Mat< M, N, E, CS, RS > >::Sub | operator- (const std::complex< R > &l, const Mat< M, N, E, CS, RS > &r) |
template<int M, int N, class E , int CS, int RS, class R > | |
Mat< M, N, E, CS, RS >::template Result< std::complex< R > >::Sub | operator- (const Mat< M, N, E, CS, RS > &l, const conjugate< R > &r) |
template<int M, int N, class E , int CS, int RS, class R > | |
CNT< std::complex< R > >::template Result< Mat< M, N, E, CS, RS > >::Sub | operator- (const conjugate< R > &l, const Mat< M, N, E, CS, RS > &r) |
template<int M, int N, class E , int CS, int RS, class R > | |
Mat< M, N, E, CS, RS >::template Result< typename negator< R >::StdNumber >::Sub | operator- (const Mat< M, N, E, CS, RS > &l, const negator< R > &r) |
template<int M, int N, class E , int CS, int RS, class R > | |
CNT< R >::template Result< Mat< M, N, E, CS, RS > >::Sub | operator- (const negator< R > &l, const Mat< M, N, E, CS, RS > &r) |
template<int M, int N, class E , int CS, int RS, class CHAR , class TRAITS > | |
std::basic_ostream< CHAR, TRAITS > & | operator<< (std::basic_ostream< CHAR, TRAITS > &o, const Mat< M, N, E, CS, RS > &m) |
template<int M, int N, class E , int CS, int RS, class CHAR , class TRAITS > | |
std::basic_istream< CHAR, TRAITS > & | operator>> (std::basic_istream< CHAR, TRAITS > &is, Mat< M, N, E, CS, RS > &m) |
template<int N, class E1 , int S1, class E2 , int S2> | |
Row< N, E1, S1 >::template Result< Row< N, E2, S2 > >::Add | operator+ (const Row< N, E1, S1 > &l, const Row< N, E2, S2 > &r) |
template<int N, class E1 , int S1, class E2 , int S2> | |
Row< N, E1, S1 >::template Result< Row< N, E2, S2 > >::Sub | operator- (const Row< N, E1, S1 > &l, const Row< N, E2, S2 > &r) |
template<int N, class E1 , int S1, class E2 , int S2> | |
bool | operator== (const Row< N, E1, S1 > &l, const Row< N, E2, S2 > &r) |
bool = v1[i] == v2[i], for all elements i More... | |
template<int N, class E1 , int S1, class E2 , int S2> | |
bool | operator!= (const Row< N, E1, S1 > &l, const Row< N, E2, S2 > &r) |
bool = v1[i] != v2[i], for any element i More... | |
template<int N, class E1 , int S1, class E2 , int S2> | |
bool | operator< (const Row< N, E1, S1 > &l, const Row< N, E2, S2 > &r) |
bool = v1[i] < v2[i], for all elements i More... | |
template<int N, class E1 , int S1, class E2 > | |
bool | operator< (const Row< N, E1, S1 > &v, const E2 &e) |
bool = v[i] < e, for all elements v[i] and element e More... | |
template<int N, class E1 , int S1, class E2 , int S2> | |
bool | operator> (const Row< N, E1, S1 > &l, const Row< N, E2, S2 > &r) |
bool = v1[i] > v2[i], for all elements i More... | |
template<int N, class E1 , int S1, class E2 > | |
bool | operator> (const Row< N, E1, S1 > &v, const E2 &e) |
bool = v[i] > e, for all elements v[i] and element e More... | |
template<int N, class E1 , int S1, class E2 , int S2> | |
bool | operator<= (const Row< N, E1, S1 > &l, const Row< N, E2, S2 > &r) |
bool = v1[i] <= v2[i], for all elements i. More... | |
template<int N, class E1 , int S1, class E2 > | |
bool | operator<= (const Row< N, E1, S1 > &v, const E2 &e) |
bool = v[i] <= e, for all elements v[i] and element e. More... | |
template<int N, class E1 , int S1, class E2 , int S2> | |
bool | operator>= (const Row< N, E1, S1 > &l, const Row< N, E2, S2 > &r) |
bool = v1[i] >= v2[i], for all elements i This is not the same as !(v1<v2). More... | |
template<int N, class E1 , int S1, class E2 > | |
bool | operator>= (const Row< N, E1, S1 > &v, const E2 &e) |
bool = v[i] >= e, for all elements v[i] and element e. More... | |
template<int N, class E , int S> | |
Row< N, E, S >::template Result< float >::Mul | operator* (const Row< N, E, S > &l, const float &r) |
template<int N, class E , int S> | |
Row< N, E, S >::template Result< float >::Mul | operator* (const float &l, const Row< N, E, S > &r) |
template<int N, class E , int S> | |
Row< N, E, S >::template Result< double >::Mul | operator* (const Row< N, E, S > &l, const double &r) |
template<int N, class E , int S> | |
Row< N, E, S >::template Result< double >::Mul | operator* (const double &l, const Row< N, E, S > &r) |
template<int N, class E , int S> | |
Row< N, E, S >::template Result< typename CNT< E >::Precision >::Mul | operator* (const Row< N, E, S > &l, int r) |
template<int N, class E , int S> | |
Row< N, E, S >::template Result< typename CNT< E >::Precision >::Mul | operator* (int l, const Row< N, E, S > &r) |
template<int N, class E , int S, class R > | |
Row< N, E, S >::template Result< std::complex< R > >::Mul | operator* (const Row< N, E, S > &l, const std::complex< R > &r) |
template<int N, class E , int S, class R > | |
Row< N, E, S >::template Result< std::complex< R > >::Mul | operator* (const std::complex< R > &l, const Row< N, E, S > &r) |
template<int N, class E , int S, class R > | |
Row< N, E, S >::template Result< std::complex< R > >::Mul | operator* (const Row< N, E, S > &l, const conjugate< R > &r) |
template<int N, class E , int S, class R > | |
Row< N, E, S >::template Result< std::complex< R > >::Mul | operator* (const conjugate< R > &l, const Row< N, E, S > &r) |
template<int N, class E , int S, class R > | |
Row< N, E, S >::template Result< typename negator< R >::StdNumber >::Mul | operator* (const Row< N, E, S > &l, const negator< R > &r) |
template<int N, class E , int S, class R > | |
Row< N, E, S >::template Result< typename negator< R >::StdNumber >::Mul | operator* (const negator< R > &l, const Row< N, E, S > &r) |
template<int N, class E , int S> | |
Row< N, E, S >::template Result< float >::Dvd | operator/ (const Row< N, E, S > &l, const float &r) |
template<int N, class E , int S> | |
CNT< float >::template Result< Row< N, E, S > >::Dvd | operator/ (const float &l, const Row< N, E, S > &r) |
template<int N, class E , int S> | |
Row< N, E, S >::template Result< double >::Dvd | operator/ (const Row< N, E, S > &l, const double &r) |
template<int N, class E , int S> | |
CNT< double >::template Result< Row< N, E, S > >::Dvd | operator/ (const double &l, const Row< N, E, S > &r) |
template<int N, class E , int S> | |
Row< N, E, S >::template Result< typename CNT< E >::Precision >::Dvd | operator/ (const Row< N, E, S > &l, int r) |
template<int N, class E , int S> | |
CNT< typename CNT< E >::Precision >::template Result< Row< N, E, S > >::Dvd | operator/ (int l, const Row< N, E, S > &r) |
template<int N, class E , int S, class R > | |
Row< N, E, S >::template Result< std::complex< R > >::Dvd | operator/ (const Row< N, E, S > &l, const std::complex< R > &r) |
template<int N, class E , int S, class R > | |
CNT< std::complex< R > >::template Result< Row< N, E, S > >::Dvd | operator/ (const std::complex< R > &l, const Row< N, E, S > &r) |
template<int N, class E , int S, class R > | |
Row< N, E, S >::template Result< std::complex< R > >::Dvd | operator/ (const Row< N, E, S > &l, const conjugate< R > &r) |
template<int N, class E , int S, class R > | |
CNT< std::complex< R > >::template Result< Row< N, E, S > >::Dvd | operator/ (const conjugate< R > &l, const Row< N, E, S > &r) |
template<int N, class E , int S, class R > | |
Row< N, E, S >::template Result< typename negator< R >::StdNumber >::Dvd | operator/ (const Row< N, E, S > &l, const negator< R > &r) |
template<int N, class E , int S, class R > | |
CNT< R >::template Result< Row< N, E, S > >::Dvd | operator/ (const negator< R > &l, const Row< N, E, S > &r) |
template<int N, class E , int S> | |
Row< N, E, S >::template Result< float >::Add | operator+ (const Row< N, E, S > &l, const float &r) |
template<int N, class E , int S> | |
Row< N, E, S >::template Result< float >::Add | operator+ (const float &l, const Row< N, E, S > &r) |
template<int N, class E , int S> | |
Row< N, E, S >::template Result< double >::Add | operator+ (const Row< N, E, S > &l, const double &r) |
template<int N, class E , int S> | |
Row< N, E, S >::template Result< double >::Add | operator+ (const double &l, const Row< N, E, S > &r) |
template<int N, class E , int S> | |
Row< N, E, S >::template Result< typename CNT< E >::Precision >::Add | operator+ (const Row< N, E, S > &l, int r) |
template<int N, class E , int S> | |
Row< N, E, S >::template Result< typename CNT< E >::Precision >::Add | operator+ (int l, const Row< N, E, S > &r) |
template<int N, class E , int S, class R > | |
Row< N, E, S >::template Result< std::complex< R > >::Add | operator+ (const Row< N, E, S > &l, const std::complex< R > &r) |
template<int N, class E , int S, class R > | |
Row< N, E, S >::template Result< std::complex< R > >::Add | operator+ (const std::complex< R > &l, const Row< N, E, S > &r) |
template<int N, class E , int S, class R > | |
Row< N, E, S >::template Result< std::complex< R > >::Add | operator+ (const Row< N, E, S > &l, const conjugate< R > &r) |
template<int N, class E , int S, class R > | |
Row< N, E, S >::template Result< std::complex< R > >::Add | operator+ (const conjugate< R > &l, const Row< N, E, S > &r) |
template<int N, class E , int S, class R > | |
Row< N, E, S >::template Result< typename negator< R >::StdNumber >::Add | operator+ (const Row< N, E, S > &l, const negator< R > &r) |
template<int N, class E , int S, class R > | |
Row< N, E, S >::template Result< typename negator< R >::StdNumber >::Add | operator+ (const negator< R > &l, const Row< N, E, S > &r) |
template<int N, class E , int S> | |
Row< N, E, S >::template Result< float >::Sub | operator- (const Row< N, E, S > &l, const float &r) |
template<int N, class E , int S> | |
CNT< float >::template Result< Row< N, E, S > >::Sub | operator- (const float &l, const Row< N, E, S > &r) |
template<int N, class E , int S> | |
Row< N, E, S >::template Result< double >::Sub | operator- (const Row< N, E, S > &l, const double &r) |
template<int N, class E , int S> | |
CNT< double >::template Result< Row< N, E, S > >::Sub | operator- (const double &l, const Row< N, E, S > &r) |
template<int N, class E , int S> | |
Row< N, E, S >::template Result< typename CNT< E >::Precision >::Sub | operator- (const Row< N, E, S > &l, int r) |
template<int N, class E , int S> | |
CNT< typename CNT< E >::Precision >::template Result< Row< N, E, S > >::Sub | operator- (int l, const Row< N, E, S > &r) |
template<int N, class E , int S, class R > | |
Row< N, E, S >::template Result< std::complex< R > >::Sub | operator- (const Row< N, E, S > &l, const std::complex< R > &r) |
template<int N, class E , int S, class R > | |
CNT< std::complex< R > >::template Result< Row< N, E, S > >::Sub | operator- (const std::complex< R > &l, const Row< N, E, S > &r) |
template<int N, class E , int S, class R > | |
Row< N, E, S >::template Result< std::complex< R > >::Sub | operator- (const Row< N, E, S > &l, const conjugate< R > &r) |
template<int N, class E , int S, class R > | |
CNT< std::complex< R > >::template Result< Row< N, E, S > >::Sub | operator- (const conjugate< R > &l, const Row< N, E, S > &r) |
template<int N, class E , int S, class R > | |
Row< N, E, S >::template Result< typename negator< R >::StdNumber >::Sub | operator- (const Row< N, E, S > &l, const negator< R > &r) |
template<int N, class E , int S, class R > | |
CNT< R >::template Result< Row< N, E, S > >::Sub | operator- (const negator< R > &l, const Row< N, E, S > &r) |
template<int N, class E , int S, class CHAR , class TRAITS > | |
std::basic_ostream< CHAR, TRAITS > & | operator<< (std::basic_ostream< CHAR, TRAITS > &o, const Row< N, E, S > &v) |
template<int N, class E , int S, class CHAR , class TRAITS > | |
std::basic_istream< CHAR, TRAITS > & | operator>> (std::basic_istream< CHAR, TRAITS > &is, Row< N, E, S > &v) |
Read a Row from a stream as M elements separated by white space or by commas, optionally enclosed in () or [] (but no leading "~"). More... | |
template<int M, class EL , int CSL, int RSL, class ER , int RSR> | |
bool | operator== (const Mat< M, M, EL, CSL, RSL > &l, const SymMat< M, ER, RSR > &r) |
template<int M, class EL , int CSL, int RSL, class ER , int RSR> | |
bool | operator!= (const Mat< M, M, EL, CSL, RSL > &l, const SymMat< M, ER, RSR > &r) |
template<int M, class EL , int RSL, class ER , int CSR, int RSR> | |
bool | operator== (const SymMat< M, EL, RSL > &l, const Mat< M, M, ER, CSR, RSR > &r) |
template<int M, class EL , int RSL, class ER , int CSR, int RSR> | |
bool | operator!= (const SymMat< M, EL, RSL > &l, const Mat< M, M, ER, CSR, RSR > &r) |
template<int M, class E1 , int S1, class E2 , int S2> | |
CNT< typename CNT< E1 >::THerm >::template Result< E2 >::Mul | dot (const Vec< M, E1, S1 > &r, const Vec< M, E2, S2 > &v) |
template<class E1 , int S1, class E2 , int S2> | |
CNT< typename CNT< E1 >::THerm >::template Result< E2 >::Mul | dot (const Vec< 1, E1, S1 > &r, const Vec< 1, E2, S2 > &v) |
template<int N, class E1 , int S1, class E2 , int S2> | |
CNT< E1 >::template Result< E2 >::Mul | operator* (const Row< N, E1, S1 > &r, const Vec< N, E2, S2 > &v) |
template<class E1 , int S1, class E2 , int S2> | |
CNT< E1 >::template Result< E2 >::Mul | operator* (const Row< 1, E1, S1 > &r, const Vec< 1, E2, S2 > &v) |
template<int N, class E1 , int S1, class E2 , int S2> | |
CNT< E1 >::template Result< E2 >::Mul | dot (const Row< N, E1, S1 > &r, const Vec< N, E2, S2 > &v) |
template<int M, class E1 , int S1, class E2 , int S2> | |
CNT< E1 >::template Result< E2 >::Mul | dot (const Vec< M, E1, S1 > &v, const Row< M, E2, S2 > &r) |
template<int N, class E1 , int S1, class E2 , int S2> | |
CNT< E1 >::template Result< E2 >::Mul | dot (const Row< N, E1, S1 > &r, const Row< N, E2, S2 > &s) |
template<int M, class E1 , int S1, class E2 , int S2> | |
Mat< M, M, typename CNT< E1 >::template Result< typename CNT< E2 >::THerm >::Mul > | outer (const Vec< M, E1, S1 > &v, const Vec< M, E2, S2 > &w) |
template<int M, class E1 , int S1, class E2 , int S2> | |
Vec< M, E1, S1 >::template Result< Row< M, E2, S2 > >::Mul | operator* (const Vec< M, E1, S1 > &v, const Row< M, E2, S2 > &r) |
template<int M, class E1 , int S1, class E2 , int S2> | |
Mat< M, M, typename CNT< E1 >::template Result< E2 >::Mul > | outer (const Vec< M, E1, S1 > &v, const Row< M, E2, S2 > &r) |
template<int M, class E1 , int S1, class E2 , int S2> | |
Mat< M, M, typename CNT< E1 >::template Result< E2 >::Mul > | outer (const Row< M, E1, S1 > &r, const Vec< M, E2, S2 > &v) |
template<int M, class E1 , int S1, class E2 , int S2> | |
Mat< M, M, typename CNT< E1 >::template Result< E2 >::Mul > | outer (const Row< M, E1, S1 > &r, const Row< M, E2, S2 > &s) |
template<int M, int N, class ME , int CS, int RS, class E , int S> | |
Mat< M, N, ME, CS, RS >::template Result< Vec< N, E, S > >::Mul | operator* (const Mat< M, N, ME, CS, RS > &m, const Vec< N, E, S > &v) |
template<int M, class E , int S, int N, class ME , int CS, int RS> | |
Row< M, E, S >::template Result< Mat< M, N, ME, CS, RS > >::Mul | operator* (const Row< M, E, S > &r, const Mat< M, N, ME, CS, RS > &m) |
template<int N, class ME , int RS, class E , int S> | |
SymMat< N, ME, RS >::template Result< Vec< N, E, S > >::Mul | operator* (const SymMat< N, ME, RS > &m, const Vec< N, E, S > &v) |
template<class ME , int RS, class E , int S> | |
SymMat< 1, ME, RS >::template Result< Vec< 1, E, S > >::Mul | operator* (const SymMat< 1, ME, RS > &m, const Vec< 1, E, S > &v) |
template<class ME , int RS, class E , int S> | |
SymMat< 2, ME, RS >::template Result< Vec< 2, E, S > >::Mul | operator* (const SymMat< 2, ME, RS > &m, const Vec< 2, E, S > &v) |
template<class ME , int RS, class E , int S> | |
SymMat< 3, ME, RS >::template Result< Vec< 3, E, S > >::Mul | operator* (const SymMat< 3, ME, RS > &m, const Vec< 3, E, S > &v) |
template<int M, class E , int S, class ME , int RS> | |
Row< M, E, S >::template Result< SymMat< M, ME, RS > >::Mul | operator* (const Row< M, E, S > &r, const SymMat< M, ME, RS > &m) |
template<class E , int S, class ME , int RS> | |
Row< 1, E, S >::template Result< SymMat< 1, ME, RS > >::Mul | operator* (const Row< 1, E, S > &r, const SymMat< 1, ME, RS > &m) |
template<class E , int S, class ME , int RS> | |
Row< 2, E, S >::template Result< SymMat< 2, ME, RS > >::Mul | operator* (const Row< 2, E, S > &r, const SymMat< 2, ME, RS > &m) |
template<class E , int S, class ME , int RS> | |
Row< 3, E, S >::template Result< SymMat< 3, ME, RS > >::Mul | operator* (const Row< 3, E, S > &r, const SymMat< 3, ME, RS > &m) |
template<int M, class E1 , int S1, int N, class E2 , int S2> | |
Vec< M, E1, S1 >::template Result< Row< N, E2, S2 > >::MulNon | operator* (const Vec< M, E1, S1 > &v, const Row< N, E2, S2 > &r) |
template<int M, class E1 , int S1, int MM, int NN, class E2 , int CS2, int RS2> | |
Vec< M, E1, S1 >::template Result< Mat< MM, NN, E2, CS2, RS2 > >::MulNon | operator* (const Vec< M, E1, S1 > &v, const Mat< MM, NN, E2, CS2, RS2 > &m) |
template<int M, class E1 , int S1, int MM, class E2 , int RS2> | |
Vec< M, E1, S1 >::template Result< SymMat< MM, E2, RS2 > >::MulNon | operator* (const Vec< M, E1, S1 > &v, const SymMat< MM, E2, RS2 > &m) |
template<int M, class E1 , int S1, int MM, class E2 , int S2> | |
Vec< M, E1, S1 >::template Result< Vec< MM, E2, S2 > >::MulNon | operator* (const Vec< M, E1, S1 > &v1, const Vec< MM, E2, S2 > &v2) |
template<int M, class E , int S, int MM, int NN, class ME , int CS, int RS> | |
Row< M, E, S >::template Result< Mat< MM, NN, ME, CS, RS > >::MulNon | operator* (const Row< M, E, S > &r, const Mat< MM, NN, ME, CS, RS > &m) |
template<int N, class E1 , int S1, int M, class E2 , int S2> | |
Row< N, E1, S1 >::template Result< Vec< M, E2, S2 > >::MulNon | operator* (const Row< N, E1, S1 > &r, const Vec< M, E2, S2 > &v) |
template<int N1, class E1 , int S1, int N2, class E2 , int S2> | |
Row< N1, E1, S1 >::template Result< Row< N2, E2, S2 > >::MulNon | operator* (const Row< N1, E1, S1 > &r1, const Row< N2, E2, S2 > &r2) |
template<int M, int N, class ME , int CS, int RS, int MM, class E , int S> | |
Mat< M, N, ME, CS, RS >::template Result< Vec< MM, E, S > >::MulNon | operator* (const Mat< M, N, ME, CS, RS > &m, const Vec< MM, E, S > &v) |
template<int M, int N, class ME , int CS, int RS, int NN, class E , int S> | |
Mat< M, N, ME, CS, RS >::template Result< Row< NN, E, S > >::MulNon | operator* (const Mat< M, N, ME, CS, RS > &m, const Row< NN, E, S > &r) |
template<int M, int N, class ME , int CS, int RS, int Dim, class E , int S> | |
Mat< M, N, ME, CS, RS >::template Result< SymMat< Dim, E, S > >::MulNon | operator* (const Mat< M, N, ME, CS, RS > &m, const SymMat< Dim, E, S > &sy) |
template<class E1 , int S1, class E2 , int S2> | |
Vec< 3, typename CNT< E1 >::template Result< E2 >::Mul > | cross (const Vec< 3, E1, S1 > &a, const Vec< 3, E2, S2 > &b) |
template<class E1 , int S1, class E2 , int S2> | |
Vec< 3, typename CNT< E1 >::template Result< E2 >::Mul > | operator% (const Vec< 3, E1, S1 > &a, const Vec< 3, E2, S2 > &b) |
template<class E1 , int S1, class E2 , int S2> | |
Row< 3, typename CNT< E1 >::template Result< E2 >::Mul > | cross (const Vec< 3, E1, S1 > &a, const Row< 3, E2, S2 > &b) |
template<class E1 , int S1, class E2 , int S2> | |
Row< 3, typename CNT< E1 >::template Result< E2 >::Mul > | operator% (const Vec< 3, E1, S1 > &a, const Row< 3, E2, S2 > &b) |
template<class E1 , int S1, class E2 , int S2> | |
Row< 3, typename CNT< E1 >::template Result< E2 >::Mul > | cross (const Row< 3, E1, S1 > &a, const Vec< 3, E2, S2 > &b) |
template<class E1 , int S1, class E2 , int S2> | |
Row< 3, typename CNT< E1 >::template Result< E2 >::Mul > | operator% (const Row< 3, E1, S1 > &a, const Vec< 3, E2, S2 > &b) |
template<class E1 , int S1, class E2 , int S2> | |
Row< 3, typename CNT< E1 >::template Result< E2 >::Mul > | cross (const Row< 3, E1, S1 > &a, const Row< 3, E2, S2 > &b) |
template<class E1 , int S1, class E2 , int S2> | |
Row< 3, typename CNT< E1 >::template Result< E2 >::Mul > | operator% (const Row< 3, E1, S1 > &a, const Row< 3, E2, S2 > &b) |
template<class E1 , int S1, int N, class E2 , int CS, int RS> | |
Mat< 3, N, typename CNT< E1 >::template Result< E2 >::Mul > | cross (const Vec< 3, E1, S1 > &v, const Mat< 3, N, E2, CS, RS > &m) |
template<class E1 , int S1, int N, class E2 , int CS, int RS> | |
Mat< 3, N, typename CNT< E1 >::template Result< E2 >::Mul > | operator% (const Vec< 3, E1, S1 > &v, const Mat< 3, N, E2, CS, RS > &m) |
template<class E1 , int S1, int N, class E2 , int S2, int S3> | |
Row< N, Vec< 3, typename CNT< E1 >::template Result< E2 >::Mul > > | cross (const Vec< 3, E1, S1 > &v, const Row< N, Vec< 3, E2, S2 >, S3 > &m) |
template<class E1 , int S1, class E2 , int S2, int S3> | |
Row< 3, Vec< 3, typename CNT< E1 >::template Result< E2 >::Mul > > | cross (const Vec< 3, E1, S1 > &v, const Row< 3, Vec< 3, E2, S2 >, S3 > &m) |
template<class E1 , int S1, int N, class E2 , int S2, int S3> | |
Row< N, Vec< 3, typename CNT< E1 >::template Result< E2 >::Mul > > | operator% (const Vec< 3, E1, S1 > &v, const Row< N, Vec< 3, E2, S2 >, S3 > &m) |
template<class E1 , int S1, class E2 , int S2, int S3> | |
Row< 3, Vec< 3, typename CNT< E1 >::template Result< E2 >::Mul > > | operator% (const Vec< 3, E1, S1 > &v, const Row< 3, Vec< 3, E2, S2 >, S3 > &m) |
template<class EV , int SV, class EM , int RS> | |
Mat< 3, 3, typename CNT< EV >::template Result< EM >::Mul > | cross (const Vec< 3, EV, SV > &v, const SymMat< 3, EM, RS > &s) |
template<class EV , int SV, class EM , int RS> | |
Mat< 3, 3, typename CNT< EV >::template Result< EM >::Mul > | operator% (const Vec< 3, EV, SV > &v, const SymMat< 3, EM, RS > &s) |
template<class E1 , int S1, int N, class E2 , int CS, int RS> | |
Mat< 3, N, typename CNT< E1 >::template Result< E2 >::Mul > | cross (const Row< 3, E1, S1 > &r, const Mat< 3, N, E2, CS, RS > &m) |
template<class E1 , int S1, int N, class E2 , int CS, int RS> | |
Mat< 3, N, typename CNT< E1 >::template Result< E2 >::Mul > | operator% (const Row< 3, E1, S1 > &r, const Mat< 3, N, E2, CS, RS > &m) |
template<class EV , int SV, class EM , int RS> | |
Mat< 3, 3, typename CNT< EV >::template Result< EM >::Mul > | cross (const Row< 3, EV, SV > &r, const SymMat< 3, EM, RS > &s) |
template<class EV , int SV, class EM , int RS> | |
Mat< 3, 3, typename CNT< EV >::template Result< EM >::Mul > | operator% (const Row< 3, EV, SV > &r, const SymMat< 3, EM, RS > &s) |
template<int M, class EM , int CS, int RS, class EV , int S> | |
Mat< M, 3, typename CNT< EM >::template Result< EV >::Mul > | cross (const Mat< M, 3, EM, CS, RS > &m, const Vec< 3, EV, S > &v) |
template<int M, class EM , int CS, int RS, class EV , int S> | |
Mat< M, 3, typename CNT< EM >::template Result< EV >::Mul > | operator% (const Mat< M, 3, EM, CS, RS > &m, const Vec< 3, EV, S > &v) |
template<class EM , int RS, class EV , int SV> | |
Mat< 3, 3, typename CNT< EM >::template Result< EV >::Mul > | cross (const SymMat< 3, EM, RS > &s, const Vec< 3, EV, SV > &v) |
template<class EM , int RS, class EV , int SV> | |
Mat< 3, 3, typename CNT< EM >::template Result< EV >::Mul > | operator% (const SymMat< 3, EM, RS > &s, const Vec< 3, EV, SV > &v) |
template<int M, class EM , int CS, int RS, class ER , int S> | |
Mat< M, 3, typename CNT< EM >::template Result< ER >::Mul > | cross (const Mat< M, 3, EM, CS, RS > &m, const Row< 3, ER, S > &r) |
template<int M, class EM , int CS, int RS, class ER , int S> | |
Mat< M, 3, typename CNT< EM >::template Result< ER >::Mul > | operator% (const Mat< M, 3, EM, CS, RS > &m, const Row< 3, ER, S > &r) |
template<class EM , int RS, class EV , int SV> | |
Mat< 3, 3, typename CNT< EM >::template Result< EV >::Mul > | cross (const SymMat< 3, EM, RS > &s, const Row< 3, EV, SV > &r) |
template<class EM , int RS, class EV , int SV> | |
Mat< 3, 3, typename CNT< EM >::template Result< EV >::Mul > | operator% (const SymMat< 3, EM, RS > &s, const Row< 3, EV, SV > &r) |
template<class E1 , int S1, class E2 , int S2> | |
CNT< E1 >::template Result< E2 >::Mul | cross (const Vec< 2, E1, S1 > &a, const Vec< 2, E2, S2 > &b) |
template<class E1 , int S1, class E2 , int S2> | |
CNT< E1 >::template Result< E2 >::Mul | operator% (const Vec< 2, E1, S1 > &a, const Vec< 2, E2, S2 > &b) |
template<class E1 , int S1, class E2 , int S2> | |
CNT< E1 >::template Result< E2 >::Mul | cross (const Row< 2, E1, S1 > &a, const Vec< 2, E2, S2 > &b) |
template<class E1 , int S1, class E2 , int S2> | |
CNT< E1 >::template Result< E2 >::Mul | operator% (const Row< 2, E1, S1 > &a, const Vec< 2, E2, S2 > &b) |
template<class E1 , int S1, class E2 , int S2> | |
CNT< E1 >::template Result< E2 >::Mul | cross (const Vec< 2, E1, S1 > &a, const Row< 2, E2, S2 > &b) |
template<class E1 , int S1, class E2 , int S2> | |
CNT< E1 >::template Result< E2 >::Mul | operator% (const Vec< 2, E1, S1 > &a, const Row< 2, E2, S2 > &b) |
template<class E1 , int S1, class E2 , int S2> | |
CNT< E1 >::template Result< E2 >::Mul | cross (const Row< 2, E1, S1 > &a, const Row< 2, E2, S2 > &b) |
template<class E1 , int S1, class E2 , int S2> | |
CNT< E1 >::template Result< E2 >::Mul | operator% (const Row< 2, E1, S1 > &a, const Row< 2, E2, S2 > &b) |
template<class E , int S> | |
Mat< 3, 3, E > | crossMat (const Vec< 3, E, S > &v) |
Calculate matrix M(v) such that M(v)*w = v % w. More... | |
template<class E , int S> | |
Mat< 3, 3, E > | crossMat (const Vec< 3, negator< E >, S > &v) |
Specialize crossMat() for negated scalar types. More... | |
template<class E , int S> | |
Mat< 3, 3, E > | crossMat (const Row< 3, E, S > &r) |
Form cross product matrix from a Row vector; 3 flops. More... | |
template<class E , int S> | |
Mat< 3, 3, E > | crossMat (const Row< 3, negator< E >, S > &r) |
Form cross product matrix from a Row vector whose elements are negated scalars; 3 flops. More... | |
template<class E , int S> | |
Row< 2, E > | crossMat (const Vec< 2, E, S > &v) |
Calculate 2D cross product matrix M(v) such that M(v)*w = v0*w1-v1*w0 = v % w (a scalar). More... | |
template<class E , int S> | |
Row< 2, E > | crossMat (const Vec< 2, negator< E >, S > &v) |
Specialize 2D cross product matrix for negated scalar types; 1 flop. More... | |
template<class E , int S> | |
Row< 2, E > | crossMat (const Row< 2, E, S > &r) |
Form 2D cross product matrix from a Row<2>; 1 flop. More... | |
template<class E , int S> | |
Row< 2, E > | crossMat (const Row< 2, negator< E >, S > &r) |
Form 2D cross product matrix from a Row<2> with negated scalar elements; 1 flop. More... | |
template<class E , int S> | |
SymMat< 3, E > | crossMatSq (const Vec< 3, E, S > &v) |
Calculate matrix S(v) such that S(v)*w = -v % (v % w) = (v % w) % v. More... | |
template<class E , int S> | |
SymMat< 3, E > | crossMatSq (const Vec< 3, negator< E >, S > &v) |
template<class E , int S> | |
SymMat< 3, E > | crossMatSq (const Row< 3, E, S > &r) |
template<class E , int S> | |
SymMat< 3, E > | crossMatSq (const Row< 3, negator< E >, S > &r) |
template<class E , int CS, int RS> | |
E | det (const Mat< 1, 1, E, CS, RS > &m) |
Special case Mat 1x1 determinant. No computation. More... | |
template<class E , int RS> | |
E | det (const SymMat< 1, E, RS > &s) |
Special case SymMat 1x1 determinant. No computation. More... | |
template<class E , int CS, int RS> | |
E | det (const Mat< 2, 2, E, CS, RS > &m) |
Special case Mat 2x2 determinant. 3 flops (if elements are Real). More... | |
template<class E , int RS> | |
E | det (const SymMat< 2, E, RS > &s) |
Special case 2x2 SymMat determinant. 3 flops (if elements are Real). More... | |
template<class E , int CS, int RS> | |
E | det (const Mat< 3, 3, E, CS, RS > &m) |
Special case Mat 3x3 determinant. 14 flops (if elements are Real). More... | |
template<class E , int RS> | |
E | det (const SymMat< 3, E, RS > &s) |
Special case SymMat 3x3 determinant. 14 flops (if elements are Real). More... | |
template<int M, class E , int CS, int RS> | |
E | det (const Mat< M, M, E, CS, RS > &m) |
Calculate the determinant of a square matrix larger than 3x3 by recursive template expansion. More... | |
template<int M, class E , int RS> | |
E | det (const SymMat< M, E, RS > &s) |
Determinant of SymMat larger than 3x3. More... | |
template<class E , int CS, int RS> | |
Mat< 1, 1, E, CS, RS >::TInvert | lapackInverse (const Mat< 1, 1, E, CS, RS > &m) |
Specialized 1x1 lapackInverse(): costs one divide. More... | |
template<int M, class E , int CS, int RS> | |
Mat< M, M, E, CS, RS >::TInvert | lapackInverse (const Mat< M, M, E, CS, RS > &m) |
General inverse of small, fixed-size, square (mXm), non-singular matrix with scalar elements: use Lapack's LU routine with pivoting. More... | |
template<class E , int CS, int RS> | |
Mat< 1, 1, E, CS, RS >::TInvert | inverse (const Mat< 1, 1, E, CS, RS > &m) |
Specialized 1x1 Mat inverse: costs one divide. More... | |
template<class E , int RS> | |
SymMat< 1, E, RS >::TInvert | inverse (const SymMat< 1, E, RS > &s) |
Specialized 1x1 SymMat inverse: costs one divide. More... | |
template<class E , int CS, int RS> | |
Mat< 2, 2, E, CS, RS >::TInvert | inverse (const Mat< 2, 2, E, CS, RS > &m) |
Specialized 2x2 Mat inverse: costs one divide plus 9 flops. More... | |
template<class E , int RS> | |
SymMat< 2, E, RS >::TInvert | inverse (const SymMat< 2, E, RS > &s) |
Specialized 2x2 SymMat inverse: costs one divide plus 7 flops. More... | |
template<class E , int CS, int RS> | |
Mat< 3, 3, E, CS, RS >::TInvert | inverse (const Mat< 3, 3, E, CS, RS > &m) |
Specialized 3x3 inverse: costs one divide plus 41 flops (for real-valued matrices). More... | |
template<class E , int RS> | |
SymMat< 3, E, RS >::TInvert | inverse (const SymMat< 3, E, RS > &s) |
Specialized 3x3 inverse for symmetric or Hermitian: costs one divide plus 29 flops (for real-valued matrices). More... | |
template<int M, class E , int CS, int RS> | |
Mat< M, M, E, CS, RS >::TInvert | inverse (const Mat< M, M, E, CS, RS > &m) |
For any matrix larger than 3x3, we just punt to the Lapack implementation. More... | |
template<int M, class E1 , int S1, class E2 , int S2> | |
SymMat< M, E1, S1 >::template Result< SymMat< M, E2, S2 > >::Add | operator+ (const SymMat< M, E1, S1 > &l, const SymMat< M, E2, S2 > &r) |
template<int M, class E1 , int S1, class E2 , int S2> | |
SymMat< M, E1, S1 >::template Result< SymMat< M, E2, S2 > >::Sub | operator- (const SymMat< M, E1, S1 > &l, const SymMat< M, E2, S2 > &r) |
template<int M, class E1 , int S1, class E2 , int S2> | |
SymMat< M, E1, S1 >::template Result< SymMat< M, E2, S2 > >::Mul | operator* (const SymMat< M, E1, S1 > &l, const SymMat< M, E2, S2 > &r) |
template<int M, class E1 , int S1, class E2 , int S2> | |
bool | operator== (const SymMat< M, E1, S1 > &l, const SymMat< M, E2, S2 > &r) |
template<int M, class E1 , int S1, class E2 , int S2> | |
bool | operator!= (const SymMat< M, E1, S1 > &l, const SymMat< M, E2, S2 > &r) |
template<int M, class E , int S> | |
SymMat< M, E, S >::template Result< float >::Mul | operator* (const SymMat< M, E, S > &l, const float &r) |
template<int M, class E , int S> | |
SymMat< M, E, S >::template Result< float >::Mul | operator* (const float &l, const SymMat< M, E, S > &r) |
template<int M, class E , int S> | |
SymMat< M, E, S >::template Result< double >::Mul | operator* (const SymMat< M, E, S > &l, const double &r) |
template<int M, class E , int S> | |
SymMat< M, E, S >::template Result< double >::Mul | operator* (const double &l, const SymMat< M, E, S > &r) |
template<int M, class E , int S> | |
SymMat< M, E, S >::template Result< typename CNT< E >::Precision >::Mul | operator* (const SymMat< M, E, S > &l, int r) |
template<int M, class E , int S> | |
SymMat< M, E, S >::template Result< typename CNT< E >::Precision >::Mul | operator* (int l, const SymMat< M, E, S > &r) |
template<int M, class E , int S, class R > | |
SymMat< M, E, S >::template Result< std::complex< R > >::Mul | operator* (const SymMat< M, E, S > &l, const std::complex< R > &r) |
template<int M, class E , int S, class R > | |
SymMat< M, E, S >::template Result< std::complex< R > >::Mul | operator* (const std::complex< R > &l, const SymMat< M, E, S > &r) |
template<int M, class E , int S, class R > | |
SymMat< M, E, S >::template Result< std::complex< R > >::Mul | operator* (const SymMat< M, E, S > &l, const conjugate< R > &r) |
template<int M, class E , int S, class R > | |
SymMat< M, E, S >::template Result< std::complex< R > >::Mul | operator* (const conjugate< R > &l, const SymMat< M, E, S > &r) |
template<int M, class E , int S, class R > | |
SymMat< M, E, S >::template Result< typename negator< R >::StdNumber >::Mul | operator* (const SymMat< M, E, S > &l, const negator< R > &r) |
template<int M, class E , int S, class R > | |
SymMat< M, E, S >::template Result< typename negator< R >::StdNumber >::Mul | operator* (const negator< R > &l, const SymMat< M, E, S > &r) |
template<int M, class E , int S> | |
SymMat< M, E, S >::template Result< float >::Dvd | operator/ (const SymMat< M, E, S > &l, const float &r) |
template<int M, class E , int S> | |
CNT< float >::template Result< SymMat< M, E, S > >::Dvd | operator/ (const float &l, const SymMat< M, E, S > &r) |
template<int M, class E , int S> | |
SymMat< M, E, S >::template Result< double >::Dvd | operator/ (const SymMat< M, E, S > &l, const double &r) |
template<int M, class E , int S> | |
CNT< double >::template Result< SymMat< M, E, S > >::Dvd | operator/ (const double &l, const SymMat< M, E, S > &r) |
template<int M, class E , int S> | |
SymMat< M, E, S >::template Result< typename CNT< E >::Precision >::Dvd | operator/ (const SymMat< M, E, S > &l, int r) |
template<int M, class E , int S> | |
CNT< typename CNT< E >::Precision >::template Result< SymMat< M, E, S > >::Dvd | operator/ (int l, const SymMat< M, E, S > &r) |
template<int M, class E , int S, class R > | |
SymMat< M, E, S >::template Result< std::complex< R > >::Dvd | operator/ (const SymMat< M, E, S > &l, const std::complex< R > &r) |
template<int M, class E , int S, class R > | |
CNT< std::complex< R > >::template Result< SymMat< M, E, S > >::Dvd | operator/ (const std::complex< R > &l, const SymMat< M, E, S > &r) |
template<int M, class E , int S, class R > | |
SymMat< M, E, S >::template Result< std::complex< R > >::Dvd | operator/ (const SymMat< M, E, S > &l, const conjugate< R > &r) |
template<int M, class E , int S, class R > | |
CNT< std::complex< R > >::template Result< SymMat< M, E, S > >::Dvd | operator/ (const conjugate< R > &l, const SymMat< M, E, S > &r) |
template<int M, class E , int S, class R > | |
SymMat< M, E, S >::template Result< typename negator< R >::StdNumber >::Dvd | operator/ (const SymMat< M, E, S > &l, const negator< R > &r) |
template<int M, class E , int S, class R > | |
CNT< R >::template Result< SymMat< M, E, S > >::Dvd | operator/ (const negator< R > &l, const SymMat< M, E, S > &r) |
template<int M, class E , int S> | |
SymMat< M, E, S >::template Result< float >::Add | operator+ (const SymMat< M, E, S > &l, const float &r) |
template<int M, class E , int S> | |
SymMat< M, E, S >::template Result< float >::Add | operator+ (const float &l, const SymMat< M, E, S > &r) |
template<int M, class E , int S> | |
SymMat< M, E, S >::template Result< double >::Add | operator+ (const SymMat< M, E, S > &l, const double &r) |
template<int M, class E , int S> | |
SymMat< M, E, S >::template Result< double >::Add | operator+ (const double &l, const SymMat< M, E, S > &r) |
template<int M, class E , int S> | |
SymMat< M, E, S >::template Result< typename CNT< E >::Precision >::Add | operator+ (const SymMat< M, E, S > &l, int r) |
template<int M, class E , int S> | |
SymMat< M, E, S >::template Result< typename CNT< E >::Precision >::Add | operator+ (int l, const SymMat< M, E, S > &r) |
template<int M, class E , int S, class R > | |
SymMat< M, E, S >::template Result< std::complex< R > >::Add | operator+ (const SymMat< M, E, S > &l, const std::complex< R > &r) |
template<int M, class E , int S, class R > | |
SymMat< M, E, S >::template Result< std::complex< R > >::Add | operator+ (const std::complex< R > &l, const SymMat< M, E, S > &r) |
template<int M, class E , int S, class R > | |
SymMat< M, E, S >::template Result< std::complex< R > >::Add | operator+ (const SymMat< M, E, S > &l, const conjugate< R > &r) |
template<int M, class E , int S, class R > | |
SymMat< M, E, S >::template Result< std::complex< R > >::Add | operator+ (const conjugate< R > &l, const SymMat< M, E, S > &r) |
template<int M, class E , int S, class R > | |
SymMat< M, E, S >::template Result< typename negator< R >::StdNumber >::Add | operator+ (const SymMat< M, E, S > &l, const negator< R > &r) |
template<int M, class E , int S, class R > | |
SymMat< M, E, S >::template Result< typename negator< R >::StdNumber >::Add | operator+ (const negator< R > &l, const SymMat< M, E, S > &r) |
template<int M, class E , int S> | |
SymMat< M, E, S >::template Result< float >::Sub | operator- (const SymMat< M, E, S > &l, const float &r) |
template<int M, class E , int S> | |
CNT< float >::template Result< SymMat< M, E, S > >::Sub | operator- (const float &l, const SymMat< M, E, S > &r) |
template<int M, class E , int S> | |
SymMat< M, E, S >::template Result< double >::Sub | operator- (const SymMat< M, E, S > &l, const double &r) |
template<int M, class E , int S> | |
CNT< double >::template Result< SymMat< M, E, S > >::Sub | operator- (const double &l, const SymMat< M, E, S > &r) |
template<int M, class E , int S> | |
SymMat< M, E, S >::template Result< typename CNT< E >::Precision >::Sub | operator- (const SymMat< M, E, S > &l, int r) |
template<int M, class E , int S> | |
CNT< typename CNT< E >::Precision >::template Result< SymMat< M, E, S > >::Sub | operator- (int l, const SymMat< M, E, S > &r) |
template<int M, class E , int S, class R > | |
SymMat< M, E, S >::template Result< std::complex< R > >::Sub | operator- (const SymMat< M, E, S > &l, const std::complex< R > &r) |
template<int M, class E , int S, class R > | |
CNT< std::complex< R > >::template Result< SymMat< M, E, S > >::Sub | operator- (const std::complex< R > &l, const SymMat< M, E, S > &r) |
template<int M, class E , int S, class R > | |
SymMat< M, E, S >::template Result< std::complex< R > >::Sub | operator- (const SymMat< M, E, S > &l, const conjugate< R > &r) |
template<int M, class E , int S, class R > | |
CNT< std::complex< R > >::template Result< SymMat< M, E, S > >::Sub | operator- (const conjugate< R > &l, const SymMat< M, E, S > &r) |
template<int M, class E , int S, class R > | |
SymMat< M, E, S >::template Result< typename negator< R >::StdNumber >::Sub | operator- (const SymMat< M, E, S > &l, const negator< R > &r) |
template<int M, class E , int S, class R > | |
CNT< R >::template Result< SymMat< M, E, S > >::Sub | operator- (const negator< R > &l, const SymMat< M, E, S > &r) |
template<int M, class E , int RS, class CHAR , class TRAITS > | |
std::basic_ostream< CHAR, TRAITS > & | operator<< (std::basic_ostream< CHAR, TRAITS > &o, const SymMat< M, E, RS > &m) |
template<int M, class E , int RS, class CHAR , class TRAITS > | |
std::basic_istream< CHAR, TRAITS > & | operator>> (std::basic_istream< CHAR, TRAITS > &is, SymMat< M, E, RS > &m) |
template<int M, class E1 , int S1, class E2 , int S2> | |
Vec< M, E1, S1 >::template Result< Vec< M, E2, S2 > >::Add | operator+ (const Vec< M, E1, S1 > &l, const Vec< M, E2, S2 > &r) |
template<int M, class E1 , int S1, class E2 , int S2> | |
Vec< M, E1, S1 >::template Result< Vec< M, E2, S2 > >::Sub | operator- (const Vec< M, E1, S1 > &l, const Vec< M, E2, S2 > &r) |
template<int M, class E1 , int S1, class E2 , int S2> | |
bool | operator== (const Vec< M, E1, S1 > &l, const Vec< M, E2, S2 > &r) |
bool = v1[i] == v2[i], for all elements i More... | |
template<int M, class E1 , int S1, class E2 , int S2> | |
bool | operator!= (const Vec< M, E1, S1 > &l, const Vec< M, E2, S2 > &r) |
bool = v1[i] != v2[i], for any element i More... | |
template<int M, class E1 , int S1, class E2 > | |
bool | operator== (const Vec< M, E1, S1 > &v, const E2 &e) |
bool = v[i] == e, for all elements v[i] and element e More... | |
template<int M, class E1 , int S1, class E2 > | |
bool | operator!= (const Vec< M, E1, S1 > &v, const E2 &e) |
bool = v[i] != e, for any element v[i] and element e More... | |
template<int M, class E1 , int S1, class E2 , int S2> | |
bool | operator< (const Vec< M, E1, S1 > &l, const Vec< M, E2, S2 > &r) |
bool = v1[i] < v2[i], for all elements i More... | |
template<int M, class E1 , int S1, class E2 > | |
bool | operator< (const Vec< M, E1, S1 > &v, const E2 &e) |
bool = v[i] < e, for all elements v[i] and element e More... | |
template<int M, class E1 , int S1, class E2 , int S2> | |
bool | operator> (const Vec< M, E1, S1 > &l, const Vec< M, E2, S2 > &r) |
bool = v1[i] > v2[i], for all elements i More... | |
template<int M, class E1 , int S1, class E2 > | |
bool | operator> (const Vec< M, E1, S1 > &v, const E2 &e) |
bool = v[i] > e, for all elements v[i] and element e More... | |
template<int M, class E1 , int S1, class E2 , int S2> | |
bool | operator<= (const Vec< M, E1, S1 > &l, const Vec< M, E2, S2 > &r) |
bool = v1[i] <= v2[i], for all elements i. More... | |
template<int M, class E1 , int S1, class E2 > | |
bool | operator<= (const Vec< M, E1, S1 > &v, const E2 &e) |
bool = v[i] <= e, for all elements v[i] and element e. More... | |
template<int M, class E1 , int S1, class E2 , int S2> | |
bool | operator>= (const Vec< M, E1, S1 > &l, const Vec< M, E2, S2 > &r) |
bool = v1[i] >= v2[i], for all elements i This is not the same as !(v1<v2). More... | |
template<int M, class E1 , int S1, class E2 > | |
bool | operator>= (const Vec< M, E1, S1 > &v, const E2 &e) |
bool = v[i] >= e, for all elements v[i] and element e. More... | |
template<int M, class E , int S> | |
Vec< M, E, S >::template Result< float >::Mul | operator* (const Vec< M, E, S > &l, const float &r) |
template<int M, class E , int S> | |
Vec< M, E, S >::template Result< float >::Mul | operator* (const float &l, const Vec< M, E, S > &r) |
template<int M, class E , int S> | |
Vec< M, E, S >::template Result< double >::Mul | operator* (const Vec< M, E, S > &l, const double &r) |
template<int M, class E , int S> | |
Vec< M, E, S >::template Result< double >::Mul | operator* (const double &l, const Vec< M, E, S > &r) |
template<int M, class E , int S> | |
Vec< M, E, S >::template Result< typename CNT< E >::Precision >::Mul | operator* (const Vec< M, E, S > &l, int r) |
template<int M, class E , int S> | |
Vec< M, E, S >::template Result< typename CNT< E >::Precision >::Mul | operator* (int l, const Vec< M, E, S > &r) |
template<int M, class E , int S, class R > | |
Vec< M, E, S >::template Result< std::complex< R > >::Mul | operator* (const Vec< M, E, S > &l, const std::complex< R > &r) |
template<int M, class E , int S, class R > | |
Vec< M, E, S >::template Result< std::complex< R > >::Mul | operator* (const std::complex< R > &l, const Vec< M, E, S > &r) |
template<int M, class E , int S, class R > | |
Vec< M, E, S >::template Result< std::complex< R > >::Mul | operator* (const Vec< M, E, S > &l, const conjugate< R > &r) |