SimTK Namespace Reference

Detailed Description

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

This file defines a large number of standard math functions that can be applied to vectors and matrices (both the large matrix and small matrix classes).

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 DecorativeMesh

This defines a polygonal mesh. More...

class DecorativeGeometryImplementation

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

class PolygonalMesh

This class provides a description of a mesh made of polygonal faces. More...

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 AtomicInteger

This class functions exactly like an int, except that the following operators are atomic: ++, --, +=, -=, *=, /=, =, &=, |=, ^=, <<=, and >>=. More...

class Concretize

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

class Enumeration

This class defines an enumerated type. More...

class EnumerationSet

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

class 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 Parallel2DExecutor

This class is used for performing multithreaded computations over two dimensional ranges. More...

class ParallelExecutor

This class is used for performing multithreaded computations. More...

class PIMPLHandle

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

class PIMPLImplementation

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

class StableArray

StableArray<T> is like std::vector<T> 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 ThreadLocal

This class represents a "thread local" variable: one which has a different value on each thread. 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...

class N_VectorContent_SimTK

class N_Vector_Ops_SimTK

class N_Vector_SimTK

class CPodesSystem

This abstract class defines the system to be integrated with SimTK CPodes. More...

class CPodes

This is a straightforward translation of the Sundials CPODES C interface into C++. More...

class Differentiator

Given a function f(y), where f, y or both can be vectors, calculate the derivative (gradient, Jacobian) df/dy. More...

class Function

This abstract class represents a mathematical function that calculates an N component vector based on M real arguments. More...

class GCVSPLUtil

This class provides entry points for using the GCVSPL algorithm in terms of SimTK data types. More...

class Spline

This class implements a non-uniform B-spline curve. More...

class SplineFitter

Given a set of data points, this class creates a Spline which interpolates or approximates them. More...

class Factor

Abstract class for performing matrix factorizations. More...

class FactorLU

Class for performing LU matrix factorizations. More...

class FactorQTZ

Class to perform a QTZ (linear least squares) factorization. More...

class Eigen

Class to compute Eigen values and Eigen vectors of a matrix. More...

class FactorSVD

Class to compute a singular value decomposition of a matrix. More...

class OptimizerSystem

Abstract class which defines an objective/cost function which is optimized by and Optimizer object. More...

class Optimizer

API for Simmath's optimizers. More...

class CPodesIntegrator

This is an Integrator based on the CPODES library. More...

class ExplicitEulerIntegrator

This is an Integrator based on the explicit Euler algorithm. More...

class Integrator

An Integrator is an object that can simulate the behavior of a System through time. More...

class RungeKuttaFeldbergIntegrator

class RungeKuttaMersonIntegrator

class TimeStepper

This class uses an Integrator to advance a System through time. More...

class VerletIntegrator

This is an Integrator based on the velocity Verlet algorithm. More...

class VTKEventReporter

This is an EventReporter that makes it easy to generate on-screen movies of any simulation. More...

class VTKVisualizer

class Body

class CollisionDetectionAlgorithm

A CollisionDetectionAlgorithm implements an algorithm for detecting overlaps between pairs of ContactGeometry objects, and creating Contact objects based on them. More...

class Constraint

This is the base class for all Constraint classes, which is just a handle for the underlying hidden implementation. More...

class Contact

A Contact contains information about two bodies that are in contact with each other. More...

class PointContact

This subclass of Contact represents a symmetric contact centered at a single point, such as between two spheres or a sphere and a half space. More...

class TriangleMeshContact

This subclass of Contact is used when one or both of the ContactGeometry objects is a TriangleMesh. More...

class ContactGeometry

A ContactGeometry object describes the physical shape of a body. More...

class ContactGeometryImpl

class OBBTreeNodeImpl

class ContactImpl

This is the internal implementation class for Contact. More...

class PointContactImpl

This is the internal implementation class for PointContact. More...

class TriangleMeshContactImpl

This is the internal implementation class for TriangleMeshContact. More...

class DecorationSubsystem

This is the client-side handle class encapsulating the hidden implementation of the DecorationSubsystem. More...

class ElasticFoundationForce

class Force

A Force object applies forces to the bodies in a system. More...

class ForceSubsystem

This is logically an abstract class, more specialized than "Subsystem" but not yet concrete. More...

class GeneralContactSubsystem

This class performs collision detection for use in contact modeling. More...

class GeneralForceSubsystem

This is a concrete subsystem which can apply arbitrary forces to a MultibodySystem. More...

class HuntCrossleyContact

This is a concrete subsystem that handles simple, frictionless contact situations with a model due to Hunt & Crossley: K. More...

class HuntCrossleyForce

class LocalEnergyMinimizer

This class performs local energy minimization of a MultibodySystem. More...

class MobilizedBody

This is the base class for all MobilizedBody classes, just a handle for the underlying hidden implementation. More...

class MultibodySystem

The job of the MultibodySystem class is to coordinate the activities of various subsystems which can be part of a multibody system. More...

class MultibodyDynamicsStudy

class MechanicalDAEIntegrator

This interface is to be implemented whenever you want to treat your mechanical system as a DAE to be solved with coordinate projection. More...

class CPodesMultibodySystem

class OLDCPodesIntegrator

class OLDExplicitEuler

class OLDRungeKuttaMerson

class ObservedPointFitter

This class attempts to find the configuration of an internal coordinate model which best fits a set of observed data. More...

class OrientedBoundingBox

This class represents a rectangular box with arbitrary position and orientation. More...

class SimbodyMatterSubsystem

The Simbody low-level multibody tree interface. More...

class SimbodyMatterSubtree

A SimbodyMatterSubtree is a view of a connected subgraph of the tree of mobilized bodies in a SimbodyMatterSubsystem. More...

class SimbodyMatterSubtreeResults

class TextDataEventReporter

This is an EventReporter which prints out numeric data at regular intervals in tabular form. More...

class Biotype

class Clonable

class Compound

The base class for atoms, molecules, and chemical groups. More...

class UnivalentAtom

Base class for atoms with exaclty one covalent bond partner. More...

class BivalentAtom

Base class for atoms having exactly two covalent bonds. More...

class TrivalentAtom

Base class for atoms having exactly three covalent bonds. More...

class QuadrivalentAtom

Base class for atoms having exactly four covalent bonds. More...

class AliphaticHydrogen

AliphaticHydrogen is a hydrogen atom for bonding to AliphaticCarbon atoms (see below). More...

class AliphaticCarbon

AliphaticCarbon is a tetrahedral sp3 carbon atom for bonding to four other things. More...

class MethyleneGroup

MethyleneGroup is -CH2- group for bonding to aliphatic carbon and a second something. More...

class MethylGroup

MethylGroup is CH3 for attaching to aliphatic carbon. More...

class AromaticSixMemberedCHGroup

Two atom C-H group in six membered aromatic rings. More...

class AlcoholOHGroup

AlcoholOHGroup is OH group for attachment to aliphatic carbon. More...

class PrimaryAmineGroup

PrimaryAmineGroup is NH3⁺ for attachment to tetrahedral carbon. More...

class CarboxylateGroup

CaboxylateGroup is COO^- for attachment to tetrahedral carbon. More...

class Molecule

Base class for complete covalently connected molecules. More...

class Argon

The noble gas argon, which does not bond with other atoms. More...

class Methane

The simplest hydrocarbon methane, CH₄. More...

class Ethane

The small hydrocarbon ethane, C₂H₆, which has a single torsion degree of freedom. More...

class BiopolymerResidue

class Biopolymer

The base class for DNA, RNA, and Protein molecules. More...

class CompoundSystem

Derived class of MolecularMechanicsSystem that knows how to model molmodel Compounds. More...

class DuMMForceFieldSubsystem

This is a concrete subsystem that provides basic molecular mechanics functionality FOR DEMO AND PROOF OF CONCEPT only!!! It is not likely to perform well on anything. More...

class Amber99ForceSubsystem

class Element

class GrinPointer

class LithiumIon

Li⁺ lithium ion with +1 charge. More...

class SodiumIon

Na⁺ sodium ion with +1 charge. More...

class PotassiumIon

K⁺ potassium ion with +1 charge. More...

class RubidiumIon

Rb⁺ rubidium ion with +1 charge. More...

class CesiumIon

Cs⁺ cesium ion with +1 charge. More...

class MagnesiumIon

Mg²⁺ magnesium ion with +2 charge. More...

class CalciumIon

Ca²⁺ calcium ion with +2 charge. More...

class ZincIon

Zn²⁺ zinc ion with +2 charge. More...

class ChlorideIon

Cl^- chloride ion with -1 charge. More...

class LigandDroplet

class P12

class MolecularMechanicsSystem

This is a particular kind of MultibodySystem, one intended for use in moleular mechanics (MM). More...

class PdbResidueId

Composite key for residue within a chain, composed of residue number and insertion code. More...

class PdbAtomLocation

Location information for a PdbAtom, corresponding to one altLoc for a PdbAtom. More...

class PdbAtom

One atom, which may have more than one location, in the case of static or dynamic disorder in an X-ray structure. More...

class PdbResidue

One residue in a protein or nucleic acid, or a single molecule in the case of non-polymer structures. More...

class PdbChain

One molecule in a PDB structure. More...

class PdbModel

PDB structure containing one or more molecules (chains), corresponding to one member of an NMR ensemble of alternate structures, or to one frame of a molecular dynamics simulation. More...

class PdbStructure

Complete PDB file, possibly including multiple MODELS, in the case of NMR structures or molecular dynamics trajectories. More...

class PDBReader

This class parses PDB files, then constructs Systems and States based on them for use in Simbody. More...

class PeriodicPdbWriter

Writes atomic coordinates in PDB format to a file stream at specified intervals during a simulation. More...

class PeriodicVmdReporter

Writes atomic coordinates in PDB format to a file stream at specified intervals during a simulation. More...

class AcetylResidue

Widely used acetyl protein N-terminal end cap. More...

class NMethylAmideResidue

Neutral C-terminal protein cap. More...

class AminoAcidResidue

amino acid residue building block for protein polypeptide chain molecules More...

class HNAminoAcidResidue

AminoAcidResidue differs from HNAminoAcidResidue in lacking "HN" proton, so Proline can be derived. More...

class BetaUnbranchedAminoAcidResidue

class BetaBranchedAminoAcidResidue

class Protein

class ZeroFunction

Function f(x) = 0 for all x. More...

class SinusoidFunction

Implements a simple functional relationship, y = amplitude * sin(x - phase). More...

class PseudorotationMobilizer

class RiboseNu3Mobilizer

class RiboseCore

class FivePrimeRnaHydroxylGroup

Phosphate group at 5' end (beginning) of RNA. More...

class FivePrimeRnaPhosphateGroup

Phosphate group at 5' end (beginning) of RNA. More...

class RnaPhosphodiesterLinkage

class ThreePrimeRnaHydroxylGroup

Phosphate group at 3' end (beginning) of RNA. More...

class ThreePrimeRnaPhosphateGroup

Phosphate group at 3' end (end) of RNA. More...

class RibonucleosideResidue

class RibonucleotideResidue

class PurineBaseCore

class AdenineBase

class GuanineBase

class TwoNMethylGuanineBaseGroup

class PyrimidineBaseCore

class CytosineBase

class UracilBase

class TwoNMethylGuanidineGroup

class RNA

class Vec3Pair

Matched pair of 3D vectors to be used in least-squares superposition. More...

class TransformAndResidual

class Kabsch78

class VanderWallSphere

class VelocityRescalingThermostat

This is an event handler that acts as a thermostat for controlling the temperature of a simulation. More...

class VoxelIndex

class Voxel

class Water

class WaterDroplet

Namespaces

namespace BondMobility

Namespace for description of allowed bond motions.

namespace DuMM

namespace Exception

namespace Impl

namespace mdunits

namespace Ordinality

namespace Pdb

namespace System

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

typedef ForceSubsystem::Guts ForceSubsystemRep

typedef DuMMForceFieldSubsystem TinkerDuMMForceFieldSubsystem

typedef Real Angle

angle in radians

typedef Real LineAngle

typedef Real CircleAngle

typedef Real WindingAngle

Enumerations

enum BodyOrSpaceType { BodyRotationSequence = 0, SpaceRotationSequence = 1 }

enum {
 SCALAR_DEPTH = 0, SCALAR_COMPOSITE_DEPTH = 1, COMPOSITE_COMPOSITE_DEPTH = 2, COMPOSITE_3_DEPTH = 3,
 MAX_RESOLVED_DEPTH = COMPOSITE_3_DEPTH
}

enum OptimizerAlgorithm {
 BestAvailiable = 0, InteriorPoint = 1, LBFGS = 2, LBFGSB = 3,
 CFSQP = 4
}

Functions

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)

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

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)

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)

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

This is a class to represent unique IDs for events in a type-safe way.

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<class E1, int S1, class E2, int S2>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

SimTK_DEFINE_UNIQUE_INDEX_TYPE (MobilizedBodyIndex) static const MobilizedBodyIndex GroundIndex(0)

SimTK_DEFINE_UNIQUE_INDEX_TYPE (ConstraintIndex) SimTK_DEFINE_UNIQUE_INDEX_TYPE(ParticleIndex) SimTK_DEFINE_UNIQUE_INDEX_TYPE(AncestorConstrainedBodyPoolIndex) SimTK_DEFINE_UNIQUE_INDEX_TYPE(QIndex) SimTK_DEFINE_UNIQUE_INDEX_TYPE(UIndex) SimTK_DEFINE_UNIQUE_INDEX_TYPE(USquaredIndex) SimTK_DEFINE_UNIQUE_INDEX_TYPE(QuaternionPoolIndex) SimTK_DEFINE_UNIQUE_INDEX_TYPE(AnglePoolIndex) SimTK_DEFINE_UNIQUE_INDEX_TYPE(MobilizerQIndex) SimTK_DEFINE_UNIQUE_INDEX_TYPE(MobilizerUIndex) SimTK_DEFINE_UNIQUE_INDEX_TYPE(ConstrainedBodyIndex) SimTK_DEFINE_UNIQUE_INDEX_TYPE(ConstrainedMobilizerIndex) SimTK_DEFINE_UNIQUE_INDEX_TYPE(ConstrainedQIndex) SimTK_DEFINE_UNIQUE_INDEX_TYPE(ConstrainedUIndex) SimTK_DEFINE_UNIQUE_INDEX_TYPE(ParticipatingQIndex) SimTK_DEFINE_UNIQUE_INDEX_TYPE(ParticipatingUIndex) SimTK_DEFINE_UNIQUE_INDEX_TYPE(SubtreeBodyIndex) static const SubtreeBodyIndex SubtreeAncestorIndex(0)

SimTK_DEFINE_UNIQUE_INDEX_TYPE (SubtreeQIndex) SimTK_DEFINE_UNIQUE_INDEX_TYPE(SubtreeUIndex) SimTK_DEFINE_UNIQUE_INDEX_TYPE(ForceIndex) SimTK_DEFINE_UNIQUE_INDEX_TYPE(ContactSetIndex) namespace Exception

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

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

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

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

SimTK_DEFINE_AND_EXPORT_UNIQUE_INDEX_TYPE (, BiotypeIndex)

SimTK_DEFINE_AND_EXPORT_UNIQUE_INDEX_TYPE (, TinkerBiotypeIndex)

Angle calcDihedralAngle (const Vec3 &atomPos1, const Vec3 &atomPos2, const Vec3 &atomPos3, const Vec3 &atomPos4)

Dihedral angle in radians in the range (-Pi, Pi].

Angle calcDihedralAngle (const UnitVec3 &bond12, const UnitVec3 &bond23, const UnitVec3 &bond34)

Dihedral angle in radians in the range (-Pi, Pi].

std::ostream & operator<< (std::ostream &o, const Compound &c)

Dump debugging information about compound structure to a stream.

std::ostream & operator<< (std::ostream &, const Element &)

template<class PointeeType>

PointeeType * deepCopy (const PointeeType *ptr, const void *)

template<class PointeeType>

PointeeType * deepCopy (const PointeeType *ptr, const Clonable *)

template<class PointeeType>

PointeeType * deepCopy (const PointeeType *ptr)

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.

Typedef Documentation

typedef Real Angle

angle in radians

typedef Real CircleAngle

typedef Matrix_<Complex> ComplexMatrix

typedef MatrixView_<Complex> ComplexMatrixView

typedef RowVector_<Complex> ComplexRowVector

typedef RowVectorView_<Complex> ComplexRowVectorView

typedef Vector_<Complex> ComplexVector

typedef VectorView_<Complex> ComplexVectorView

typedef conjugate<Real> Conjugate

typedef ForceSubsystem::Guts ForceSubsystemRep

typedef Real LineAngle

typedef Mat<1,1> Mat11

typedef Mat<1,2> Mat12

typedef Mat<1,3> Mat13

typedef Mat<1,4> Mat14

typedef Mat<1,5> Mat15

typedef Mat<1,6> Mat16

typedef Mat<1,7> Mat17

typedef Mat<1,8> Mat18

typedef Mat<1,9> Mat19

typedef Mat<2,1> Mat21

typedef Mat<2,2> Mat22

typedef Mat<2,3> Mat23

typedef Mat<2,4> Mat24

typedef Mat<2,5> Mat25

typedef Mat<2,6> Mat26

typedef Mat<2,7> Mat27

typedef Mat<2,8> Mat28

typedef Mat<2,9> Mat29

typedef Mat<3,1> Mat31

typedef Mat<3,2> Mat32

typedef Mat<3,3> Mat33

typedef Mat<3,4> Mat34

typedef Mat<3,5> Mat35

typedef Mat<3,6> Mat36

typedef Mat<3,7> Mat37

typedef Mat<3,8> Mat38

typedef Mat<3,9> Mat39

typedef Mat<4,1> Mat41

typedef Mat<4,2> Mat42

typedef Mat<4,3> Mat43

typedef Mat<4,4> Mat44

typedef Mat<4,5> Mat45

typedef Mat<4,6> Mat46

typedef Mat<4,7> Mat47

typedef Mat<4,8> Mat48

typedef Mat<4,9> Mat49

typedef Mat<5,1> Mat51

typedef Mat<5,2> Mat52

typedef Mat<5,3> Mat53

typedef Mat<5,4> Mat54

typedef Mat<5,5> Mat55

typedef Mat<5,6> Mat56

typedef Mat<5,7> Mat57

typedef Mat<5,8> Mat58

typedef Mat<5,9> Mat59

typedef Mat<6,1> Mat61

typedef Mat<6,2> Mat62

typedef Mat<6,3> Mat63

typedef Mat<6,4> Mat64

typedef Mat<6,5> Mat65

typedef Mat<6,6> Mat66

typedef Mat<6,7> Mat67

typedef Mat<6,8> Mat68

typedef Mat<6,9> Mat69

typedef Mat<7,1> Mat71

typedef Mat<7,2> Mat72

typedef Mat<7,3> Mat73

typedef Mat<7,4> Mat74

typedef Mat<7,5> Mat75

typedef Mat<7,6> Mat76

typedef Mat<7,7> Mat77

typedef Mat<7,8> Mat78

typedef Mat<7,9> Mat79

typedef Mat<8,1> Mat81

typedef Mat<8,2> Mat82

typedef Mat<8,3> Mat83

typedef Mat<8,4> Mat84

typedef Mat<8,5> Mat85

typedef Mat<8,6> Mat86

typedef Mat<8,7> Mat87

typedef Mat<8,8> Mat88

typedef Mat<8,9> Mat89

typedef Mat<9,1> Mat91

typedef Mat<9,2> Mat92

typedef Mat<9,3> Mat93

typedef Mat<9,4> Mat94

typedef Mat<9,5> Mat95

typedef Mat<9,6> Mat96

typedef Mat<9,7> Mat97

typedef Mat<9,8> Mat98

typedef Mat<9,9> Mat99

typedef Matrix_<Real> Matrix

typedef MatrixView_<Real> MatrixView

typedef Row<1> Row1

typedef Row<2> Row2

typedef Row<3> Row3

typedef Row<4> Row4

typedef Row<5> Row5

typedef Row<6> Row6

typedef Row<7> Row7

typedef Row<8> Row8

typedef Row<9> Row9

typedef RowVector_<Real> RowVector

typedef RowVectorView_<Real> RowVectorView

typedef Mat< 2, 2, Mat33 > SpatialMat

typedef Row< 2, Row3 > SpatialRow

typedef Vec< 2, Vec3 > SpatialVec

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 DuMMForceFieldSubsystem TinkerDuMMForceFieldSubsystem

typedef UnitVec<1> UnitVec3

typedef Vec<1> Vec1

typedef Vec<2> Vec2

typedef Vec<3> Vec3

typedef Vec<4> Vec4

typedef Vec<5> Vec5

typedef Vec<6> Vec6

typedef Vec<7> Vec7

typedef Vec<8> Vec8

typedef Vec<9> Vec9

typedef Vector_<Real> Vector

typedef VectorView_<Real> VectorView

typedef Real WindingAngle

Enumeration Type Documentation

anonymous enum

Enumerator:

SCALAR_DEPTH
SCALAR_COMPOSITE_DEPTH
COMPOSITE_COMPOSITE_DEPTH
COMPOSITE_3_DEPTH
MAX_RESOLVED_DEPTH

enum BodyOrSpaceType

Enumerator:

BodyRotationSequence
SpaceRotationSequence

enum OptimizerAlgorithm

Enumerator:

BestAvailiable
InteriorPoint
LBFGS
LBFGSB
CFSQP

Function Documentation

long double SimTK::abs ( const conjugate< long double > & c ) [inline]

Referenced by Vec< 3, Real, S >::abs(), Row< 3, Real, S >::abs(), NTraits< conjugate< R > >::abs(), NTraits< complex< R > >::abs(), negator::abs(), abs(), RowVectorBase::abs(), VectorBase< SimTK::Vec< N > >::abs(), MatrixBase< SimTK::Vec< N > >::abs(), main(), SimTK_DEFINE_UNIQUE_INDEX_TYPE(), and Kabsch78::superpose().

double SimTK::abs ( const conjugate< double > & c ) [inline]

References abs().

float SimTK::abs ( const conjugate< float > & c ) [inline]

References abs().

SymMat<N, typename CNT<ELEM>::TAbs> SimTK::abs ( const SymMat< N, ELEM > v ) [inline]

References SymMat::abs().

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

References Mat::abs().

Row<N, typename CNT<ELEM>::TAbs> SimTK::abs ( const Row< N, ELEM > v ) [inline]

References Row::abs().

Vec<N, typename CNT<ELEM>::TAbs> SimTK::abs ( const Vec< N, ELEM > v ) [inline]

References Vec::abs().

MatrixBase<typename CNT<ELEM>::TAbs> SimTK::abs ( const MatrixBase< ELEM > v ) [inline]

References MatrixBase::abs().

RowVectorBase<typename CNT<ELEM>::TAbs> SimTK::abs ( const RowVectorBase< ELEM > v ) [inline]

References RowVectorBase::abs().

VectorBase<typename CNT<ELEM>::TAbs> SimTK::abs ( const VectorBase< ELEM > v ) [inline]

References VectorBase::abs().

Referenced by NTraits< conjugate< R > >::normalize(), and NTraits< complex< R > >::normalize().

Angle SimTK::calcDihedralAngle	(	const UnitVec3 &	bond12,
		const UnitVec3 &	bond23,
		const UnitVec3 &	bond34
	)

Dihedral angle in radians in the range (-Pi, Pi].

Angle SimTK::calcDihedralAngle	(	const Vec3 &	atomPos1,
		const Vec3 &	atomPos2,
		const Vec3 &	atomPos3,
		const Vec3 &	atomPos4
	)

Dihedral angle in radians in the range (-Pi, Pi].

bool SimTK::canStoreInInt ( unsigned long u ) [inline]

bool SimTK::canStoreInInt ( long i ) [inline]

bool SimTK::canStoreInInt ( unsigned int u ) [inline]

bool SimTK::canStoreInInt ( int ) [inline]

bool SimTK::canStoreInInt ( short ) [inline]

bool SimTK::canStoreInInt ( signed char ) [inline]

bool canStoreInInt ( unsigned char ) [inline]

bool SimTK::canStoreInInt ( char ) [inline]

Referenced by canStoreInNonnegativeInt().

bool SimTK::canStoreInNonnegativeInt ( unsigned long u ) [inline]

References canStoreInInt().

bool SimTK::canStoreInNonnegativeInt ( unsigned int u ) [inline]

References canStoreInInt().

bool SimTK::canStoreInNonnegativeInt ( long l ) [inline]

References canStoreInInt().

bool SimTK::canStoreInNonnegativeInt ( int i ) [inline]

bool SimTK::canStoreInNonnegativeInt ( unsigned short s ) [inline]

bool SimTK::canStoreInNonnegativeInt ( short s ) [inline]

bool SimTK::canStoreInNonnegativeInt ( signed char c ) [inline]

bool SimTK::canStoreInNonnegativeInt ( unsigned char c ) [inline]

bool SimTK::canStoreInNonnegativeInt ( char c ) [inline]

const complex<long double>& SimTK::conj ( const conjugate< long double > & c ) [inline]

Referenced by operator/(), conjugate< float >::operator/=(), conjugate< double >::operator/=(), and conjugate< long double >::operator/=().

const complex<double>& SimTK::conj ( const conjugate< double > & c ) [inline]

const complex<float>& SimTK::conj ( const conjugate< float > & c ) [inline]

Referenced by conjugate< float >::operator/=(), conjugate< double >::operator/=(), and conjugate< long double >::operator/=().

bool SimTK::contains	(	const ListView< T > &	lv,
		const T &	test
	)			`[inline]`

References contains().

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.

References findFirstOf().

bool SimTK::contains	(	const ArrayView< T > &	a,
		const T &	test
	)			`[inline]`

References findFirstOf().

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.

References findFirstOf().

Referenced by contains().

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

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

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

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

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

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

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

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

Referenced by operator%(), and Kabsch78::superpose().

Row<2,E> SimTK::crossMat ( const Row< 2, E, S > & r ) [inline]

References crossMat(), and Row::positionalTranspose().

Row<2,E> SimTK::crossMat ( const Vec< 2, E, S > & v ) [inline]

Mat<3,3,E> SimTK::crossMat ( const Row< 3, E, S > & r ) [inline]

References crossMat(), and Row::positionalTranspose().

Mat<3,3,E> SimTK::crossMat ( const Vec< 3, E, S > & v ) [inline]

References E.

Referenced by crossMat(), and operator*().

std::complex SimTK::cube ( const negator< std::complex > & x ) [inline]

References fkinkryx_p::ii, imag(), real(), and x.

std::complex SimTK::cube ( const std::complex & x ) [inline]

References fkinkryx_p::ii.

negator<long double> SimTK::cube ( const negator< long double > & x ) [inline]

References cube().

negator<double> SimTK::cube ( const negator< double > & x ) [inline]

References cube().

negator<float> SimTK::cube ( const negator< float > & x ) [inline]

References cube().

long double SimTK::cube ( const long double & x ) [inline]

double SimTK::cube ( const double & x ) [inline]

float SimTK::cube ( const float & x ) [inline]

long SimTK::cube ( long i ) [inline]

int SimTK::cube ( int i ) [inline]

short SimTK::cube ( short i ) [inline]

signed char SimTK::cube ( signed char i ) [inline]

char SimTK::cube ( char c ) [inline]

unsigned long SimTK::cube ( unsigned long u ) [inline]

unsigned int SimTK::cube ( unsigned int u ) [inline]

unsigned short SimTK::cube ( unsigned short u ) [inline]

unsigned char SimTK::cube ( unsigned char u ) [inline]

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

We promise to evaluate x only once. We assume is is acceptable for the result type to be the same as the argument type; if it won't fit caller must cast argument to a wider type first. This is an inline routine which will run as fast as explicit multiplies (x*x*x) in optimized code, and even faster for complex types.

Referenced by cube().

PointeeType* SimTK::deepCopy ( const PointeeType * ptr ) [inline]

References deepCopy().

PointeeType* SimTK::deepCopy	(	const PointeeType *	ptr,
		const Clonable *
	)			`[inline]`

PointeeType* SimTK::deepCopy	(	const PointeeType *	ptr,
		const void *
	)			`[inline]`

Referenced by deepCopy().

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

References dot(), and Row::positionalTranspose().

Referenced by CompoundVector::DotImpl().

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

References dot(), and Row::positionalTranspose().

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

References dot(), and Row::positionalTranspose().

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

References sum().

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

References sum().

Referenced by MobilizedBody::calcStationToStationDistance2ndTimeDerivative(), MobilizedBody::calcStationToStationDistanceTimeDerivative(), dot(), QuadrivalentAtom::QuadrivalentAtom(), and Kabsch78::superpose().

Array<int> SimTK::findAllOf	(	const ListView< T > &	lv,
		const T &	test
	)			`[inline]`

References findAllOf().

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.

References fkinkryx::i, ArrayBase::push_back(), and ArrayBase::size().

Array<int> SimTK::findAllOf	(	const ArrayView< T > &	a,
		const T &	test
	)			`[inline]`

References findAllOf().

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.

References fkinkryx::i, ArrayBase::push_back(), and ArrayBase::size().

Referenced by findAllOf().

int SimTK::findFirstOf	(	const ListView< T > &	lv,
		const T &	test
	)			`[inline]`

References findFirstOf().

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.

References fkinkryx::i, and ArrayBase::size().

int SimTK::findFirstOf	(	const ArrayView< T > &	a,
		const T &	test
	)			`[inline]`

References findFirstOf().

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.

References fkinkryx::i, and ArrayBase::size().

Referenced by contains(), and findFirstOf().

const negator<long double>& SimTK::imag ( const conjugate< long double > & c ) [inline]

Referenced by negator::imag().

const negator<double>& SimTK::imag ( const conjugate< double > & c ) [inline]

const negator<float>& SimTK::imag ( const conjugate< float > & c ) [inline]

Referenced by cube().

bool SimTK::isNaN ( const negator< conjugate > & x ) [inline]

References isNaN(), and x.

bool SimTK::isNaN ( const negator< std::complex > & x ) [inline]

References isNaN(), and x.

bool SimTK::isNaN ( const negator< long double > & x ) [inline]

References isNaN().

bool SimTK::isNaN ( const negator< double > & x ) [inline]

References isNaN().

bool SimTK::isNaN ( const negator< float > & x ) [inline]

References isNaN().

bool SimTK::isNaN ( const conjugate & x ) [inline]

References isNaN().

bool SimTK::isNaN ( const std::complex & x ) [inline]

References isNaN().

bool SimTK::isNaN ( const long double & x ) [inline]

bool SimTK::isNaN ( const double & x ) [inline]

bool SimTK::isNaN ( const float & x ) [inline]

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

Comparing x==NaN does not work because any relational operation involving NaN always return false, even (NaN==NaN)! We use this latter fact to detect NaN since no other floating point values have that property. This routine is specialized for all SimTK scalar types: float, double, long double, std::complex, SimTK::conjugate, and SimTK::negator<T>, where T is any of the above. For complex and conjugate types, isNaN() returns true if either the real or imaginary part or both are NaN.

Referenced by isNaN().

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]`

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]`

Row<N, ELEM> SimTK::max ( const SymMat< N, ELEM > v ) [inline]

References SymMat::getDiag(), SymMat::getEltLower(), and fkinkryx::i.

Referenced by CompoundVector::AmaxImpl(), IpoptCalculatedQuantities::CalcCentralityMeasure(), Spline::getMaxDerivativeOrder(), Function::Polynomial::getMaxDerivativeOrder(), Function::Linear::getMaxDerivativeOrder(), Function::Constant::getMaxDerivativeOrder(), Ipopt::Max(), DenseVector::MaxImpl(), CompoundVector::MaxImpl(), CompoundVector::MinImpl(), TaggedObject::ObjectChanged(), RowVectorBase::size(), VectorBase< SimTK::Vec< N > >::size(), OLDRungeKuttaMerson::step(), and OLDExplicitEuler::step().

Row<N, ELEM> SimTK::max ( const Mat< M, N, ELEM > v ) [inline]

References fkinkryx::i, and max().

ELEM SimTK::max ( const Row< N, ELEM > v ) [inline]

References fkinkryx::i, and max().

ELEM SimTK::max ( Vec< N, ELEM > v ) [inline]

References fkinkryx::i, and max().

RowVectorBase<ELEM> SimTK::max ( const MatrixBase< ELEM > v ) [inline]

References fkinkryx::i, max(), and MatrixBase::ncol().

ELEM SimTK::max ( const RowVectorBase< ELEM > v ) [inline]

References fkinkryx::i, max(), RowVectorBase::size(), and fkinkryx_p::size.

ELEM SimTK::max ( const VectorBase< ELEM > v ) [inline]

References fkinkryx::i, VectorBase::size(), and fkinkryx_p::size.

Referenced by max().

Row<N, ELEM> SimTK::mean ( const SymMat< N, ELEM > v ) [inline]

References sum().

Row<N, ELEM> SimTK::mean ( const Mat< M, N, ELEM > v ) [inline]

References sum().

ELEM SimTK::mean ( const Row< N, ELEM > v ) [inline]

References sum().

ELEM SimTK::mean ( const Vec< N, ELEM > v ) [inline]

References sum().

RowVectorBase<ELEM> SimTK::mean ( const MatrixBase< ELEM > v ) [inline]

References MatrixBase::nrow(), and sum().

ELEM SimTK::mean ( const RowVectorBase< ELEM > v ) [inline]

References RowVectorBase::size(), and sum().

ELEM SimTK::mean ( const VectorBase< ELEM > v ) [inline]

References VectorBase::size(), and sum().

Row<N, ELEM> SimTK::median ( const SymMat< N, ELEM > v ) [inline]

References median().

Row<N, ELEM> SimTK::median ( const Mat< M, N, ELEM > v ) [inline]

References fkinkryx::i, and median().

ELEM SimTK::median ( Row< N, ELEM > v ) [inline]

ELEM SimTK::median ( Vec< N, ELEM > v ) [inline]

RowVectorBase<ELEM> SimTK::median ( const MatrixBase< ELEM > v ) [inline]

References MatrixBase::col(), fkinkryx::i, MatrixBase::ncol(), and MatrixBase::nrow().

ELEM SimTK::median ( const RowVectorBase< ELEM > v ) [inline]

References RowVectorBase::begin(), and RowVectorBase::end().

ELEM SimTK::median ( const VectorBase< ELEM > v ) [inline]

References VectorBase::begin(), and VectorBase::end().

ELEM SimTK::median	(	RandomAccessIterator	start,
		RandomAccessIterator	end
	)			`[inline]`

References min(), and fkinkryx_p::size.

Referenced by median().

Row<N, ELEM> SimTK::min ( SymMat< N, ELEM > v ) [inline]

References SymMat::getDiag(), SymMat::getEltLower(), and fkinkryx::i.

Referenced by Ipopt::Min(), DenseVector::MinImpl(), CompoundVector::MinImpl(), DefaultIterateInitializer::push_variables(), OLDRungeKuttaMerson::step(), and OLDExplicitEuler::step().

Row<N, ELEM> SimTK::min ( const Mat< M, N, ELEM > v ) [inline]

References fkinkryx::i, and min().

ELEM SimTK::min ( Row< N, ELEM > v ) [inline]

References fkinkryx::i, and min().

ELEM SimTK::min ( const Vec< N, ELEM > v ) [inline]

References fkinkryx::i, and min().

RowVectorBase<ELEM> SimTK::min ( const MatrixBase< ELEM > v ) [inline]

References fkinkryx::i, min(), and MatrixBase::ncol().

ELEM SimTK::min ( const RowVectorBase< ELEM > v ) [inline]

References fkinkryx::i, min(), RowVectorBase::size(), and fkinkryx_p::size.

ELEM SimTK::min ( const VectorBase< ELEM > v ) [inline]

References fkinkryx::i, VectorBase::size(), and fkinkryx_p::size.

Referenced by median(), and min().

long double SimTK::norm ( const conjugate< long double > & c ) [inline]

Referenced by norm(), Quaternion::normalizeThis(), UnitRow::UnitRow(), and UnitVec< 1 >::UnitVec().

double SimTK::norm ( const conjugate< double > & c ) [inline]

References norm().

float SimTK::norm ( const conjugate< float > & c ) [inline]

References norm().

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

References cross().

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

References cross().

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

References cross().

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

References cross().

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

References cross().

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

References cross().

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

References cross().

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

References cross().

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

References fkinkryx::i, and m.

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

References fkinkryx::i.

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

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

References sum().

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

References sum().

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Transform SimTK::operator*	(	const InverseTransform &	X1,
		const InverseTransform &	X2
	)			`[inline]`

References InverseTransform::compose().

Transform SimTK::operator*	(	const InverseTransform &	X1,
		const Transform &	X2
	)			`[inline]`

References InverseTransform::compose().

Transform SimTK::operator*	(	const Transform &	X1,
		const InverseTransform &	X2
	)			`[inline]`

References Transform::compose().

Transform SimTK::operator*	(	const Transform &	X1,
		const Transform &	X2
	)			`[inline]`

References Transform::compose().

Mat<M,N,E> SimTK::operator*	(	const Mat< M, N, E > &	v,
		const Transform &	T
	)			`[inline]`