SimTK Namespace Reference

Detailed Description

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

Classes

class MatrixBase

Variable-size 2d matrix of Composite Numerical Type (ELT) elements. More...

class VectorBase

This is a dataless rehash of the MatrixBase class to specialize it for Vectors. More...

class RowVectorBase

This is a dataless rehash of the MatrixBase class to specialize it for RowVectors. More...

class TmpMatrixView_

XXX not ready for prime time. More...

class MatrixView_

This class is identical to a Matrix_; it is used only to manage the C++ rules for when copy constructors are called by introducing a separate type to prevent certain allowed optimizations from occuring when we don't want them. More...

class Matrix_

This is the class intended to appear in user code. More...

class VectorView_

class TmpVectorViewT

XXX not ready for prime time. More...

class Vector_

class RowVectorView_

class TmpRowVectorView_

XXX not ready for prime time. More...

class RowVector_

class MatrixShape

class MatrixSize

class MatrixStructure

class MatrixSparsity

class MatrixStorage

class MatrixCondition

class VectorIterator

This is an iterator for iterating over the elements of a matrix. More...

class MatrixStructures

Class of enums used to communicate various attributes of matrices that affect which alogrithms are used for factoring, solving etc. More...

class MatrixShapes

class MatrixSparseFormats

class MatrixStorageFormats

class MatrixConditions

class MatrixHelper

class AnalyticGeometry

This abstract class represents a piece of high-quality geometry that can be used for valid physical simulation. More...

class AnalyticCurve

class AnalyticSurface

class AnalyticVolume

class AnalyticLine

An analytic line has only a length. More...

class AnalyticCircle

An analytic circle has only a radius. More...

class AnalyticSphere

class AnalyticCylinder

The coordinate frame of the central cross section is the same as for a circle; that is, x and z are radial and y points along the cylinder's axis. More...

class AnalyticBrick

This is a rectangular solid. More...

class DecorativeGeometry

This is an abstract handle class using the PIMPL design pattern to hide the private implementation. More...

class DecorativeLine

A line between two points. More...

class DecorativeCircle

This defines a circle in the x-y plane, centered at the origin. More...

class DecorativeSphere

This defines a sphere centered at the origin. More...

class DecorativeEllipsoid

This defines an ellipsoidal solid centered at the origin and aligned with the local frame axes. More...

class DecorativeBrick

This defines a rectangular solid centered at the origin and aligned with the local frame axes. More...

class DecorativeCylinder

This defines a cylinder centered on the origin and aligned in the y direction. More...

class DecorativeFrame

This defines geometry to represent a coordinate frame. More...

class DecorativeText

This defines a text label with its base at the origin. More...

class DecorativeGeometryImplementation

Use this abstract class to connect your implementation of decorative geometry to the implementation-independent classes above. More...

class ArrayBase

class ArrayView

This class is a duplicate of Array and can be cast to an Array with no harm. More...

class Array

Container class like std::vector<T> but with hidden implementation. More...

class Concretize

Wrap a pointer to an abstract base class in a way that makes it behave like a concrete class (sometimes called a "ClonePtr"). More...

class Enumeration

This class defines an enumerated type. More...

class EnumerationSet

This class provides an efficient implementation of a set for storing values of an enumerated type defined with Enumeration. More...

class ListBase

class ListBase< T * >

class ListView

ListView is a 'dummy' class which is completely interchangeable with List. More...

class List

Container class with hidden implementation. More...

class PIMPLHandle

This class provides some infrastructure useful in making SimTK Private Implementation (PIMPL) classes. More...

class PIMPLDerivedHandle

This class is the parent of derived handle classes. More...

class PIMPLImplementation

This class provides some infrastructure useful in creating PIMPL Implementation classes (the ones referred to by Handles). More...

class StableArray

StableArray<T> is like std::vector<T> but more stable in two ways:

the addresses of the inserted items never change, even if the array has to be resized, and
the index of an inserted item never changes either.
More...

class String

SimTK::String is just an std::string with some additional methods defined. More...

class UserFunction

class AbstractValue

Abstract base class representing an arbitrary value of self-describing type. More...

class ValueHelper

Templatized version of the abstract class, providing generic type-specific functionality that does not require specialization. More...

class Value

A particular kind of AbstractValue, with automatic converstion to the underlying type. More...

class Lapack

class CoordinateAxis

class Inertia

The physical meaning of an inertia is the distribution of a rigid body's mass about a *particular* point. More...

class MassProperties

This class contains the mass, center of mass, and inertia of a rigid body B. More...

class Quaternion

A Quaternion is a Vec4 with the following behavior:

its length is always 1 (or else it is all NaN)
it is equivalent to an angle/axis rotation for angle a, axis unit vector v, as: q = [ cos(a/2) sin(a/2)*v ] A quaternion is in "canonical form" when its first element is nonnegative.
More...

class Rotation

The Rotation class is a Mat33 that guarantees that the matrix is a legitimate 3x3 array associated with the relative orientation of two right-handed, orthogonal, unit vector bases. More...

class InverseRotation

----------------------------------------------------------------------------- This InverseRotation class is the inverse of a Rotation See the Rotation class for information. More...

class PhiMatrix

class PhiMatrixTranspose

class Transform

This class represents the rotate-and-shift transform which gives the location and orientation of a new frame F in a base (reference) frame B. More...

class InverseTransform

Transform from frame B to frame F, but with the internal representation inverted. More...

class UnitVec

This class is a Vec3 plus an ironclad guarantee either that:

the length is one (to within a very small tolerance), or
all components are NaN.
More...

class UnitRow

This type is used for the transpose of UnitVec, and as the returned row type of a Rotation. More...

class PolynomialRootFinder

This class provides static methods for finding the roots of polynomials. More...

class Random

This class defines the interface for pseudo-random number generators. More...

class CNT

Specialized information about Composite Numerical Types which allows us to define appropriate templatized classes using them. More...

struct Wider

struct Wider< float, float >

struct Wider< float, double >

struct Wider< double, float >

struct Wider< double, double >

struct Wider< float, long double >

struct Wider< double, long double >

struct Wider< long double, float >

struct Wider< long double, double >

struct Wider< long double, long double >

class conjugate

SimTK::conjugate<R> should be instantiated only for float, double, long double. More...

class conjugate< float >

class conjugate< double >

class conjugate< long double >

class negator

negator<N>, where N is a number type (real, complex, conjugate), is represented in memory identically to N, but behaves as though multiplied by -1, though at zero cost. More...

struct Widest

struct Widest< float, float >

struct Widest< float, double >

struct Widest< float, long double >

struct Widest< double, float >

struct Widest< double, double >

struct Widest< double, long double >

struct Widest< long double, float >

struct Widest< long double, double >

struct Widest< long double, long double >

struct Widest< complex< R1 >, complex< R2 > >

struct Widest< complex< R1 >, R2 >

struct Widest< R1, complex< R2 > >

class NTraits

class NTraits< complex< R > >

Partial specialization for complex numbers -- underlying real R is still a template parameter. More...

class NTraits< conjugate< R > >

class CNT< complex< R > >

Specializations of CNT for numeric types. More...

class CNT< conjugate< R > >

class CNT< float >

class CNT< double >

class CNT< long double >

class EventHandler

An EventHandler is an object that defines an event that can occur within a system. More...

class ScheduledEventHandler

ScheduledEventHandler is a subclass of EventHandler for events that occur at a particular time that is known in advance. More...

class TriggeredEventHandler

TriggeredEventHandler is a subclass of EventHandler for events that occur when some condition is satisfied within the system. More...

class PeriodicEventHandler

PeriodicEventHandler is a subclass of ScheduledEventHandler which generates a series of uniformly spaced events at regular intervals. More...

class EventReporter

An EventReporter is an object that defines an event that can occur within a system. More...

class ScheduledEventReporter

ScheduledEventReporter is a subclass of EventReporter for events that occur at a particular time that is known in advance. More...

class TriggeredEventReporter

TriggeredEventReporter is a subclass of EventReporter for events that occur when some condition is satisfied within the system. More...

class PeriodicEventReporter

PeriodicEventReporter is a subclass of ScheduledEventReporter which generates a series of uniformly spaced events at regular intervals. More...

class Stage

This class is basically a glorified enumerated type, type-safe and range checked but permitting convenient (if limited) arithmetic. More...

class CacheEntry

class EventStatus

class State

This is the handle class for the hidden State implementation. More...

class Study

The handle class which serves as the abstract parent of all Studies. More...

class Subsystem

The abstract parent of all Subsystems. More...

class DefaultSystemSubsystem

This is a concrete Subsystem that is part of every System. More...

class Mat

CS is total spacing between columns in memory (default M) RS is total spacing between rows in memory (default 1). More...

class Row

Generic Row. More...

class SymMat

RS is total spacing between rows in memory (default 1). More...

class Vec

Generic Vec. More...

Namespaces

namespace Exception

namespace System

template<class E>

Vector_< E > operator * (const Transform &T, const VectorBase< E > &v)

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

template<class E>

Vector_< E > operator * (const VectorBase< E > &v, const Transform &T)

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

template<class E>

RowVector_< E > operator * (const Transform &T, const RowVectorBase< E > &v)

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

template<class E>

RowVector_< E > operator * (const RowVectorBase< E > &v, const Transform &T)

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

template<class E>

Matrix_< E > operator * (const Transform &T, const MatrixBase< E > &v)

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

template<class E>

Matrix_< E > operator * (const MatrixBase< E > &v, const Transform &T)

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

template<int N, class E>

Vec< N, E > operator * (const Transform &T, const Vec< N, E > &v)

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

template<int N, class E>

Vec< N, E > operator * (const Vec< N, E > &v, const Transform &T)

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

template<int N, class E>

Row< N, E > operator * (const Transform &T, const Row< N, E > &v)

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

template<int N, class E>

Row< N, E > operator * (const Row< N, E > &v, const Transform &T)

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

template<int M, int N, class E>

Mat< M, N, E > operator * (const Transform &T, const Mat< M, N, E > &v)

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

template<int M, int N, class E>

Mat< M, N, E > operator * (const Mat< M, N, E > &v, const Transform &T)

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

Typedefs

typedef Vector_< Real > Vector

typedef Vector_< Complex > ComplexVector

typedef VectorView_< Real > VectorView

typedef VectorView_< Complex > ComplexVectorView

typedef RowVector_< Real > RowVector

typedef RowVector_< Complex > ComplexRowVector

typedef RowVectorView_< Real > RowVectorView

typedef RowVectorView_< Complex > ComplexRowVectorView

typedef Matrix_< Real > Matrix

typedef Matrix_< Complex > ComplexMatrix

typedef MatrixView_< Real > MatrixView

typedef MatrixView_< Complex > ComplexMatrixView

typedef Mat< 2, 2, Mat33 > SpatialMat

typedef Vec< 2, Vec3 > SpatialVec

typedef Row< 2, Row3 > SpatialRow

typedef Mat< 2, 2, Mat33 > SpatialMat

typedef Vec< 2, Vec3 > SpatialVec

typedef Row< 2, Row3 > SpatialRow

typedef Mat< 2, 2, Mat33 > SpatialMat

typedef UnitVec< 1 > UnitVec3

typedef conjugate< Real > Conjugate

typedef Vec< 1 > Vec1

typedef Vec< 2 > Vec2

typedef Vec< 3 > Vec3

typedef Vec< 4 > Vec4

typedef Vec< 5 > Vec5

typedef Vec< 6 > Vec6

typedef Vec< 7 > Vec7

typedef Vec< 8 > Vec8

typedef Vec< 9 > Vec9

typedef Row< 1 > Row1

typedef Row< 2 > Row2

typedef Row< 3 > Row3

typedef Row< 4 > Row4

typedef Row< 5 > Row5

typedef Row< 6 > Row6

typedef Row< 7 > Row7

typedef Row< 8 > Row8

typedef Row< 9 > Row9

typedef SymMat< 1 > SymMat11

typedef SymMat< 2 > SymMat22

typedef SymMat< 3 > SymMat33

typedef SymMat< 4 > SymMat44

typedef SymMat< 5 > SymMat55

typedef SymMat< 6 > SymMat66

typedef SymMat< 7 > SymMat77

typedef SymMat< 8 > SymMat88

typedef SymMat< 9 > SymMat99

typedef Mat< 1, 1 > Mat11

typedef Mat< 1, 2 > Mat12

typedef Mat< 1, 3 > Mat13

typedef Mat< 1, 4 > Mat14

typedef Mat< 1, 5 > Mat15

typedef Mat< 1, 6 > Mat16

typedef Mat< 1, 7 > Mat17

typedef Mat< 1, 8 > Mat18

typedef Mat< 1, 9 > Mat19

typedef Mat< 2, 1 > Mat21

typedef Mat< 2, 2 > Mat22

typedef Mat< 2, 3 > Mat23

typedef Mat< 2, 4 > Mat24

typedef Mat< 2, 5 > Mat25

typedef Mat< 2, 6 > Mat26

typedef Mat< 2, 7 > Mat27

typedef Mat< 2, 8 > Mat28

typedef Mat< 2, 9 > Mat29

typedef Mat< 3, 1 > Mat31

typedef Mat< 3, 2 > Mat32

typedef Mat< 3, 3 > Mat33

typedef Mat< 3, 4 > Mat34

typedef Mat< 3, 5 > Mat35

typedef Mat< 3, 6 > Mat36

typedef Mat< 3, 7 > Mat37

typedef Mat< 3, 8 > Mat38

typedef Mat< 3, 9 > Mat39

typedef Mat< 4, 1 > Mat41

typedef Mat< 4, 2 > Mat42

typedef Mat< 4, 3 > Mat43

typedef Mat< 4, 4 > Mat44

typedef Mat< 4, 5 > Mat45

typedef Mat< 4, 6 > Mat46

typedef Mat< 4, 7 > Mat47

typedef Mat< 4, 8 > Mat48

typedef Mat< 4, 9 > Mat49

typedef Mat< 5, 1 > Mat51

typedef Mat< 5, 2 > Mat52

typedef Mat< 5, 3 > Mat53

typedef Mat< 5, 4 > Mat54

typedef Mat< 5, 5 > Mat55

typedef Mat< 5, 6 > Mat56

typedef Mat< 5, 7 > Mat57

typedef Mat< 5, 8 > Mat58

typedef Mat< 5, 9 > Mat59

typedef Mat< 6, 1 > Mat61

typedef Mat< 6, 2 > Mat62

typedef Mat< 6, 3 > Mat63

typedef Mat< 6, 4 > Mat64

typedef Mat< 6, 5 > Mat65

typedef Mat< 6, 6 > Mat66

typedef Mat< 6, 7 > Mat67

typedef Mat< 6, 8 > Mat68

typedef Mat< 6, 9 > Mat69

typedef Mat< 7, 1 > Mat71

typedef Mat< 7, 2 > Mat72

typedef Mat< 7, 3 > Mat73

typedef Mat< 7, 4 > Mat74

typedef Mat< 7, 5 > Mat75

typedef Mat< 7, 6 > Mat76

typedef Mat< 7, 7 > Mat77

typedef Mat< 7, 8 > Mat78

typedef Mat< 7, 9 > Mat79

typedef Mat< 8, 1 > Mat81

typedef Mat< 8, 2 > Mat82

typedef Mat< 8, 3 > Mat83

typedef Mat< 8, 4 > Mat84

typedef Mat< 8, 5 > Mat85

typedef Mat< 8, 6 > Mat86

typedef Mat< 8, 7 > Mat87

typedef Mat< 8, 8 > Mat88

typedef Mat< 8, 9 > Mat89

typedef Mat< 9, 1 > Mat91

typedef Mat< 9, 2 > Mat92

typedef Mat< 9, 3 > Mat93

typedef Mat< 9, 4 > Mat94

typedef Mat< 9, 5 > Mat95

typedef Mat< 9, 6 > Mat96

typedef Mat< 9, 7 > Mat97

typedef Mat< 9, 8 > Mat98

typedef Mat< 9, 9 > Mat99

Enumerations

enum 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
}

Functions

template<class E1, class E2>

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

template<class E>

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

template<class E>

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

template<class E1, class E2>

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

template<class E>

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

template<class E>

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

template<class E>

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

template<class E>

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

template<class E>

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

template<class E1, class E2>

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

template<class E>

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

template<class E>

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

template<class E1, class E2>

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

template<class E>

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

template<class E>

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

template<class E>

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

template<class E>

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

template<class E>

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

template<class E1, class E2>

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

template<class E>

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

template<class E>

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

template<class E1, class E2>

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

template<class E>

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

template<class E>

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

template<class E>

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

template<class E>

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

template<class E>

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

template<class E1, class E2>

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

template<class E1, class E2>

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

template<class E1, class E2>

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

template<class T>

std::ostream & operator<< (std::ostream &o, const VectorBase< T > &v)

template<class T>

std::ostream & operator<< (std::ostream &o, const RowVectorBase< T > &v)

template<class T>

std::ostream & operator<< (std::ostream &o, const MatrixBase< T > &m)

template<class T>

int findFirstOf (const Array< T > &a, const T &test)

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

template<class T>

int findFirstOf (const ArrayView< T > &a, const T &test)

template<class T>

Array< int > findAllOf (const Array< T > &a, const T &test)

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

template<class T>

Array< int > findAllOf (const ArrayView< T > &a, const T &test)

template<class T>

bool contains (const Array< T > &a, const T &test)

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

template<class T>

bool contains (const ArrayView< T > &a, const T &test)

template<class T>

std::ostream & operator<< (std::ostream &s, const Array< T > &a)

template<class T>

std::ostream & operator<< (std::ostream &s, const ArrayView< T > &a)

template<class T>

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

SimTK_LIST_SPECIALIZE (bool)

SimTK_LIST_SPECIALIZE (signed char)

SimTK_LIST_SPECIALIZE (char)

SimTK_LIST_SPECIALIZE (unsigned char)

SimTK_LIST_SPECIALIZE (short)

SimTK_LIST_SPECIALIZE (int)

SimTK_LIST_SPECIALIZE (long)

SimTK_LIST_SPECIALIZE (float)

SimTK_LIST_SPECIALIZE (double)

SimTK_LIST_SPECIALIZE (std::complex< float >)

SimTK_LIST_SPECIALIZE (std::complex< double >)

SimTK_LIST_SPECIALIZE (std::complex< long double >)

template<class T>

int findFirstOf (const List< T > &l, const T &test)

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

template<class T>

int findFirstOf (const ListView< T > &lv, const T &test)

template<class T>

Array< int > findAllOf (const List< T > &l, const T &test)

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

template<class T>

Array< int > findAllOf (const ListView< T > &lv, const T &test)

template<class T>

bool contains (const List< T > &l, const T &test)

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

template<class T>

bool contains (const ListView< T > &lv, const T &test)

template<class H, class IMPL, bool PTR>

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

template<class HANDLE, class IMPL, bool PTR>

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

std::ostream & operator<< (std::ostream &o, const AbstractValue &v)

template<class ELEM>

VectorBase< typename CNT<
ELEM >::TAbs > abs (const VectorBase< ELEM > v)

template<class ELEM>

RowVectorBase< typename CNT<
ELEM >::TAbs > abs (const RowVectorBase< ELEM > v)

template<class ELEM>

MatrixBase< typename CNT<
ELEM >::TAbs > abs (const MatrixBase< ELEM > v)

template<int N, class ELEM>

Vec< N, typename CNT< ELEM
>::TAbs > abs (const Vec< N, ELEM > v)

template<int N, class ELEM>

Row< N, typename CNT< ELEM
>::TAbs > abs (const Row< N, ELEM > v)

template<int M, int N, class ELEM>

Mat< M, N, typename CNT< ELEM
>::TAbs > abs (const Mat< M, N, ELEM > v)

template<int N, class ELEM>

SymMat< N, typename CNT< ELEM
>::TAbs > abs (const SymMat< N, ELEM > v)

template<class ELEM>

ELEM sum (const VectorBase< ELEM > v)

template<class ELEM>

ELEM sum (const RowVectorBase< ELEM > v)

template<class ELEM>

RowVectorBase< ELEM > sum (const MatrixBase< ELEM > v)

template<int N, class ELEM>

ELEM sum (const Vec< N, ELEM > v)

template<int N, class ELEM>

ELEM sum (const Row< N, ELEM > v)

template<int M, int N, class ELEM>

Row< N, ELEM > sum (const Mat< M, N, ELEM > v)

template<int N, class ELEM>

Row< N, ELEM > sum (const SymMat< N, ELEM > v)

template<class ELEM>

ELEM min (const VectorBase< ELEM > v)

template<class ELEM>

ELEM min (const RowVectorBase< ELEM > v)

template<class ELEM>

RowVectorBase< ELEM > min (const MatrixBase< ELEM > v)

template<int N, class ELEM>

ELEM min (const Vec< N, ELEM > v)

template<int N, class ELEM>

ELEM min (Row< N, ELEM > v)

template<int M, int N, class ELEM>

Row< N, ELEM > min (const Mat< M, N, ELEM > v)

template<int N, class ELEM>

Row< N, ELEM > min (SymMat< N, ELEM > v)

template<class ELEM>

ELEM max (const VectorBase< ELEM > v)

template<class ELEM>

ELEM max (const RowVectorBase< ELEM > v)

template<class ELEM>

RowVectorBase< ELEM > max (const MatrixBase< ELEM > v)

template<int N, class ELEM>

ELEM max (Vec< N, ELEM > v)

template<int N, class ELEM>

ELEM max (const Row< N, ELEM > v)

template<int M, int N, class ELEM>

Row< N, ELEM > max (const Mat< M, N, ELEM > v)

template<int N, class ELEM>

Row< N, ELEM > max (const SymMat< N, ELEM > v)

template<class ELEM>

ELEM mean (const VectorBase< ELEM > v)

template<class ELEM>

ELEM mean (const RowVectorBase< ELEM > v)

template<class ELEM>

RowVectorBase< ELEM > mean (const MatrixBase< ELEM > v)

template<int N, class ELEM>

ELEM mean (const Vec< N, ELEM > v)

template<int N, class ELEM>

ELEM mean (const Row< N, ELEM > v)

template<int M, int N, class ELEM>

Row< N, ELEM > mean (const Mat< M, N, ELEM > v)

template<int N, class ELEM>

Row< N, ELEM > mean (const SymMat< N, ELEM > v)

template<class ELEM>

VectorBase< ELEM > sort (const VectorBase< ELEM > v)

template<class ELEM>

RowVectorBase< ELEM > sort (const RowVectorBase< ELEM > v)

template<class ELEM>

MatrixBase< ELEM > sort (const MatrixBase< ELEM > v)

template<int N, class ELEM>

Vec< N, ELEM > sort (Vec< N, ELEM > v)

template<int N, class ELEM>

Row< N, ELEM > sort (Row< N, ELEM > v)

template<int M, int N, class ELEM>

Mat< M, N, ELEM > sort (Mat< M, N, ELEM > v)

template<int N, class ELEM>

Mat< N, N, ELEM > sort (const SymMat< N, ELEM > v)

template<class ELEM, class RandomAccessIterator>

ELEM median (RandomAccessIterator start, RandomAccessIterator end)

template<class ELEM>

ELEM median (const VectorBase< ELEM > v)

template<class ELEM>

ELEM median (const RowVectorBase< ELEM > v)

template<class ELEM>

RowVectorBase< ELEM > median (const MatrixBase< ELEM > v)

template<int N, class ELEM>

ELEM median (Vec< N, ELEM > v)

template<int N, class ELEM>

ELEM median (Row< N, ELEM > v)

template<int M, int N, class ELEM>

Row< N, ELEM > median (const Mat< M, N, ELEM > v)

template<int N, class ELEM>

Row< N, ELEM > median (const SymMat< N, ELEM > v)

template<>

void Lapack::gemm< std::complex< float > > (char transa, char transb, int m, int n, int k, const std::complex< float > &alpha, const std::complex< float > a[], int lda, const std::complex< float > b[], int ldb, const std::complex< float > &beta, std::complex< float > c[], int ldc)

template<>

void Lapack::gemm< std::complex< double > > (char transa, char transb, int m, int n, int k, const std::complex< double > &alpha, const std::complex< double > a[], int lda, const std::complex< double > b[], int ldb, const std::complex< double > &beta, std::complex< double > c[], int ldc)

Inertia operator+ (const Inertia &l, const Inertia &r)

Inertia operator- (const Inertia &l, const Inertia &r)

Inertia operator * (const Inertia &i, const Real &r)

Inertia operator * (const Real &r, const Inertia &i)

Vec3 operator * (const Inertia &i, const Vec3 &w)

Inertia operator/ (const Inertia &i, const Real &r)

bool operator== (const Inertia &i1, const Inertia &i2)

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

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

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

template<int S>

UnitVec< 1 > operator * (const Rotation &R, const UnitVec< S > &v)

template<int S>

UnitRow< 1 > operator * (const UnitRow< S > &r, const Rotation &R)

template<int S>

UnitVec< 1 > operator * (const InverseRotation &R, const UnitVec< S > &v)

template<int S>

UnitRow< 1 > operator * (const UnitRow< S > &r, const InverseRotation &R)

Rotation operator * (const Rotation &R1, const Rotation &R2)

Rotation operator * (const Rotation &R1, const InverseRotation &R2)

Rotation operator * (const InverseRotation &R1, const Rotation &R2)

Rotation operator * (const InverseRotation &R1, const InverseRotation &R2)

Rotation operator/ (const Rotation &R1, const Rotation &R2)

Rotation operator/ (const Rotation &R1, const InverseRotation &R2)

Rotation operator/ (const InverseRotation &R1, const Rotation &R2)

Rotation operator/ (const InverseRotation &R1, const InverseRotation &R2)

PhiMatrixTranspose transpose (const PhiMatrix &phi)

PhiMatrixTranspose operator~ (const PhiMatrix &phi)

SpatialVec operator * (const PhiMatrix &phi, const SpatialVec &v)

SpatialMat operator * (const PhiMatrix &phi, const SpatialMat &m)

SpatialVec operator * (const PhiMatrixTranspose &phiT, const SpatialVec &v)

SpatialMat operator * (const SpatialMat::THerm &m, const PhiMatrixTranspose &phiT)

SpatialMat operator * (const SpatialMat &m, const PhiMatrixTranspose &phiT)

bool operator== (const PhiMatrix &p1, const PhiMatrix &p2)

bool operator== (const PhiMatrixTranspose &p1, const PhiMatrixTranspose &p2)

Vec3 operator * (const Transform &X_BF, const Vec3 &s_F)

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

Vec3 operator * (const InverseTransform &X_BF, const Vec3 &s_F)

Vec4 operator * (const Transform &X_BF, const Vec4 &a_F)

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

Vec4 operator * (const InverseTransform &X_BF, const Vec4 &a_F)

Transform operator * (const Transform &X1, const Transform &X2)

Transform operator * (const Transform &X1, const InverseTransform &X2)

Transform operator * (const InverseTransform &X1, const Transform &X2)

Transform operator * (const InverseTransform &X1, const InverseTransform &X2)

bool operator== (const Transform &X1, const Transform &X2)

bool operator== (const InverseTransform &X1, const InverseTransform &X2)

bool operator== (const Transform &X1, const InverseTransform &X2)

bool operator== (const InverseTransform &X1, const Transform &X2)

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

complex< float > operator * (const complex< float > &c, int r)

complex< float > operator * (int r, const complex< float > &c)

complex< double > operator * (const complex< float > &c, const double &r)

complex< double > operator * (const double &r, const complex< float > &c)

complex< long double > operator * (const complex< float > &c, const long double &r)

complex< long double > operator * (const long double &r, const complex< float > &c)

complex< float > operator/ (const complex< float > &c, int r)

complex< float > operator/ (int r, const complex< float > &c)

complex< double > operator/ (const complex< float > &c, const double &r)

complex< double > operator/ (const double &r, const complex< float > &c)

complex< long double > operator/ (const complex< float > &c, const long double &r)

complex< long double > operator/ (const long double &r, const complex< float > &c)

complex< float > operator+ (const complex< float > &c, int r)

complex< float > operator+ (int r, const complex< float > &c)

complex< double > operator+ (const complex< float > &c, const double &r)

complex< double > operator+ (const double &r, const complex< float > &c)

complex< long double > operator+ (const complex< float > &c, const long double &r)

complex< long double > operator+ (const long double &r, const complex< float > &c)

complex< float > operator- (const complex< float > &c, int r)

complex< float > operator- (int r, const complex< float > &c)

complex< double > operator- (const complex< float > &c, const double &r)

complex< double > operator- (const double &r, const complex< float > &c)

complex< long double > operator- (const complex< float > &c, const long double &r)

complex< long double > operator- (const long double &r, const complex< float > &c)

complex< double > operator * (const complex< double > &c, int r)

complex< double > operator * (int r, const complex< double > &c)

complex< double > operator * (const complex< double > &c, const float &r)

complex< double > operator * (const float &r, const complex< double > &c)

complex< long double > operator * (const complex< double > &c, const long double &r)

complex< long double > operator * (const long double &r, const complex< double > &c)

complex< double > operator/ (const complex< double > &c, int r)

complex< double > operator/ (int r, const complex< double > &c)

complex< double > operator/ (const complex< double > &c, const float &r)

complex< double > operator/ (const float &r, const complex< double > &c)

complex< long double > operator/ (const complex< double > &c, const long double &r)

complex< long double > operator/ (const long double &r, const complex< double > &c)

complex< double > operator+ (const complex< double > &c, int r)

complex< double > operator+ (int r, const complex< double > &c)

complex< double > operator+ (const complex< double > &c, const float &r)

complex< double > operator+ (const float &r, const complex< double > &c)

complex< long double > operator+ (const complex< double > &c, const long double &r)

complex< long double > operator+ (const long double &r, const complex< double > &c)

complex< double > operator- (const complex< double > &c, int r)

complex< double > operator- (int r, const complex< double > &c)

complex< double > operator- (const complex< double > &c, const float &r)

complex< double > operator- (const float &r, const complex< double > &c)

complex< long double > operator- (const complex< double > &c, const long double &r)

complex< long double > operator- (const long double &r, const complex< double > &c)

complex< long double > operator * (const complex< long double > &c, int r)

complex< long double > operator * (int r, const complex< long double > &c)

complex< long double > operator * (const complex< long double > &c, const float &r)

complex< long double > operator * (const float &r, const complex< long double > &c)

complex< long double > operator * (const complex< long double > &c, const double &r)

complex< long double > operator * (const double &r, const complex< long double > &c)

complex< long double > operator/ (const complex< long double > &c, int r)

complex< long double > operator/ (int r, const complex< long double > &c)

complex< long double > operator/ (const complex< long double > &c, const float &r)

complex< long double > operator/ (const float &r, const complex< long double > &c)

complex< long double > operator/ (const complex< long double > &c, const double &r)

complex< long double > operator/ (const double &r, const complex< long double > &c)

complex< long double > operator+ (const complex< long double > &c, int r)

complex< long double > operator+ (int r, const complex< long double > &c)

complex< long double > operator+ (const complex< long double > &c, const float &r)

complex< long double > operator+ (const float &r, const complex< long double > &c)

complex< long double > operator+ (const complex< long double > &c, const double &r)

complex< long double > operator+ (const double &r, const complex< long double > &c)

complex< long double > operator- (const complex< long double > &c, int r)

complex< long double > operator- (int r, const complex< long double > &c)

complex< long double > operator- (const complex< long double > &c, const float &r)

complex< long double > operator- (const float &r, const complex< long double > &c)

complex< long double > operator- (const complex< long double > &c, const double &r)

complex< long double > operator- (const double &r, const complex< long double > &c)

const float & real (const conjugate< float > &c)

const negator< float > & imag (const conjugate< float > &c)

const complex< float > & conj (const conjugate< float > &c)

float abs (const conjugate< float > &c)

float norm (const conjugate< float > &c)

const double & real (const conjugate< double > &c)

const negator< double > & imag (const conjugate< double > &c)

const complex< double > & conj (const conjugate< double > &c)

double abs (const conjugate< double > &c)

double norm (const conjugate< double > &c)

const long double & real (const conjugate< long double > &c)

const negator< long double > & imag (const conjugate< long double > &c)

const complex< long double > & conj (const conjugate< long double > &c)

long double abs (const conjugate< long double > &c)

long double norm (const conjugate< long double > &c)

template<class R, class CHAR, class TRAITS>

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

template<class R, class CHAR, class TRAITS>

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

template<class R>

conjugate< R > operator+ (const conjugate< R > &a, const float &b)

template<class R>

conjugate< long double > operator+ (const conjugate< R > &a, const long double &b)

template<class R>

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

template<class R>

conjugate< R > operator+ (const float &a, const conjugate< R > &b)

template<class R>

conjugate< long double > operator+ (const long double &a, const conjugate< R > &b)

template<class R>

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

template<class R>

conjugate< R > operator * (const conjugate< R > &a, const float &b)

template<class R>

conjugate< long double > operator * (const conjugate< R > &a, const long double &b)

template<class R>

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

template<class R>

conjugate< R > operator * (const float &a, const conjugate< R > &b)

template<class R>

conjugate< long double > operator * (const long double &a, const conjugate< R > &b)

template<class R>

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

template<class R>

bool operator== (const conjugate< R > &a, const float &b)

template<class R>

bool operator== (const conjugate< R > &a, const long double &b)

template<class R>

bool operator== (const conjugate< R > &a, const double &b)

template<class R>

bool operator== (const float &a, const conjugate< R > &b)

template<class R>

bool operator== (const long double &a, const conjugate< R > &b)

template<class R>

bool operator== (const double &a, const conjugate< R > &b)

template<class R>

bool operator!= (const conjugate< R > &a, const float &b)

template<class R>

bool operator!= (const conjugate< R > &a, const long double &b)

template<class R>

bool operator!= (const conjugate< R > &a, const double &b)

template<class R>

bool operator!= (const float &a, const conjugate< R > &b)

template<class R>

bool operator!= (const long double &a, const conjugate< R > &b)

template<class R>

bool operator!= (const double &a, const conjugate< R > &b)

template<class R>

conjugate< R > operator- (const conjugate< R > &a, const float &b)

template<class R>

conjugate< long double > operator- (const conjugate< R > &a, const long double &b)

template<class R>

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

template<class R>

complex< R > operator- (const float &a, const conjugate< R > &b)

template<class R>

complex< long double > operator- (const long double &a, const conjugate< R > &b)

template<class R>

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

template<class R>

conjugate< R > operator/ (const conjugate< R > &a, const float &b)

template<class R>

conjugate< long double > operator/ (const conjugate< R > &a, const long double &b)

template<class R>

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

template<class R>

complex< R > operator/ (const float &a, const conjugate< R > &b)

template<class R>

complex< long double > operator/ (const long double &a, const conjugate< R > &b)

template<class R>

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

template<class R, class S>

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

template<class R, class S>

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

template<class R, class S>

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

template<class R, class S>

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

template<class R, class S>

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

template<class R, class S>

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

template<class R, class S>

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

template<class R, class S>

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

template<class R, class S>

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

template<class R, class S>

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

template<class R, class S>

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

template<class R, class S>

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

template<class R, class S>

bool operator== (const conjugate< R > &a, const conjugate< S > &r)

template<class R, class S>

bool operator== (const conjugate< R > &a, const complex< S > &r)

template<class R, class S>

bool operator== (const complex< R > &a, const conjugate< S > &r)

template<class R, class S>

bool operator!= (const conjugate< R > &a, const conjugate< S > &r)

template<class R, class S>

bool operator!= (const conjugate< R > &a, const complex< S > &r)

template<class R, class S>

bool operator!= (const complex< R > &a, const conjugate< S > &r)

template<class A, class B>

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

template<class A, class B>

CNT< A >::template Result<
negator >::Add operator+ (const A &l, const negator &r)

template<class A, class B>

negator< A >::template Result<
negator >::Add operator+ (const negator< A > &l, const negator &r)

template<class A, class B>

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

template<class A, class B>

CNT< A >::template Result<
negator >::Sub operator- (const A &l, const negator &r)

template<class A, class B>

negator< A >::template Result<
negator >::Sub operator- (const negator< A > &l, const negator &r)

template<class A, class B>

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

template<class A, class B>

CNT< A >::template Result<
negator >::Mul operator * (const A &l, const negator &r)

template<class A, class B>

negator< A >::template Result<
negator >::Mul operator * (const negator< A > &l, const negator &r)

template<class A, class B>

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

template<class A, class B>

CNT< A >::template Result<
negator >::Dvd operator/ (const A &l, const negator &r)

template<class A, class B>

negator< A >::template Result<
negator >::Dvd operator/ (const negator< A > &l, const negator &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 &r)

template<class A, class B>

bool operator== (const negator< A > &l, const negator &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 &r)

template<class A, class B>

bool operator!= (const negator< A > &l, const negator &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)

SimTK_BNTCMPLX_SPEC (float, float)

SimTK_BNTCMPLX_SPEC (float, double)

SimTK_BNTCMPLX_SPEC (float, long double)

SimTK_BNTCMPLX_SPEC (double, float)

SimTK_BNTCMPLX_SPEC (double, double)

SimTK_BNTCMPLX_SPEC (double, long double)

SimTK_BNTCMPLX_SPEC (long double, float)

SimTK_BNTCMPLX_SPEC (long double, double)

SimTK_BNTCMPLX_SPEC (long double, long double)

SimTK_NTRAITS_CONJ_SPEC (float, float)

SimTK_NTRAITS_CONJ_SPEC (float, double)

SimTK_NTRAITS_CONJ_SPEC (float, long double)

SimTK_NTRAITS_CONJ_SPEC (double, float)

SimTK_NTRAITS_CONJ_SPEC (double, double)

SimTK_NTRAITS_CONJ_SPEC (double, long double)

SimTK_NTRAITS_CONJ_SPEC (long double, float)

SimTK_NTRAITS_CONJ_SPEC (long double, double)

SimTK_NTRAITS_CONJ_SPEC (long double, long double)

SimTK_DEFINE_REAL_NTRAITS (float)

SimTK_DEFINE_REAL_NTRAITS (double)

SimTK_DEFINE_REAL_NTRAITS (long double)

bool 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 canStoreInNonnegativeInt (char c)

bool canStoreInNonnegativeInt (unsigned char c)

bool canStoreInNonnegativeInt (signed char c)

bool canStoreInNonnegativeInt (short s)

bool canStoreInNonnegativeInt (unsigned short s)

bool canStoreInNonnegativeInt (int i)

bool canStoreInNonnegativeInt (long l)

bool canStoreInNonnegativeInt (unsigned int u)

bool canStoreInNonnegativeInt (unsigned long u)

bool isNaN (const float &x)

isNaN(x) provides a reliable way to determine if x is one of the "not a number" floating point forms.

bool isNaN (const double &x)

bool isNaN (const long double &x)

template<class P>

bool isNaN (const std::complex &x)

template<class P>

bool isNaN (const conjugate &x)

bool isNaN (const negator< float > &x)

bool isNaN (const negator< double > &x)

bool isNaN (const negator< long double > &x)

template<class P>

bool isNaN (const negator< std::complex > &x)

template<class P>

bool isNaN (const negator< conjugate > &x)

unsigned int sign (unsigned char u)

s=sign(n) returns int -1,0,1 according to n<0, n==0, n>0 for any integer or real numeric type, unsigned 0 or 1 for any unsigned argument.

unsigned int sign (unsigned short u)

unsigned int sign (unsigned int u)

unsigned int sign (unsigned long u)

int sign (signed char i)

int sign (short i)

int sign (int i)

int sign (long i)

int sign (const float &x)

int sign (const double &x)

int sign (const long double &x)

int sign (const negator< float > &x)

int sign (const negator< double > &x)

int sign (const negator< long double > &x)

unsigned char square (unsigned char u)

y=square(x) returns the square of the argument for any numeric type.

unsigned short square (unsigned short u)

unsigned int square (unsigned int u)

unsigned long square (unsigned long u)

char square (char c)

signed char square (signed char i)

short square (short i)

int square (int i)

long square (long i)

float square (const float &x)

double square (const double &x)

long double square (const long double &x)

float square (const negator< float > &x)

double square (const negator< double > &x)

long double square (const negator< long double > &x)

template<class P>

std::complex square (const std::complex &x)

template<class P>

std::complex square (const conjugate &x)

template<class P>

std::complex square (const negator< std::complex > &x)

template<class P>

std::complex square (const negator< conjugate > &x)

unsigned char cube (unsigned char u)

y=cube(x) returns the cube of the argument for any numeric type, integral or floating point.

unsigned short cube (unsigned short u)

unsigned int cube (unsigned int u)

unsigned long cube (unsigned long u)

char cube (char c)

signed char cube (signed char i)

short cube (short i)

int cube (int i)

long cube (long i)

float cube (const float &x)

double cube (const double &x)

long double cube (const long double &x)

negator< float > cube (const negator< float > &x)

negator< double > cube (const negator< double > &x)

negator< long double > cube (const negator< long double > &x)

template<class P>

std::complex cube (const std::complex &x)

template<class P>

std::complex cube (const negator< std::complex > &x)

std::ostream & operator<< (std::ostream &o, Stage g)

SimTK_DEFINE_UNIQUE_INDEX_TYPE (SubsystemIndex) class DiscreteVariable

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

SimTK_DEFINE_UNIQUE_INDEX_TYPE (EventId) class System

The handle class which serves as the abstract parent of all Systems.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

bool operator== (const Row< N, E1, S1 > &l, const Row< N, E2, S2 > &r)

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

bool operator!= (const Row< N, E1, S1 > &l, const Row< N, E2, S2 > &r)

template<int N, class E, int S>

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

template<int N, class E, int S>

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

template<int N, class E, int S>

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

template<int N, class E, int S>

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

template<int N, class E, int S>

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

template<int N, class E, int S>

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

template<int N, class E, int S>

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

template<int N, class E, int S>

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

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

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

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

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

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

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

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

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

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

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

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

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

template<int N, class E, int S>

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

template<int N, class E, int S>

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

template<int N, class E, int S>

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

template<int N, class E, int S>

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

template<int N, class E, int S>

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

template<int N, class E, int S>

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

template<int N, class E, int S>

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

template<int N, class E, int S>

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

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

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

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

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

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

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

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

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

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

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

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

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

template<int N, class E, int S>

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

template<int N, class E, int S>

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

template<int N, class E, int S>

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

template<int N, class E, int S>

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

template<int N, class E, int S>

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

template<int N, class E, int S>

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

template<int N, class E, int S>

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

template<int N, class E, int S>

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

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

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

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

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

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

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

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

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

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

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

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

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

template<int N, class E, int S>

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

template<int N, class E, int S>

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

template<int N, class E, int S>

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

template<int N, class E, int S>

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

template<int N, class E, int S>

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

template<int N, class E, int S>

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

template<int N, class E, int S>

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

template<int N, class E, int S>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

template<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<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 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, 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)

template<class E, int S>

Mat< 3, 3, E > crossMat (const Row< 3, E, S > &r)

template<class E, int S>

Row< 2, E > crossMat (const Vec< 2, E, S > &v)

template<class E, int S>

Row< 2, E > crossMat (const Row< 2, E, S > &r)

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

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

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

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

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

bool operator== (const SymMat< M, E1, S1 > &l, const SymMat< M, E2, S2 > &r)

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

bool operator!= (const SymMat< M, E1, S1 > &l, const SymMat< M, E2, S2 > &r)

template<int M, class E, int S>

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

template<int M, class E, int S>

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

template<int M, class E, int S>

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

template<int M, class E, int S>

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

template<int M, class E, int S>

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

template<int M, class E, int S>

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

template<int M, class E, int S>

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

template<int M, class E, int S>

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

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

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

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

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

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

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

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

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

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

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

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

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

template<int M, class E, int S>

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

template<int M, class E, int S>

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

template<int M, class E, int S>

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

template<int M, class E, int S>

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

template<int M, class E, int S>

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

template<int M, class E, int S>

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

template<int M, class E, int S>

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

template<int M, class E, int S>

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

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

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

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

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

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

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

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

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

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

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

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

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

template<int M, class E, int S>

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

template<int M, class E, int S>

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

template<int M, class E, int S>

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

template<int M, class E, int S>

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

template<int M, class E, int S>

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

template<int M, class E, int S>

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

template<int M, class E, int S>

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

template<int M, class E, int S>

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

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

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

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

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

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

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

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

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

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

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

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

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

template<int M, class E, int S>

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

template<int M, class E, int S>

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

template<int M, class E, int S>

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

template<int M, class E, int S>

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

template<int M, class E, int S>

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

template<int M, class E, int S>

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

template<int M, class E, int S>

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

template<int M, class E, int S>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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)

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)

template<int M, class E, int S>

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

template<int M, class E, int S>

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

template<int M, class E, int S>

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

template<int M, class E, int S>

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

template<int M, class E, int S>

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

template<int M, class E, int S>

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

template<int M, class E, int S>

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

template<int M, class E, int S>

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

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

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

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

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

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

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

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

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

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

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

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

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

template<int M, class E, int S>

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

template<int M, class E, int S>

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

template<int M, class E, int S>

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

template<int M, class E, int S>

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

template<int M, class E, int S>

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

template<int M, class E, int S>

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

template<int M, class E, int S>

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

template<int M, class E, int S>

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

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

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

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

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

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

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

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

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

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

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

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

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

template<int M, class E, int S>

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

template<int M, class E, int S>

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

template<int M, class E, int S>

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

template<int M, class E, int S>

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

template<int M, class E, int S>

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

template<int M, class E, int S>

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

template<int M, class E, int S>

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

template<int M, class E, int S>

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

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

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

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

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

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

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

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

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

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

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

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

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

template<int M, class E, int S>

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

template<int M, class E, int S>

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

template<int M, class E, int S>

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

template<int M, class E, int S>

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

template<int M, class E, int S>

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

template<int M, class E, int S>

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

template<int M, class E, int S>

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

template<int M, class E, int S>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Typedef Documentation

typedef Vector_<Real> Vector

typedef Vector_<Complex> ComplexVector

typedef VectorView_<Real> VectorView

typedef VectorView_<Complex> ComplexVectorView

typedef RowVector_<Real> RowVector

typedef RowVector_<Complex> ComplexRowVector

typedef RowVectorView_<Real> RowVectorView

typedef RowVectorView_<Complex> ComplexRowVectorView

typedef Matrix_<Real> Matrix

typedef Matrix_<Complex> ComplexMatrix

typedef MatrixView_<Real> MatrixView

typedef MatrixView_<Complex> ComplexMatrixView

typedef Mat<2,2, Mat33> SpatialMat

typedef Vec<2, Vec3> SpatialVec

typedef Row<2, Row3> SpatialRow

typedef Mat<2,2, Mat33> SpatialMat

typedef Vec<2, Vec3> SpatialVec

typedef Row<2, Row3> SpatialRow

typedef Mat<2,2, Mat33> SpatialMat

typedef UnitVec<1> UnitVec3

typedef conjugate<Real> Conjugate

typedef Vec<1> Vec1

typedef Vec<2> Vec2

typedef Vec<3> Vec3

typedef Vec<4> Vec4

typedef Vec<5> Vec5

typedef Vec<6> Vec6

typedef Vec<7> Vec7

typedef Vec<8> Vec8

typedef Vec<9> Vec9

typedef Row<1> Row1

typedef Row<2> Row2

typedef Row<3> Row3

typedef Row<4> Row4

typedef Row<5> Row5

typedef Row<6> Row6

typedef Row<7> Row7

typedef Row<8> Row8

typedef Row<9> Row9

typedef SymMat<1> SymMat11

typedef SymMat<2> SymMat22

typedef SymMat<3> SymMat33

typedef SymMat<4> SymMat44

typedef SymMat<5> SymMat55

typedef SymMat<6> SymMat66

typedef SymMat<7> SymMat77

typedef SymMat<8> SymMat88

typedef SymMat<9> SymMat99

typedef Mat<1,1> Mat11

typedef Mat<1,2> Mat12

typedef Mat<1,3> Mat13

typedef Mat<1,4> Mat14

typedef Mat<1,5> Mat15

typedef Mat<1,6> Mat16

typedef Mat<1,7> Mat17

typedef Mat<1,8> Mat18

typedef Mat<1,9> Mat19

typedef Mat<2,1> Mat21

typedef Mat<2,2> Mat22

typedef Mat<2,3> Mat23

typedef Mat<2,4> Mat24

typedef Mat<2,5> Mat25

typedef Mat<2,6> Mat26

typedef Mat<2,7> Mat27

typedef Mat<2,8> Mat28

typedef Mat<2,9> Mat29

typedef Mat<3,1> Mat31

typedef Mat<3,2> Mat32

typedef Mat<3,3> Mat33

typedef Mat<3,4> Mat34

typedef Mat<3,5> Mat35

typedef Mat<3,6> Mat36

typedef Mat<3,7> Mat37

typedef Mat<3,8> Mat38

typedef Mat<3,9> Mat39

typedef Mat<4,1> Mat41

typedef Mat<4,2> Mat42

typedef Mat<4,3> Mat43

typedef Mat<4,4> Mat44

typedef Mat<4,5> Mat45

typedef Mat<4,6> Mat46

typedef Mat<4,7> Mat47

typedef Mat<4,8> Mat48

typedef Mat<4,9> Mat49

typedef Mat<5,1> Mat51

typedef Mat<5,2> Mat52

typedef Mat<5,3> Mat53

typedef Mat<5,4> Mat54

typedef Mat<5,5> Mat55

typedef Mat<5,6> Mat56

typedef Mat<5,7> Mat57

typedef Mat<5,8> Mat58

typedef Mat<5,9> Mat59

typedef Mat<6,1> Mat61

typedef Mat<6,2> Mat62

typedef Mat<6,3> Mat63

typedef Mat<6,4> Mat64

typedef Mat<6,5> Mat65

typedef Mat<6,6> Mat66

typedef Mat<6,7> Mat67

typedef Mat<6,8> Mat68

typedef Mat<6,9> Mat69

typedef Mat<7,1> Mat71

typedef Mat<7,2> Mat72

typedef Mat<7,3> Mat73

typedef Mat<7,4> Mat74

typedef Mat<7,5> Mat75

typedef Mat<7,6> Mat76

typedef Mat<7,7> Mat77

typedef Mat<7,8> Mat78

typedef Mat<7,9> Mat79

typedef Mat<8,1> Mat81

typedef Mat<8,2> Mat82

typedef Mat<8,3> Mat83

typedef Mat<8,4> Mat84

typedef Mat<8,5> Mat85

typedef Mat<8,6> Mat86

typedef Mat<8,7> Mat87

typedef Mat<8,8> Mat88

typedef Mat<8,9> Mat89

typedef Mat<9,1> Mat91

typedef Mat<9,2> Mat92

typedef Mat<9,3> Mat93

typedef Mat<9,4> Mat94

typedef Mat<9,5> Mat95

typedef Mat<9,6> Mat96

typedef Mat<9,7> Mat97

typedef Mat<9,8> Mat98

typedef Mat<9,9> Mat99

Enumeration Type Documentation

enum BodyOrSpaceType

Enumerator:

BodyRotationSequence
SpaceRotationSequence

anonymous enum

Enumerator:

SCALAR_DEPTH
SCALAR_COMPOSITE_DEPTH
COMPOSITE_COMPOSITE_DEPTH
COMPOSITE_3_DEPTH
MAX_RESOLVED_DEPTH

Function Documentation

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

The index is returned if found, otherwise -1.

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

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

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

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

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

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

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

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

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

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

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

SimTK::SimTK_LIST_SPECIALIZE ( bool )

SimTK::SimTK_LIST_SPECIALIZE ( signed char )

SimTK::SimTK_LIST_SPECIALIZE ( char )

SimTK_LIST_SPECIALIZE ( unsigned char )

SimTK::SimTK_LIST_SPECIALIZE ( short )

SimTK::SimTK_LIST_SPECIALIZE ( int )

SimTK_LIST_SPECIALIZE ( long )

SimTK::SimTK_LIST_SPECIALIZE ( float )

SimTK::SimTK_LIST_SPECIALIZE ( double )

SimTK::SimTK_LIST_SPECIALIZE ( std::complex< float > )

SimTK::SimTK_LIST_SPECIALIZE ( std::complex< double > )

SimTK::SimTK_LIST_SPECIALIZE ( std::complex< long double > )

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

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

The index is returned if found, otherwise -1.

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

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

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

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

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

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

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

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

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

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

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

VectorBase<typename CNT<ELEM>::TAbs> SimTK::abs ( const VectorBase< ELEM > v )

RowVectorBase<typename CNT<ELEM>::TAbs> SimTK::abs ( const RowVectorBase< ELEM > v )

MatrixBase<typename CNT<ELEM>::TAbs> SimTK::abs ( const MatrixBase< ELEM > v )

Vec<N, typename CNT<ELEM>::TAbs> SimTK::abs ( const Vec< N, ELEM > v )

Row<N, typename CNT<ELEM>::TAbs> SimTK::abs ( const Row< N, ELEM > v )

Mat<M, N, typename CNT<ELEM>::TAbs> SimTK::abs ( const Mat< M, N, ELEM > v )

SymMat<N, typename CNT<ELEM>::TAbs> SimTK::abs ( const SymMat< N, ELEM > v )

ELEM SimTK::sum ( const VectorBase< ELEM > v )

ELEM SimTK::sum ( const RowVectorBase< ELEM > v )

RowVectorBase<ELEM> SimTK::sum ( const MatrixBase< ELEM > v )

ELEM SimTK::sum ( const Vec< N, ELEM > v )

ELEM SimTK::sum ( const Row< N, ELEM > v )

Row<N, ELEM> SimTK::sum ( const Mat< M, N, ELEM > v )

Row<N, ELEM> SimTK::sum ( const SymMat< N, ELEM > v )

ELEM SimTK::min ( const VectorBase< ELEM > v )

ELEM SimTK::min ( const RowVectorBase< ELEM > v )

RowVectorBase<ELEM> SimTK::min ( const MatrixBase< ELEM > v )

ELEM SimTK::min ( const Vec< N, ELEM > v )

ELEM SimTK::min ( Row< N, ELEM > v )

Row<N, ELEM> SimTK::min ( const Mat< M, N, ELEM > v )

Row<N, ELEM> SimTK::min ( SymMat< N, ELEM > v )

ELEM SimTK::max ( const VectorBase< ELEM > v )

ELEM SimTK::max ( const RowVectorBase< ELEM > v )

RowVectorBase<ELEM> SimTK::max ( const MatrixBase< ELEM > v )

ELEM SimTK::max ( Vec< N, ELEM > v )

ELEM SimTK::max ( const Row< N, ELEM > v )

Row<N, ELEM> SimTK::max ( const Mat< M, N, ELEM > v )

Row<N, ELEM> SimTK::max ( const SymMat< N, ELEM > v )

ELEM SimTK::mean ( const VectorBase< ELEM > v )

ELEM SimTK::mean ( const RowVectorBase< ELEM > v )

RowVectorBase<ELEM> SimTK::mean ( const MatrixBase< ELEM > v )

ELEM SimTK::mean ( const Vec< N, ELEM > v )

ELEM SimTK::mean ( const Row< N, ELEM > v )

Row<N, ELEM> SimTK::mean ( const Mat< M, N, ELEM > v )

Row<N, ELEM> SimTK::mean ( const SymMat< N, ELEM > v )

VectorBase<ELEM> SimTK::sort ( const VectorBase< ELEM > v )

RowVectorBase<ELEM> SimTK::sort ( const RowVectorBase< ELEM > v )

MatrixBase<ELEM> SimTK::sort ( const MatrixBase< ELEM > v )

Vec<N, ELEM> SimTK::sort ( Vec< N, ELEM > v )

Row<N, ELEM> SimTK::sort ( Row< N, ELEM > v )

Mat<M, N, ELEM> SimTK::sort ( Mat< M, N, ELEM > v )

Mat<N, N, ELEM> SimTK::sort ( const SymMat< N, ELEM > v )

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

ELEM SimTK::median ( const VectorBase< ELEM > v )

ELEM SimTK::median ( const RowVectorBase< ELEM > v )

RowVectorBase<ELEM> SimTK::median ( const MatrixBase< ELEM > v )

ELEM SimTK::median ( Vec< N, ELEM > v )

ELEM SimTK::median ( Row< N, ELEM > v )

Row<N, ELEM> SimTK::median ( const Mat< M, N, ELEM > v )

Row<N, ELEM> SimTK::median ( const SymMat< N, ELEM > v )

void SimTK::Lapack::gemm< std::complex< float > >	(	char	transa,
		char	transb,
		int	m,
		int	n,
		int	k,
		const std::complex< float > &	alpha,
		const std::complex< float >	a[],
		int	lda,
		const std::complex< float >	b[],
		int	ldb,
		const std::complex< float > &	beta,
		std::complex< float >	c[],
		int	ldc
	)			`[inline]`

void SimTK::Lapack::gemm< std::complex< double > >	(	char	transa,
		char	transb,
		int	m,
		int	n,
		int	k,
		const std::complex< double > &	alpha,
		const std::complex< double >	a[],
		int	lda,
		const std::complex< double >	b[],
		int	ldb,
		const std::complex< double > &	beta,
		std::complex< double >	c[],
		int	ldc
	)			`[inline]`

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

PhiMatrixTranspose SimTK::transpose ( const PhiMatrix & phi ) [inline]

PhiMatrixTranspose SimTK::operator~ ( const PhiMatrix & phi ) [inline]

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

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

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

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

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

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

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

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

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

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

Vec4 SimTK::operator *	(	const Transform &	X_BF,
		const Vec4 &	a_F
	)			`[inline]`

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

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

Vec4 SimTK::operator *	(	const InverseTransform &	X_BF,
		const Vec4 &	a_F
	)			`[inline]`

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