Simbody
Classes | Public Types | Public Member Functions | Static Public Member Functions

SimTK::Mat< M, N, ELT, CS, RS > Class Template Reference

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

#include <Mat.h>

Inheritance diagram for SimTK::Mat< M, N, ELT, CS, RS >:

List of all members.

Classes

struct  EltResult
struct  Result
struct  SubMat
struct  Substitute

Public Types

enum  {
  NRows = M, NCols = N, MinDim = N < M ? N : M, MaxDim = N > M ? N : M,
  RowSpacing = RS, ColSpacing = CS, NPackedElements = M * N, NActualElements = (N-1)*CS + (M-1)*RS + 1,
  NActualScalars = CNT<E>::NActualScalars * NActualElements, ImagOffset = NTraits<ENumber>::ImagOffset, RealStrideFactor = 1, ArgDepth,
  IsScalar = 0, IsULessScalar = 0, IsNumber = 0, IsStdNumber = 0,
  IsPrecision = 0, SignInterpretation = CNT<E>::SignInterpretation
}
typedef Mat< M, N, E, CS, RS > T
typedef Mat< M, N, ENeg, CS, RS > TNeg
typedef Mat< M, N,
EWithoutNegator, CS, RS > 		TWithoutNegator
typedef Mat< M, N, EReal, CS
*CNT< E >::RealStrideFactor,
RS *CNT< E >::RealStrideFactor > 		TReal
typedef Mat< M, N, EImag, CS
*CNT< E >::RealStrideFactor,
RS *CNT< E >::RealStrideFactor > 		TImag
typedef Mat< M, N, EComplex,
CS, RS > 		TComplex
typedef Mat< N, M, EHerm, RS, CS > THerm
typedef Mat< N, M, E, RS, CS > TPosTrans
typedef E TElement
typedef Row< N, E, CS > TRow
typedef Vec< M, E, RS > TCol
typedef Vec< MinDim, E, RS+CS > TDiag
typedef Mat< M, N, ESqrt, M, 1 > TSqrt
typedef Mat< M, N, EAbs, M, 1 > TAbs
typedef Mat< M, N, EStandard,
M, 1 > 		TStandard
typedef Mat< N, M, EInvert, N, 1 > TInvert
typedef Mat< M, N, ENormalize,
M, 1 > 		TNormalize
typedef SymMat< N, ESqHermT > TSqHermT
typedef SymMat< M, ESqTHerm > TSqTHerm
typedef Mat< M, N, E, M, 1 > TPacked
typedef Mat< M-1, N, E, M, 1 > TDropRow
typedef Mat< M, N-1, E, M, 1 > TDropCol
typedef Mat< M-1, N-1, E, M, 1 > TDropRowCol
typedef Mat< M+1, N, E, M, 1 > TAppendRow
typedef Mat< M, N+1, E, M, 1 > TAppendCol
typedef Mat< M+1, N+1, E, M, 1 > TAppendRowCol
typedef EScalar Scalar
typedef EULessScalar ULessScalar
typedef ENumber Number
typedef EStdNumber StdNumber
typedef EPrecision Precision
typedef EScalarNormSq ScalarNormSq
typedef THerm TransposeType

Public Member Functions

int size () const
int nrow () const
int ncol () const
ScalarNormSq scalarNormSqr () const
TSqrt sqrt () const
TAbs abs () const
TStandard standardize () const
 Mat ()
 Mat (const Mat &src)
Mat & operator= (const Mat &src)
 Mat (const SymMat< M, ELT > &src)
template<int CSS, int RSS>
 Mat (const Mat< M, N, E, CSS, RSS > &src)
template<int CSS, int RSS>
 Mat (const Mat< M, N, ENeg, CSS, RSS > &src)
template<class EE , int CSS, int RSS>
 Mat (const Mat< M, N, EE, CSS, RSS > &mm)
 Mat (const E &e)
 Mat (const ENeg &e)
 Mat (int i)
 Mat (const E &e0, const E &e1)
 Mat (const E &e0, const E &e1, const E &e2)
 Mat (const E &e0, const E &e1, const E &e2, const E &e3)
 Mat (const E &e0, const E &e1, const E &e2, const E &e3, const E &e4)
 Mat (const E &e0, const E &e1, const E &e2, const E &e3, const E &e4, const E &e5)
 Mat (const E &e0, const E &e1, const E &e2, const E &e3, const E &e4, const E &e5, const E &e6)
 Mat (const E &e0, const E &e1, const E &e2, const E &e3, const E &e4, const E &e5, const E &e6, const E &e7)
 Mat (const E &e0, const E &e1, const E &e2, const E &e3, const E &e4, const E &e5, const E &e6, const E &e7, const E &e8)
 Mat (const E &e0, const E &e1, const E &e2, const E &e3, const E &e4, const E &e5, const E &e6, const E &e7, const E &e8, const E &e9)
 Mat (const E &e0, const E &e1, const E &e2, const E &e3, const E &e4, const E &e5, const E &e6, const E &e7, const E &e8, const E &e9, const E &e10)
 Mat (const E &e0, const E &e1, const E &e2, const E &e3, const E &e4, const E &e5, const E &e6, const E &e7, const E &e8, const E &e9, const E &e10, const E &e11)
 Mat (const E &e0, const E &e1, const E &e2, const E &e3, const E &e4, const E &e5, const E &e6, const E &e7, const E &e8, const E &e9, const E &e10, const E &e11, const E &e12)
 Mat (const E &e0, const E &e1, const E &e2, const E &e3, const E &e4, const E &e5, const E &e6, const E &e7, const E &e8, const E &e9, const E &e10, const E &e11, const E &e12, const E &e13)
 Mat (const E &e0, const E &e1, const E &e2, const E &e3, const E &e4, const E &e5, const E &e6, const E &e7, const E &e8, const E &e9, const E &e10, const E &e11, const E &e12, const E &e13, const E &e14)
 Mat (const E &e0, const E &e1, const E &e2, const E &e3, const E &e4, const E &e5, const E &e6, const E &e7, const E &e8, const E &e9, const E &e10, const E &e11, const E &e12, const E &e13, const E &e14, const E &e15)
 Mat (const TRow &r0)
 Mat (const TRow &r0, const TRow &r1)
 Mat (const TRow &r0, const TRow &r1, const TRow &r2)
 Mat (const TRow &r0, const TRow &r1, const TRow &r2, const TRow &r3)
 Mat (const TRow &r0, const TRow &r1, const TRow &r2, const TRow &r3, const TRow &r4)
 Mat (const TRow &r0, const TRow &r1, const TRow &r2, const TRow &r3, const TRow &r4, const TRow &r5)
template<class EE , int SS>
 Mat (const Row< N, EE, SS > &r0)
template<class EE , int SS>
 Mat (const Row< N, EE, SS > &r0, const Row< N, EE, SS > &r1)
template<class EE , int SS>
 Mat (const Row< N, EE, SS > &r0, const Row< N, EE, SS > &r1, const Row< N, EE, SS > &r2)
template<class EE , int SS>
 Mat (const Row< N, EE, SS > &r0, const Row< N, EE, SS > &r1, const Row< N, EE, SS > &r2, const Row< N, EE, SS > &r3)
template<class EE , int SS>
 Mat (const Row< N, EE, SS > &r0, const Row< N, EE, SS > &r1, const Row< N, EE, SS > &r2, const Row< N, EE, SS > &r3, const Row< N, EE, SS > &r4)
template<class EE , int SS>
 Mat (const Row< N, EE, SS > &r0, const Row< N, EE, SS > &r1, const Row< N, EE, SS > &r2, const Row< N, EE, SS > &r3, const Row< N, EE, SS > &r4, const Row< N, EE, SS > &r5)
 Mat (const TCol &r0)
 Mat (const TCol &r0, const TCol &r1)
 Mat (const TCol &r0, const TCol &r1, const TCol &r2)
 Mat (const TCol &r0, const TCol &r1, const TCol &r2, const TCol &r3)
 Mat (const TCol &r0, const TCol &r1, const TCol &r2, const TCol &r3, const TCol &r4)
 Mat (const TCol &r0, const TCol &r1, const TCol &r2, const TCol &r3, const TCol &r4, const TCol &r5)
template<class EE , int SS>
 Mat (const Vec< M, EE, SS > &r0)
template<class EE , int SS>
 Mat (const Vec< M, EE, SS > &r0, const Vec< M, EE, SS > &r1)
template<class EE , int SS>
 Mat (const Vec< M, EE, SS > &r0, const Vec< M, EE, SS > &r1, const Vec< M, EE, SS > &r2)
template<class EE , int SS>
 Mat (const Vec< M, EE, SS > &r0, const Vec< M, EE, SS > &r1, const Vec< M, EE, SS > &r2, const Vec< M, EE, SS > &r3)
template<class EE , int SS>
 Mat (const Vec< M, EE, SS > &r0, const Vec< M, EE, SS > &r1, const Vec< M, EE, SS > &r2, const Vec< M, EE, SS > &r3, const Vec< M, EE, SS > &r4)
template<class EE , int SS>
 Mat (const Vec< M, EE, SS > &r0, const Vec< M, EE, SS > &r1, const Vec< M, EE, SS > &r2, const Vec< M, EE, SS > &r3, const Vec< M, EE, SS > &r4, const Vec< M, EE, SS > &r5)
template<class EE >
 Mat (const EE *p)
template<class EE , int CSS, int RSS>
Mat & operator= (const Mat< M, N, EE, CSS, RSS > &mm)
template<class EE >
Mat & operator= (const EE *p)
template<class EE , int CSS, int RSS>
Mat & operator+= (const Mat< M, N, EE, CSS, RSS > &mm)
template<class EE , int CSS, int RSS>
Mat & operator+= (const Mat< M, N, negator< EE >, CSS, RSS > &mm)
template<class EE , int CSS, int RSS>
Mat & operator-= (const Mat< M, N, EE, CSS, RSS > &mm)
template<class EE , int CSS, int RSS>
Mat & operator-= (const Mat< M, N, negator< EE >, CSS, RSS > &mm)
template<class EE , int CSS, int RSS>
Mat & operator*= (const Mat< N, N, EE, CSS, RSS > &mm)
template<class E2 , int CS2, int RS2>
Result< Mat< M, N, E2, CS2,
RS2 > >::Add 		conformingAdd (const Mat< M, N, E2, CS2, RS2 > &r) const
template<class E2 , int CS2, int RS2>
Result< Mat< M, N, E2, CS2,
RS2 > >::Sub 		conformingSubtract (const Mat< M, N, E2, CS2, RS2 > &r) const
template<class E2 , int CS2, int RS2>
Mat< M, N, E2, CS2, RS2 >
::template Result< Mat >::Sub 		conformingSubtractFromLeft (const Mat< M, N, E2, CS2, RS2 > &l) const
template<class E2 , int RS2>
Result< SymMat< M, E2, RS2 > >::Add conformingAdd (const SymMat< M, E2, RS2 > &sy) const
template<class E2 , int RS2>
Result< SymMat< M, E2, RS2 > >::Sub conformingSubtract (const SymMat< M, E2, RS2 > &sy) const
template<class E2 , int RS2>
SymMat< M, E2, RS2 >::template
Result< Mat >::Sub 		conformingSubtractFromLeft (const SymMat< M, E2, RS2 > &sy) const
template<int N2, class E2 , int CS2, int RS2>
Result< Mat< N, N2, E2, CS2,
RS2 > >::Mul 		conformingMultiply (const Mat< N, N2, E2, CS2, RS2 > &m) const
template<int M2, class E2 , int CS2, int RS2>
Mat< M2, M, E2, CS2, RS2 >
::template Result< Mat >::Mul 		conformingMultiplyFromLeft (const Mat< M2, M, E2, CS2, RS2 > &m) const
template<int M2, class E2 , int CS2, int RS2>
Result< Mat< M2, N, E2, CS2,
RS2 > >::Dvd 		conformingDivide (const Mat< M2, N, E2, CS2, RS2 > &m) const
template<int M2, class E2 , int CS2, int RS2>
Mat< M2, N, E2, CS2, RS2 >
::template Result< Mat >::Dvd 		conformingDivideFromLeft (const Mat< M2, N, E2, CS2, RS2 > &m) const
const TRow & operator[] (int i) const
TRow & operator[] (int i)
const TCol & operator() (int j) const
TCol & operator() (int j)
const E & operator() (int i, int j) const
E & operator() (int i, int j)
ScalarNormSq normSqr () const
CNT< ScalarNormSq >::TSqrt norm () const
TNormalize normalize () const
TInvert invert () const
const Mat & operator+ () const
const TNeg & operator- () const
TNeg & operator- ()
const THerm & operator~ () const
THerm & operator~ ()
const TNeg & negate () const
TNeg & updNegate ()
const THerm & transpose () const
THerm & updTranspose ()
const TPosTrans & positionalTranspose () const
TPosTrans & updPositionalTranspose ()
const TReal & real () const
TReal & real ()
const TImag & imag () const
TImag & imag ()
const TWithoutNegator & castAwayNegatorIfAny () const
TWithoutNegator & updCastAwayNegatorIfAny ()
const TRow & row (int i) const
TRow & row (int i)
const TCol & col (int j) const
TCol & col (int j)
const E & elt (int i, int j) const
E & elt (int i, int j)
const TDiag & diag () const
TDiag & diag ()
EStandard trace () const
template<class EE >
Mat< M, N, typename CNT< E >
::template Result< EE >::Mul > 		scalarMultiply (const EE &e) const
template<class EE >
Mat< M, N, typename CNT< EE >
::template Result< E >::Mul > 		scalarMultiplyFromLeft (const EE &e) const
template<class EE >
Mat< M, N, typename CNT< E >
::template Result< EE >::Dvd > 		scalarDivide (const EE &e) const
template<class EE >
Mat< M, N, typename CNT< EE >
::template Result< E >::Dvd > 		scalarDivideFromLeft (const EE &e) const
template<class EE >
Mat< M, N, typename CNT< E >
::template Result< EE >::Add > 		scalarAdd (const EE &e) const
template<class EE >
Mat< M, N, typename CNT< E >
::template Result< EE >::Sub > 		scalarSubtract (const EE &e) const
template<class EE >
Mat< M, N, typename CNT< EE >
::template Result< E >::Sub > 		scalarSubtractFromLeft (const EE &e) const
template<class EE >
Mat & operator= (const EE &e)
template<class EE >
Mat & operator+= (const EE &e)
template<class EE >
Mat & operator-= (const EE &e)
template<class EE >
Mat & operator*= (const EE &e)
template<class EE >
Mat & operator/= (const EE &e)
template<class EE >
Mat & scalarEq (const EE &ee)
template<class EE >
Mat & scalarPlusEq (const EE &ee)
template<class EE >
Mat & scalarMinusEq (const EE &ee)
template<class EE >
Mat & scalarMinusEqFromLeft (const EE &ee)
template<class EE >
Mat & scalarTimesEq (const EE &ee)
template<class EE >
Mat & scalarTimesEqFromLeft (const EE &ee)
template<class EE >
Mat & scalarDivideEq (const EE &ee)
template<class EE >
Mat & scalarDivideEqFromLeft (const EE &ee)
void setToNaN ()
void setToZero ()
template<int MM, int NN>
const SubMat< MM, NN >::Type & getSubMat (int i, int j) const
template<int MM, int NN>
SubMat< MM, NN >::Type & updSubMat (int i, int j)
template<int MM, int NN>
void setSubMat (int i, int j, const typename SubMat< MM, NN >::Type &value)
TDropRow dropRow (int i) const
 Return a matrix one row smaller than this one by dropping row i.
TDropCol dropCol (int j) const
 Return a matrix one column smaller than this one by dropping column j.
TDropRowCol dropRowCol (int i, int j) const
 Return a matrix one row and one column smaller than this one by dropping row i and column j.
template<class EE , int SS>
TAppendRow appendRow (const Row< N, EE, SS > &row) const
 Return a matrix one row larger than this one by adding a row to the end.
template<class EE , int SS>
TAppendCol appendCol (const Vec< M, EE, SS > &col) const
 Return a matrix one column larger than this one by adding a column to the end.
template<class ER , int SR, class EC , int SC>
TAppendRowCol appendRowCol (const Row< N+1, ER, SR > &row, const Vec< M+1, EC, SC > &col) const
 Return a matrix one row and one column larger than this one by adding a row to the bottom and a column to the right.
template<class EE , int SS>
TAppendRow insertRow (int i, const Row< N, EE, SS > &row) const
 Return a matrix one row larger than this one by inserting a row before* row i.
template<class EE , int SS>
TAppendCol insertCol (int j, const Vec< M, EE, SS > &col) const
 Return a matrix one column larger than this one by inserting a column before* column j.
template<class ER , int SR, class EC , int SC>
TAppendRowCol insertRowCol (int i, int j, const Row< N+1, ER, SR > &row, const Vec< M+1, EC, SC > &col) const
 Return a matrix one row and one column larger than this one by inserting a row *before* row i and a column *before* column j.
bool isNaN () const
 Return true if any element of this Mat contains a NaN anywhere.
bool isInf () const
 Return true if any element of this Mat contains a +Inf or -Inf somewhere but no element contains a NaN anywhere.
bool isFinite () const
 Return true if no element contains an Infinity or a NaN.
template<class E2 , int CS2, int RS2>
bool isNumericallyEqual (const Mat< M, N, E2, CS2, RS2 > &m, double tol) const
 Test whether this matrix is numerically equal to some other matrix with the same shape, using a specified tolerance.
template<class E2 , int CS2, int RS2>
bool isNumericallyEqual (const Mat< M, N, E2, CS2, RS2 > &m) const
 Test whether this matrix is numerically equal to some other matrix with the same shape, using a default tolerance which is the looser of the default tolerances of the two objects being compared.
bool isNumericallyEqual (const ELT &e, double tol=getDefaultTolerance()) const
 Test whether this is numerically a "scalar" matrix, meaning that it is a diagonal matrix in which each diagonal element is numerically equal to the same scalar, using either a specified tolerance or the matrix's default tolerance (which is always the same or looser than the default tolerance for one of its elements).
bool isNumericallySymmetric (double tol=getDefaultTolerance()) const
 A Matrix is symmetric (actually Hermitian) if it is square and each element (i,j) is the Hermitian transpose of element (j,i).
bool isExactlySymmetric () const
 A Matrix is symmetric (actually Hermitian) if it is square and each element (i,j) is the Hermitian (conjugate) transpose of element (j,i).
TRow sum () const

Static Public Member Functions

static const Mat & getAs (const ELT *p)
static Mat & updAs (ELT *p)
static Mat< M, N, ELT, M, 1 > getNaN ()
static double getDefaultTolerance ()
 For approximate comparisions, the default tolerance to use for a matrix is its shortest dimension times its elements' default tolerance.

Detailed Description

template<int M, int N, class ELT, int CS, int RS>
class SimTK::Mat< M, N, ELT, CS, RS >

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

Member Typedef Documentation

template<int M, int N, class ELT, int CS, int RS>
typedef Mat<M,N,E,CS,RS> SimTK::Mat< M, N, ELT, CS, RS >::T
template<int M, int N, class ELT, int CS, int RS>
typedef Mat<M,N,ENeg,CS,RS> SimTK::Mat< M, N, ELT, CS, RS >::TNeg
template<int M, int N, class ELT, int CS, int RS>
typedef Mat<M,N,EWithoutNegator,CS,RS> SimTK::Mat< M, N, ELT, CS, RS >::TWithoutNegator
template<int M, int N, class ELT, int CS, int RS>
typedef Mat<M,N,EReal,CS*CNT<E>::RealStrideFactor,RS*CNT<E>::RealStrideFactor> SimTK::Mat< M, N, ELT, CS, RS >::TReal
template<int M, int N, class ELT, int CS, int RS>
typedef Mat<M,N,EImag,CS*CNT<E>::RealStrideFactor,RS*CNT<E>::RealStrideFactor> SimTK::Mat< M, N, ELT, CS, RS >::TImag
template<int M, int N, class ELT, int CS, int RS>
typedef Mat<M,N,EComplex,CS,RS> SimTK::Mat< M, N, ELT, CS, RS >::TComplex
template<int M, int N, class ELT, int CS, int RS>
typedef Mat<N,M,EHerm,RS,CS> SimTK::Mat< M, N, ELT, CS, RS >::THerm
template<int M, int N, class ELT, int CS, int RS>
typedef Mat<N,M,E,RS,CS> SimTK::Mat< M, N, ELT, CS, RS >::TPosTrans
template<int M, int N, class ELT, int CS, int RS>
typedef E SimTK::Mat< M, N, ELT, CS, RS >::TElement
template<int M, int N, class ELT, int CS, int RS>
typedef Row<N,E,CS> SimTK::Mat< M, N, ELT, CS, RS >::TRow
template<int M, int N, class ELT, int CS, int RS>
typedef Vec<M,E,RS> SimTK::Mat< M, N, ELT, CS, RS >::TCol
template<int M, int N, class ELT, int CS, int RS>
typedef Vec<MinDim,E,RS+CS> SimTK::Mat< M, N, ELT, CS, RS >::TDiag
template<int M, int N, class ELT, int CS, int RS>
typedef Mat<M,N,ESqrt,M,1> SimTK::Mat< M, N, ELT, CS, RS >::TSqrt
template<int M, int N, class ELT, int CS, int RS>
typedef Mat<M,N,EAbs,M,1> SimTK::Mat< M, N, ELT, CS, RS >::TAbs
template<int M, int N, class ELT, int CS, int RS>
typedef Mat<M,N,EStandard,M,1> SimTK::Mat< M, N, ELT, CS, RS >::TStandard
template<int M, int N, class ELT, int CS, int RS>
typedef Mat<N,M,EInvert,N,1> SimTK::Mat< M, N, ELT, CS, RS >::TInvert
template<int M, int N, class ELT, int CS, int RS>
typedef Mat<M,N,ENormalize,M,1> SimTK::Mat< M, N, ELT, CS, RS >::TNormalize
template<int M, int N, class ELT, int CS, int RS>
typedef SymMat<N,ESqHermT> SimTK::Mat< M, N, ELT, CS, RS >::TSqHermT
template<int M, int N, class ELT, int CS, int RS>
typedef SymMat<M,ESqTHerm> SimTK::Mat< M, N, ELT, CS, RS >::TSqTHerm
template<int M, int N, class ELT, int CS, int RS>
typedef Mat<M,N,E,M,1> SimTK::Mat< M, N, ELT, CS, RS >::TPacked
template<int M, int N, class ELT, int CS, int RS>
typedef Mat<M-1,N,E,M,1> SimTK::Mat< M, N, ELT, CS, RS >::TDropRow
template<int M, int N, class ELT, int CS, int RS>
typedef Mat<M,N-1,E,M,1> SimTK::Mat< M, N, ELT, CS, RS >::TDropCol
template<int M, int N, class ELT, int CS, int RS>
typedef Mat<M-1,N-1,E,M,1> SimTK::Mat< M, N, ELT, CS, RS >::TDropRowCol
template<int M, int N, class ELT, int CS, int RS>
typedef Mat<M+1,N,E,M,1> SimTK::Mat< M, N, ELT, CS, RS >::TAppendRow
template<int M, int N, class ELT, int CS, int RS>
typedef Mat<M,N+1,E,M,1> SimTK::Mat< M, N, ELT, CS, RS >::TAppendCol
template<int M, int N, class ELT, int CS, int RS>
typedef Mat<M+1,N+1,E,M,1> SimTK::Mat< M, N, ELT, CS, RS >::TAppendRowCol
template<int M, int N, class ELT, int CS, int RS>
typedef EScalar SimTK::Mat< M, N, ELT, CS, RS >::Scalar
template<int M, int N, class ELT, int CS, int RS>
typedef EULessScalar SimTK::Mat< M, N, ELT, CS, RS >::ULessScalar
template<int M, int N, class ELT, int CS, int RS>
typedef ENumber SimTK::Mat< M, N, ELT, CS, RS >::Number
template<int M, int N, class ELT, int CS, int RS>
typedef EStdNumber SimTK::Mat< M, N, ELT, CS, RS >::StdNumber
template<int M, int N, class ELT, int CS, int RS>
typedef EPrecision SimTK::Mat< M, N, ELT, CS, RS >::Precision
template<int M, int N, class ELT, int CS, int RS>
typedef EScalarNormSq SimTK::Mat< M, N, ELT, CS, RS >::ScalarNormSq
template<int M, int N, class ELT, int CS, int RS>
typedef THerm SimTK::Mat< M, N, ELT, CS, RS >::TransposeType

Member Enumeration Documentation

template<int M, int N, class ELT, int CS, int RS>
anonymous enum
Enumerator:
NRows 
NCols 
MinDim 
MaxDim 
RowSpacing 
ColSpacing 
NPackedElements 
NActualElements 
NActualScalars 
ImagOffset 
RealStrideFactor 
ArgDepth 
IsScalar 
IsULessScalar 
IsNumber 
IsStdNumber 
IsPrecision 
SignInterpretation 

Constructor & Destructor Documentation

template<int M, int N, class ELT, int CS, int RS>
SimTK::Mat< M, N, ELT, CS, RS >::Mat ( ) [inline]
template<int M, int N, class ELT, int CS, int RS>
SimTK::Mat< M, N, ELT, CS, RS >::Mat ( const Mat< M, N, ELT, CS, RS > &  src) [inline]
template<int M, int N, class ELT, int CS, int RS>
SimTK::Mat< M, N, ELT, CS, RS >::Mat ( const SymMat< M, ELT > &  src) [inline, explicit]
template<int M, int N, class ELT, int CS, int RS>
template<int CSS, int RSS>
SimTK::Mat< M, N, ELT, CS, RS >::Mat ( const Mat< M, N, E, CSS, RSS > &  src) [inline]
template<int M, int N, class ELT, int CS, int RS>
template<int CSS, int RSS>
SimTK::Mat< M, N, ELT, CS, RS >::Mat ( const Mat< M, N, ENeg, CSS, RSS > &  src) [inline]
template<int M, int N, class ELT, int CS, int RS>
template<class EE , int CSS, int RSS>
SimTK::Mat< M, N, ELT, CS, RS >::Mat ( const Mat< M, N, EE, CSS, RSS > &  mm) [inline, explicit]
template<int M, int N, class ELT, int CS, int RS>
SimTK::Mat< M, N, ELT, CS, RS >::Mat ( const E &  e) [inline, explicit]
template<int M, int N, class ELT, int CS, int RS>
SimTK::Mat< M, N, ELT, CS, RS >::Mat ( const ENeg &  e) [inline, explicit]
template<int M, int N, class ELT, int CS, int RS>
SimTK::Mat< M, N, ELT, CS, RS >::Mat ( int  i) [inline, explicit]
template<int M, int N, class ELT, int CS, int RS>
SimTK::Mat< M, N, ELT, CS, RS >::Mat ( const E &  e0,
const E &  e1 
) [inline]
template<int M, int N, class ELT, int CS, int RS>
SimTK::Mat< M, N, ELT, CS, RS >::Mat ( const E &  e0,
const E &  e1,
const E &  e2 
) [inline]
template<int M, int N, class ELT, int CS, int RS>
SimTK::Mat< M, N, ELT, CS, RS >::Mat ( const E &  e0,
const E &  e1,
const E &  e2,
const E &  e3 
) [inline]
template<int M, int N, class ELT, int CS, int RS>
SimTK::Mat< M, N, ELT, CS, RS >::Mat ( const E &  e0,
const E &  e1,
const E &  e2,
const E &  e3,
const E &  e4 
) [inline]
template<int M, int N, class ELT, int CS, int RS>
SimTK::Mat< M, N, ELT, CS, RS >::Mat ( const E &  e0,
const E &  e1,
const E &  e2,
const E &  e3,
const E &  e4,
const E &  e5 
) [inline]
template<int M, int N, class ELT, int CS, int RS>
SimTK::Mat< M, N, ELT, CS, RS >::Mat ( const E &  e0,
const E &  e1,
const E &  e2,
const E &  e3,
const E &  e4,
const E &  e5,
const E &  e6 
) [inline]
template<int M, int N, class ELT, int CS, int RS>
SimTK::Mat< M, N, ELT, CS, RS >::Mat ( const E &  e0,
const E &  e1,
const E &  e2,
const E &  e3,
const E &  e4,
const E &  e5,
const E &  e6,
const E &  e7 
) [inline]
template<int M, int N, class ELT, int CS, int RS>
SimTK::Mat< M, N, ELT, CS, RS >::Mat ( const E &  e0,
const E &  e1,
const E &  e2,
const E &  e3,
const E &  e4,
const E &  e5,
const E &  e6,
const E &  e7,
const E &  e8 
) [inline]
template<int M, int N, class ELT, int CS, int RS>
SimTK::Mat< M, N, ELT, CS, RS >::Mat ( const E &  e0,
const E &  e1,
const E &  e2,
const E &  e3,
const E &  e4,
const E &  e5,
const E &  e6,
const E &  e7,
const E &  e8,
const E &  e9 
) [inline]
template<int M, int N, class ELT, int CS, int RS>
SimTK::Mat< M, N, ELT, CS, RS >::Mat ( const E &  e0,
const E &  e1,
const E &  e2,
const E &  e3,
const E &  e4,
const E &  e5,
const E &  e6,
const E &  e7,
const E &  e8,
const E &  e9,
const E &  e10 
) [inline]
template<int M, int N, class ELT, int CS, int RS>
SimTK::Mat< M, N, ELT, CS, RS >::Mat ( const E &  e0,
const E &  e1,
const E &  e2,
const E &  e3,
const E &  e4,
const E &  e5,
const E &  e6,
const E &  e7,
const E &  e8,
const E &  e9,
const E &  e10,
const E &  e11 
) [inline]
template<int M, int N, class ELT, int CS, int RS>
SimTK::Mat< M, N, ELT, CS, RS >::Mat ( const E &  e0,
const E &  e1,
const E &  e2,
const E &  e3,
const E &  e4,
const E &  e5,
const E &  e6,
const E &  e7,
const E &  e8,
const E &  e9,
const E &  e10,
const E &  e11,
const E &  e12 
) [inline]
template<int M, int N, class ELT, int CS, int RS>
SimTK::Mat< M, N, ELT, CS, RS >::Mat ( const E &  e0,
const E &  e1,
const E &  e2,
const E &  e3,
const E &  e4,
const E &  e5,
const E &  e6,
const E &  e7,
const E &  e8,
const E &  e9,
const E &  e10,
const E &  e11,
const E &  e12,
const E &  e13 
) [inline]
template<int M, int N, class ELT, int CS, int RS>
SimTK::Mat< M, N, ELT, CS, RS >::Mat ( const E &  e0,
const E &  e1,
const E &  e2,
const E &  e3,
const E &  e4,
const E &  e5,
const E &  e6,
const E &  e7,
const E &  e8,
const E &  e9,
const E &  e10,
const E &  e11,
const E &  e12,
const E &  e13,
const E &  e14 
) [inline]
template<int M, int N, class ELT, int CS, int RS>
SimTK::Mat< M, N, ELT, CS, RS >::Mat ( const E &  e0,
const E &  e1,
const E &  e2,
const E &  e3,
const E &  e4,
const E &  e5,
const E &  e6,
const E &  e7,
const E &  e8,
const E &  e9,
const E &  e10,
const E &  e11,
const E &  e12,
const E &  e13,
const E &  e14,
const E &  e15 
) [inline]
template<int M, int N, class ELT, int CS, int RS>
SimTK::Mat< M, N, ELT, CS, RS >::Mat ( const TRow &  r0) [inline, explicit]
template<int M, int N, class ELT, int CS, int RS>
SimTK::Mat< M, N, ELT, CS, RS >::Mat ( const TRow &  r0,
const TRow &  r1 
) [inline]
template<int M, int N, class ELT, int CS, int RS>
SimTK::Mat< M, N, ELT, CS, RS >::Mat ( const TRow &  r0,
const TRow &  r1,
const TRow &  r2 
) [inline]
template<int M, int N, class ELT, int CS, int RS>
SimTK::Mat< M, N, ELT, CS, RS >::Mat ( const TRow &  r0,
const TRow &  r1,
const TRow &  r2,
const TRow &  r3 
) [inline]
template<int M, int N, class ELT, int CS, int RS>
SimTK::Mat< M, N, ELT, CS, RS >::Mat ( const TRow &  r0,
const TRow &  r1,
const TRow &  r2,
const TRow &  r3,
const TRow &  r4 
) [inline]
template<int M, int N, class ELT, int CS, int RS>
SimTK::Mat< M, N, ELT, CS, RS >::Mat ( const TRow &  r0,
const TRow &  r1,
const TRow &  r2,
const TRow &  r3,
const TRow &  r4,
const TRow &  r5 
) [inline]
template<int M, int N, class ELT, int CS, int RS>
template<class EE , int SS>
SimTK::Mat< M, N, ELT, CS, RS >::Mat ( const Row< N, EE, SS > &  r0) [inline, explicit]
template<int M, int N, class ELT, int CS, int RS>
template<class EE , int SS>
SimTK::Mat< M, N, ELT, CS, RS >::Mat ( const Row< N, EE, SS > &  r0,
const Row< N, EE, SS > &  r1 
) [inline]
template<int M, int N, class ELT, int CS, int RS>
template<class EE , int SS>
SimTK::Mat< M, N, ELT, CS, RS >::Mat ( const Row< N, EE, SS > &  r0,
const Row< N, EE, SS > &  r1,
const Row< N, EE, SS > &  r2 
) [inline]
template<int M, int N, class ELT, int CS, int RS>
template<class EE , int SS>
SimTK::Mat< M, N, ELT, CS, RS >::Mat ( const Row< N, EE, SS > &  r0,
const Row< N, EE, SS > &  r1,
const Row< N, EE, SS > &  r2,
const Row< N, EE, SS > &  r3 
) [inline]
template<int M, int N, class ELT, int CS, int RS>
template<class EE , int SS>
SimTK::Mat< M, N, ELT, CS, RS >::Mat ( const Row< N, EE, SS > &  r0,
const Row< N, EE, SS > &  r1,
const Row< N, EE, SS > &  r2,
const Row< N, EE, SS > &  r3,
const Row< N, EE, SS > &  r4 
) [inline]
template<int M, int N, class ELT, int CS, int RS>
template<class EE , int SS>
SimTK::Mat< M, N, ELT, CS, RS >::Mat ( const Row< N, EE, SS > &  r0,
const Row< N, EE, SS > &  r1,
const Row< N, EE, SS > &  r2,
const Row< N, EE, SS > &  r3,
const Row< N, EE, SS > &  r4,
const Row< N, EE, SS > &  r5 
) [inline]
template<int M, int N, class ELT, int CS, int RS>
SimTK::Mat< M, N, ELT, CS, RS >::Mat ( const TCol &  r0) [inline, explicit]
template<int M, int N, class ELT, int CS, int RS>
SimTK::Mat< M, N, ELT, CS, RS >::Mat ( const TCol &  r0,
const TCol &  r1 
) [inline]
template<int M, int N, class ELT, int CS, int RS>
SimTK::Mat< M, N, ELT, CS, RS >::Mat ( const TCol &  r0,
const TCol &  r1,
const TCol &  r2 
) [inline]
template<int M, int N, class ELT, int CS, int RS>
SimTK::Mat< M, N, ELT, CS, RS >::Mat ( const TCol &  r0,
const TCol &  r1,
const TCol &  r2,
const TCol &  r3 
) [inline]
template<int M, int N, class ELT, int CS, int RS>
SimTK::Mat< M, N, ELT, CS, RS >::Mat ( const TCol &  r0,
const TCol &  r1,
const TCol &  r2,
const TCol &  r3,
const TCol &  r4 
) [inline]
template<int M, int N, class ELT, int CS, int RS>
SimTK::Mat< M, N, ELT, CS, RS >::Mat ( const TCol &  r0,
const TCol &  r1,
const TCol &  r2,
const TCol &  r3,
const TCol &  r4,
const TCol &  r5 
) [inline]
template<int M, int N, class ELT, int CS, int RS>
template<class EE , int SS>
SimTK::Mat< M, N, ELT, CS, RS >::Mat ( const Vec< M, EE, SS > &  r0) [inline, explicit]
template<int M, int N, class ELT, int CS, int RS>
template<class EE , int SS>
SimTK::Mat< M, N, ELT, CS, RS >::Mat ( const Vec< M, EE, SS > &  r0,
const Vec< M, EE, SS > &  r1 
) [inline]
template<int M, int N, class ELT, int CS, int RS>
template<class EE , int SS>
SimTK::Mat< M, N, ELT, CS, RS >::Mat ( const Vec< M, EE, SS > &  r0,
const Vec< M, EE, SS > &  r1,
const Vec< M, EE, SS > &  r2 
) [inline]
template<int M, int N, class ELT, int CS, int RS>
template<class EE , int SS>
SimTK::Mat< M, N, ELT, CS, RS >::Mat ( const Vec< M, EE, SS > &  r0,
const Vec< M, EE, SS > &  r1,
const Vec< M, EE, SS > &  r2,
const Vec< M, EE, SS > &  r3 
) [inline]
template<int M, int N, class ELT, int CS, int RS>
template<class EE , int SS>
SimTK::Mat< M, N, ELT, CS, RS >::Mat ( const Vec< M, EE, SS > &  r0,
const Vec< M, EE, SS > &  r1,
const Vec< M, EE, SS > &  r2,
const Vec< M, EE, SS > &  r3,
const Vec< M, EE, SS > &  r4 
) [inline]
template<int M, int N, class ELT, int CS, int RS>
template<class EE , int SS>
SimTK::Mat< M, N, ELT, CS, RS >::Mat ( const Vec< M, EE, SS > &  r0,
const Vec< M, EE, SS > &  r1,
const Vec< M, EE, SS > &  r2,
const Vec< M, EE, SS > &  r3,
const Vec< M, EE, SS > &  r4,
const Vec< M, EE, SS > &  r5 
) [inline]
template<int M, int N, class ELT, int CS, int RS>
template<class EE >
SimTK::Mat< M, N, ELT, CS, RS >::Mat ( const EE *  p) [inline, explicit]

Member Function Documentation

template<int M, int N, class ELT, int CS, int RS>
int SimTK::Mat< M, N, ELT, CS, RS >::size ( ) const [inline]
template<int M, int N, class ELT, int CS, int RS>
int SimTK::Mat< M, N, ELT, CS, RS >::nrow ( ) const [inline]
template<int M, int N, class ELT, int CS, int RS>
int SimTK::Mat< M, N, ELT, CS, RS >::ncol ( ) const [inline]
template<int M, int N, class ELT, int CS, int RS>
ScalarNormSq SimTK::Mat< M, N, ELT, CS, RS >::scalarNormSqr ( ) const [inline]
template<int M, int N, class ELT, int CS, int RS>
TSqrt SimTK::Mat< M, N, ELT, CS, RS >::sqrt ( ) const [inline]
template<int M, int N, class ELT, int CS, int RS>
TAbs SimTK::Mat< M, N, ELT, CS, RS >::abs ( ) const [inline]
template<int M, int N, class ELT, int CS, int RS>
TStandard SimTK::Mat< M, N, ELT, CS, RS >::standardize ( ) const [inline]
template<int M, int N, class ELT, int CS, int RS>
Mat& SimTK::Mat< M, N, ELT, CS, RS >::operator= ( const Mat< M, N, ELT, CS, RS > &  src) [inline]
template<int M, int N, class ELT, int CS, int RS>
template<class EE , int CSS, int RSS>
Mat& SimTK::Mat< M, N, ELT, CS, RS >::operator= ( const Mat< M, N, EE, CSS, RSS > &  mm) [inline]
template<int M, int N, class ELT, int CS, int RS>
template<class EE >
Mat& SimTK::Mat< M, N, ELT, CS, RS >::operator= ( const EE *  p) [inline]
template<int M, int N, class ELT, int CS, int RS>
template<class EE , int CSS, int RSS>
Mat& SimTK::Mat< M, N, ELT, CS, RS >::operator+= ( const Mat< M, N, EE, CSS, RSS > &  mm) [inline]
template<int M, int N, class ELT, int CS, int RS>
template<class EE , int CSS, int RSS>
Mat& SimTK::Mat< M, N, ELT, CS, RS >::operator+= ( const Mat< M, N, negator< EE >, CSS, RSS > &  mm) [inline]
template<int M, int N, class ELT, int CS, int RS>
template<class EE , int CSS, int RSS>
Mat& SimTK::Mat< M, N, ELT, CS, RS >::operator-= ( const Mat< M, N, EE, CSS, RSS > &  mm) [inline]
template<int M, int N, class ELT, int CS, int RS>
template<class EE , int CSS, int RSS>
Mat& SimTK::Mat< M, N, ELT, CS, RS >::operator-= ( const Mat< M, N, negator< EE >, CSS, RSS > &  mm) [inline]
template<int M, int N, class ELT, int CS, int RS>
template<class EE , int CSS, int RSS>
Mat& SimTK::Mat< M, N, ELT, CS, RS >::operator*= ( const Mat< N, N, EE, CSS, RSS > &  mm) [inline]
template<int M, int N, class ELT, int CS, int RS>
template<class E2 , int CS2, int RS2>
Result<Mat<M,N,E2,CS2,RS2> >::Add SimTK::Mat< M, N, ELT, CS, RS >::conformingAdd ( const Mat< M, N, E2, CS2, RS2 > &  r) const [inline]
template<int M, int N, class ELT, int CS, int RS>
template<class E2 , int CS2, int RS2>
Result<Mat<M,N,E2,CS2,RS2> >::Sub SimTK::Mat< M, N, ELT, CS, RS >::conformingSubtract ( const Mat< M, N, E2, CS2, RS2 > &  r) const [inline]
template<int M, int N, class ELT, int CS, int RS>
template<class E2 , int CS2, int RS2>
Mat<M,N,E2,CS2,RS2>::template Result<Mat>::Sub SimTK::Mat< M, N, ELT, CS, RS >::conformingSubtractFromLeft ( const Mat< M, N, E2, CS2, RS2 > &  l) const [inline]
template<int M, int N, class ELT, int CS, int RS>
template<class E2 , int RS2>
Result<SymMat<M,E2,RS2> >::Add SimTK::Mat< M, N, ELT, CS, RS >::conformingAdd ( const SymMat< M, E2, RS2 > &  sy) const [inline]
template<int M, int N, class ELT, int CS, int RS>
template<class E2 , int RS2>
Result<SymMat<M,E2,RS2> >::Sub SimTK::Mat< M, N, ELT, CS, RS >::conformingSubtract ( const SymMat< M, E2, RS2 > &  sy) const [inline]
template<int M, int N, class ELT, int CS, int RS>
template<class E2 , int RS2>
SymMat<M,E2,RS2>::template Result<Mat>::Sub SimTK::Mat< M, N, ELT, CS, RS >::conformingSubtractFromLeft ( const SymMat< M, E2, RS2 > &  sy) const [inline]
template<int M, int N, class ELT, int CS, int RS>
template<int N2, class E2 , int CS2, int RS2>
Result<Mat<N,N2,E2,CS2,RS2> >::Mul SimTK::Mat< M, N, ELT, CS, RS >::conformingMultiply ( const Mat< N, N2, E2, CS2, RS2 > &  m) const [inline]
template<int M, int N, class ELT, int CS, int RS>
template<int M2, class E2 , int CS2, int RS2>
Mat<M2,M,E2,CS2,RS2>::template Result<Mat>::Mul SimTK::Mat< M, N, ELT, CS, RS >::conformingMultiplyFromLeft ( const Mat< M2, M, E2, CS2, RS2 > &  m) const [inline]
template<int M, int N, class ELT, int CS, int RS>
template<int M2, class E2 , int CS2, int RS2>
Result<Mat<M2,N,E2,CS2,RS2> >::Dvd SimTK::Mat< M, N, ELT, CS, RS >::conformingDivide ( const Mat< M2, N, E2, CS2, RS2 > &  m) const [inline]
template<int M, int N, class ELT, int CS, int RS>
template<int M2, class E2 , int CS2, int RS2>
Mat<M2,N,E2,CS2,RS2>::template Result<Mat>::Dvd SimTK::Mat< M, N, ELT, CS, RS >::conformingDivideFromLeft ( const Mat< M2, N, E2, CS2, RS2 > &  m) const [inline]
template<int M, int N, class ELT, int CS, int RS>
const TRow& SimTK::Mat< M, N, ELT, CS, RS >::operator[] ( int  i) const [inline]

Reimplemented in SimTK::Rotation_< P >, SimTK::InverseRotation_< P >, and SimTK::Rotation_< Real >.

template<int M, int N, class ELT, int CS, int RS>
TRow& SimTK::Mat< M, N, ELT, CS, RS >::operator[] ( int  i) [inline]
template<int M, int N, class ELT, int CS, int RS>
const TCol& SimTK::Mat< M, N, ELT, CS, RS >::operator() ( int  j) const [inline]

Reimplemented in SimTK::Rotation_< P >, SimTK::InverseRotation_< P >, and SimTK::Rotation_< Real >.

template<int M, int N, class ELT, int CS, int RS>
TCol& SimTK::Mat< M, N, ELT, CS, RS >::operator() ( int  j) [inline]
template<int M, int N, class ELT, int CS, int RS>
const E& SimTK::Mat< M, N, ELT, CS, RS >::operator() ( int  i,
int  j 
) const [inline]
template<int M, int N, class ELT, int CS, int RS>
E& SimTK::Mat< M, N, ELT, CS, RS >::operator() ( int  i,
int  j 
) [inline]
template<int M, int N, class ELT, int CS, int RS>
ScalarNormSq SimTK::Mat< M, N, ELT, CS, RS >::normSqr ( ) const [inline]
template<int M, int N, class ELT, int CS, int RS>
CNT<ScalarNormSq>::TSqrt SimTK::Mat< M, N, ELT, CS, RS >::norm ( ) const [inline]
template<int M, int N, class ELT, int CS, int RS>
TNormalize SimTK::Mat< M, N, ELT, CS, RS >::normalize ( ) const [inline]
template<int M, int N, class ELT , int CS, int RS>
Mat< M, N, ELT, CS, RS >::TInvert SimTK::Mat< M, N, ELT, CS, RS >::invert ( ) const [inline]

Reimplemented in SimTK::Rotation_< P >, SimTK::InverseRotation_< P >, and SimTK::Rotation_< Real >.

template<int M, int N, class ELT, int CS, int RS>
const Mat& SimTK::Mat< M, N, ELT, CS, RS >::operator+ ( ) const [inline]
template<int M, int N, class ELT, int CS, int RS>
const TNeg& SimTK::Mat< M, N, ELT, CS, RS >::operator- ( ) const [inline]
template<int M, int N, class ELT, int CS, int RS>
TNeg& SimTK::Mat< M, N, ELT, CS, RS >::operator- ( ) [inline]
template<int M, int N, class ELT, int CS, int RS>
const THerm& SimTK::Mat< M, N, ELT, CS, RS >::operator~ ( ) const [inline]

Reimplemented in SimTK::Rotation_< P >, SimTK::InverseRotation_< P >, and SimTK::Rotation_< Real >.

template<int M, int N, class ELT, int CS, int RS>
THerm& SimTK::Mat< M, N, ELT, CS, RS >::operator~ ( ) [inline]

Reimplemented in SimTK::Rotation_< P >, SimTK::InverseRotation_< P >, and SimTK::Rotation_< Real >.

template<int M, int N, class ELT, int CS, int RS>
const TNeg& SimTK::Mat< M, N, ELT, CS, RS >::negate ( ) const [inline]
template<int M, int N, class ELT, int CS, int RS>
TNeg& SimTK::Mat< M, N, ELT, CS, RS >::updNegate ( ) [inline]
template<int M, int N, class ELT, int CS, int RS>
const THerm& SimTK::Mat< M, N, ELT, CS, RS >::transpose ( ) const [inline]

Reimplemented in SimTK::Rotation_< P >, SimTK::InverseRotation_< P >, and SimTK::Rotation_< Real >.

template<int M, int N, class ELT, int CS, int RS>
THerm& SimTK::Mat< M, N, ELT, CS, RS >::updTranspose ( ) [inline]

Reimplemented in SimTK::Rotation_< P >, SimTK::InverseRotation_< P >, and SimTK::Rotation_< Real >.

template<int M, int N, class ELT, int CS, int RS>
const TPosTrans& SimTK::Mat< M, N, ELT, CS, RS >::positionalTranspose ( ) const [inline]
template<int M, int N, class ELT, int CS, int RS>
TPosTrans& SimTK::Mat< M, N, ELT, CS, RS >::updPositionalTranspose ( ) [inline]
template<int M, int N, class ELT, int CS, int RS>
const TReal& SimTK::Mat< M, N, ELT, CS, RS >::real ( ) const [inline]
template<int M, int N, class ELT, int CS, int RS>
TReal& SimTK::Mat< M, N, ELT, CS, RS >::real ( ) [inline]
template<int M, int N, class ELT, int CS, int RS>
const TImag& SimTK::Mat< M, N, ELT, CS, RS >::imag ( ) const [inline]
template<int M, int N, class ELT, int CS, int RS>
TImag& SimTK::Mat< M, N, ELT, CS, RS >::imag ( ) [inline]
template<int M, int N, class ELT, int CS, int RS>
const TWithoutNegator& SimTK::Mat< M, N, ELT, CS, RS >::castAwayNegatorIfAny ( ) const [inline]
template<int M, int N, class ELT, int CS, int RS>
TWithoutNegator& SimTK::Mat< M, N, ELT, CS, RS >::updCastAwayNegatorIfAny ( ) [inline]
template<int M, int N, class ELT, int CS, int RS>
const TRow& SimTK::Mat< M, N, ELT, CS, RS >::row ( int  i) const [inline]

Reimplemented in SimTK::Rotation_< P >, SimTK::InverseRotation_< P >, and SimTK::Rotation_< Real >.

template<int M, int N, class ELT, int CS, int RS>
TRow& SimTK::Mat< M, N, ELT, CS, RS >::row ( int  i) [inline]
template<int M, int N, class ELT, int CS, int RS>
const TCol& SimTK::Mat< M, N, ELT, CS, RS >::col ( int  j) const [inline]

Reimplemented in SimTK::Rotation_< P >, SimTK::InverseRotation_< P >, and SimTK::Rotation_< Real >.

template<int M, int N, class ELT, int CS, int RS>
TCol& SimTK::Mat< M, N, ELT, CS, RS >::col ( int  j) [inline]
template<int M, int N, class ELT, int CS, int RS>
const E& SimTK::Mat< M, N, ELT, CS, RS >::elt ( int  i,
int  j 
) const [inline]
template<int M, int N, class ELT, int CS, int RS>
E& SimTK::Mat< M, N, ELT, CS, RS >::elt ( int  i,
int  j 
) [inline]
template<int M, int N, class ELT, int CS, int RS>
const TDiag& SimTK::Mat< M, N, ELT, CS, RS >::diag ( ) const [inline]
template<int M, int N, class ELT, int CS, int RS>
TDiag& SimTK::Mat< M, N, ELT, CS, RS >::diag ( ) [inline]
template<int M, int N, class ELT, int CS, int RS>
EStandard SimTK::Mat< M, N, ELT, CS, RS >::trace ( ) const [inline]
template<int M, int N, class ELT, int CS, int RS>
template<class EE >
Mat<M,N, typename CNT<E>::template Result<EE>::Mul> SimTK::Mat< M, N, ELT, CS, RS >::scalarMultiply ( const EE &  e) const [inline]
template<int M, int N, class ELT, int CS, int RS>
template<class EE >
Mat<M,N, typename CNT<EE>::template Result<E>::Mul> SimTK::Mat< M, N, ELT, CS, RS >::scalarMultiplyFromLeft ( const EE &  e) const [inline]
template<int M, int N, class ELT, int CS, int RS>
template<class EE >
Mat<M,N, typename CNT<E>::template Result<EE>::Dvd> SimTK::Mat< M, N, ELT, CS, RS >::scalarDivide ( const EE &  e) const [inline]
template<int M, int N, class ELT, int CS, int RS>
template<class EE >
Mat<M,N, typename CNT<EE>::template Result<E>::Dvd> SimTK::Mat< M, N, ELT, CS, RS >::scalarDivideFromLeft ( const EE &  e) const [inline]
template<int M, int N, class ELT, int CS, int RS>
template<class EE >
Mat<M,N, typename CNT<E>::template Result<EE>::Add> SimTK::Mat< M, N, ELT, CS, RS >::scalarAdd ( const EE &  e) const [inline]
template<int M, int N, class ELT, int CS, int RS>
template<class EE >
Mat<M,N, typename CNT<E>::template Result<EE>::Sub> SimTK::Mat< M, N, ELT, CS, RS >::scalarSubtract ( const EE &  e) const [inline]
template<int M, int N, class ELT, int CS, int RS>
template<class EE >
Mat<M,N, typename CNT<EE>::template Result<E>::Sub> SimTK::Mat< M, N, ELT, CS, RS >::scalarSubtractFromLeft ( const EE &  e) const [inline]
template<int M, int N, class ELT, int CS, int RS>
template<class EE >
Mat& SimTK::Mat< M, N, ELT, CS, RS >::operator= ( const EE &  e) [inline]
template<int M, int N, class ELT, int CS, int RS>
template<class EE >
Mat& SimTK::Mat< M, N, ELT, CS, RS >::operator+= ( const EE &  e) [inline]
template<int M, int N, class ELT, int CS, int RS>
template<class EE >
Mat& SimTK::Mat< M, N, ELT, CS, RS >::operator-= ( const EE &  e) [inline]
template<int M, int N, class ELT, int CS, int RS>
template<class EE >
Mat& SimTK::Mat< M, N, ELT, CS, RS >::operator*= ( const EE &  e) [inline]
template<int M, int N, class ELT, int CS, int RS>
template<class EE >
Mat& SimTK::Mat< M, N, ELT, CS, RS >::operator/= ( const EE &  e) [inline]
template<int M, int N, class ELT, int CS, int RS>
template<class EE >
Mat& SimTK::Mat< M, N, ELT, CS, RS >::scalarEq ( const EE &  ee) [inline]
template<int M, int N, class ELT, int CS, int RS>
template<class EE >
Mat& SimTK::Mat< M, N, ELT, CS, RS >::scalarPlusEq ( const EE &  ee) [inline]
template<int M, int N, class ELT, int CS, int RS>
template<class EE >
Mat& SimTK::Mat< M, N, ELT, CS, RS >::scalarMinusEq ( const EE &  ee) [inline]
template<int M, int N, class ELT, int CS, int RS>
template<class EE >
Mat& SimTK::Mat< M, N, ELT, CS, RS >::scalarMinusEqFromLeft ( const EE &  ee) [inline]
template<int M, int N, class ELT, int CS, int RS>
template<class EE >
Mat& SimTK::Mat< M, N, ELT, CS, RS >::scalarTimesEq ( const EE &  ee) [inline]
template<int M, int N, class ELT, int CS, int RS>
template<class EE >
Mat& SimTK::Mat< M, N, ELT, CS, RS >::scalarTimesEqFromLeft ( const EE &  ee) [inline]
template<int M, int N, class ELT, int CS, int RS>
template<class EE >
Mat& SimTK::Mat< M, N, ELT, CS, RS >::scalarDivideEq ( const EE &  ee) [inline]
template<int M, int N, class ELT, int CS, int RS>
template<class EE >
Mat& SimTK::Mat< M, N, ELT, CS, RS >::scalarDivideEqFromLeft ( const EE &  ee) [inline]
template<int M, int N, class ELT, int CS, int RS>
void SimTK::Mat< M, N, ELT, CS, RS >::setToNaN ( ) [inline]
template<int M, int N, class ELT, int CS, int RS>
void SimTK::Mat< M, N, ELT, CS, RS >::setToZero ( ) [inline]
template<int M, int N, class ELT, int CS, int RS>
template<int MM, int NN>
const SubMat<MM,NN>::Type& SimTK::Mat< M, N, ELT, CS, RS >::getSubMat ( int  i,
int  j 
) const [inline]
template<int M, int N, class ELT, int CS, int RS>
template<int MM, int NN>
SubMat<MM,NN>::Type& SimTK::Mat< M, N, ELT, CS, RS >::updSubMat ( int  i,
int  j 
) [inline]
template<int M, int N, class ELT, int CS, int RS>
template<int MM, int NN>
void SimTK::Mat< M, N, ELT, CS, RS >::setSubMat ( int  i,
int  j,
const typename SubMat< MM, NN >::Type &  value 
) [inline]
template<int M, int N, class ELT, int CS, int RS>
TDropRow SimTK::Mat< M, N, ELT, CS, RS >::dropRow ( int  i) const [inline]

Return a matrix one row smaller than this one by dropping row i.

The result is packed but has same element type as this one.

template<int M, int N, class ELT, int CS, int RS>
TDropCol SimTK::Mat< M, N, ELT, CS, RS >::dropCol ( int  j) const [inline]

Return a matrix one column smaller than this one by dropping column j.

The result is packed but has same element type as this one.

template<int M, int N, class ELT, int CS, int RS>
TDropRowCol SimTK::Mat< M, N, ELT, CS, RS >::dropRowCol ( int  i,
int  j 
) const [inline]

Return a matrix one row and one column smaller than this one by dropping row i and column j.

The result is packed but has same element type as this one.

template<int M, int N, class ELT, int CS, int RS>
template<class EE , int SS>
TAppendRow SimTK::Mat< M, N, ELT, CS, RS >::appendRow ( const Row< N, EE, SS > &  row) const [inline]

Return a matrix one row larger than this one by adding a row to the end.

The result is packed but has same element type as this one. Works for any assignment compatible row.

template<int M, int N, class ELT, int CS, int RS>
template<class EE , int SS>
TAppendCol SimTK::Mat< M, N, ELT, CS, RS >::appendCol ( const Vec< M, EE, SS > &  col) const [inline]

Return a matrix one column larger than this one by adding a column to the end.

The result is packed but has same element type as this one. Works for any assignment compatible column.

template<int M, int N, class ELT, int CS, int RS>
template<class ER , int SR, class EC , int SC>
TAppendRowCol SimTK::Mat< M, N, ELT, CS, RS >::appendRowCol ( const Row< N+1, ER, SR > &  row,
const Vec< M+1, EC, SC > &  col 
) const [inline]

Return a matrix one row and one column larger than this one by adding a row to the bottom and a column to the right.

The final element of the row is ignored; that value is taken from the final element of the column instead. The result is packed but has same element type as this one. Works for any assignment compatible row and column.

template<int M, int N, class ELT, int CS, int RS>
template<class EE , int SS>
TAppendRow SimTK::Mat< M, N, ELT, CS, RS >::insertRow ( int  i,
const Row< N, EE, SS > &  row 
) const [inline]

Return a matrix one row larger than this one by inserting a row before* row i.

The result is packed but has same element type as this one. Works for any assignment compatible row. The index can be one greater than normally allowed in which case the row is appended.

template<int M, int N, class ELT, int CS, int RS>
template<class EE , int SS>
TAppendCol SimTK::Mat< M, N, ELT, CS, RS >::insertCol ( int  j,
const Vec< M, EE, SS > &  col 
) const [inline]

Return a matrix one column larger than this one by inserting a column before* column j.

The result is packed but has same element type as this one. Works for any assignment compatible column. The index can be one greater than normally allowed in which case the column is appended.

template<int M, int N, class ELT, int CS, int RS>
template<class ER , int SR, class EC , int SC>
TAppendRowCol SimTK::Mat< M, N, ELT, CS, RS >::insertRowCol ( int  i,
int  j,
const Row< N+1, ER, SR > &  row,
const Vec< M+1, EC, SC > &  col 
) const [inline]

Return a matrix one row and one column larger than this one by inserting a row *before* row i and a column *before* column j.

The intersecting element of the row is ignored; that element is taken from the column. The result is packed but has same element type as this one. Works for any assignment compatible row and column. The indices can be one greater than normally allowed in which case the row or column is appended.

template<int M, int N, class ELT, int CS, int RS>
static const Mat& SimTK::Mat< M, N, ELT, CS, RS >::getAs ( const ELT *  p) [inline, static]
template<int M, int N, class ELT, int CS, int RS>
static Mat& SimTK::Mat< M, N, ELT, CS, RS >::updAs ( ELT *  p) [inline, static]
template<int M, int N, class ELT, int CS, int RS>
static Mat<M,N,ELT,M,1> SimTK::Mat< M, N, ELT, CS, RS >::getNaN ( ) [inline, static]
template<int M, int N, class ELT, int CS, int RS>
bool SimTK::Mat< M, N, ELT, CS, RS >::isNaN ( ) const [inline]

Return true if any element of this Mat contains a NaN anywhere.

template<int M, int N, class ELT, int CS, int RS>
bool SimTK::Mat< M, N, ELT, CS, RS >::isInf ( ) const [inline]

Return true if any element of this Mat contains a +Inf or -Inf somewhere but no element contains a NaN anywhere.

template<int M, int N, class ELT, int CS, int RS>
bool SimTK::Mat< M, N, ELT, CS, RS >::isFinite ( ) const [inline]

Return true if no element contains an Infinity or a NaN.

template<int M, int N, class ELT, int CS, int RS>
static double SimTK::Mat< M, N, ELT, CS, RS >::getDefaultTolerance ( ) [inline, static]

For approximate comparisions, the default tolerance to use for a matrix is its shortest dimension times its elements' default tolerance.

template<int M, int N, class ELT, int CS, int RS>
template<class E2 , int CS2, int RS2>
bool SimTK::Mat< M, N, ELT, CS, RS >::isNumericallyEqual ( const Mat< M, N, E2, CS2, RS2 > &  m,
double  tol 
) const [inline]

Test whether this matrix is numerically equal to some other matrix with the same shape, using a specified tolerance.

template<int M, int N, class ELT, int CS, int RS>
template<class E2 , int CS2, int RS2>
bool SimTK::Mat< M, N, ELT, CS, RS >::isNumericallyEqual ( const Mat< M, N, E2, CS2, RS2 > &  m) const [inline]

Test whether this matrix is numerically equal to some other matrix with the same shape, using a default tolerance which is the looser of the default tolerances of the two objects being compared.

template<int M, int N, class ELT, int CS, int RS>
bool SimTK::Mat< M, N, ELT, CS, RS >::isNumericallyEqual ( const ELT &  e,
double  tol = getDefaultTolerance() 
) const [inline]

Test whether this is numerically a "scalar" matrix, meaning that it is a diagonal matrix in which each diagonal element is numerically equal to the same scalar, using either a specified tolerance or the matrix's default tolerance (which is always the same or looser than the default tolerance for one of its elements).

template<int M, int N, class ELT, int CS, int RS>
bool SimTK::Mat< M, N, ELT, CS, RS >::isNumericallySymmetric ( double  tol = getDefaultTolerance()) const [inline]

A Matrix is symmetric (actually Hermitian) if it is square and each element (i,j) is the Hermitian transpose of element (j,i).

Here we are testing for numerical symmetry, meaning that the symmetry condition is satisified to within a tolerance (supplied or default). This is a relatively expensive test since all elements must be examined but can be very useful in Debug mode to check assumptions.

See also:
isExactlySymmetric() for a rarely-used exact equality test
template<int M, int N, class ELT, int CS, int RS>
bool SimTK::Mat< M, N, ELT, CS, RS >::isExactlySymmetric ( ) const [inline]

A Matrix is symmetric (actually Hermitian) if it is square and each element (i,j) is the Hermitian (conjugate) transpose of element (j,i).

This method tests for exact (bitwise) equality and is too stringent for most purposes; don't use it unless you know that the corresponding elements should be bitwise conjugates, typically because you put them there directly.

See also:
isNumericallySymmetric() for a more useful method
template<int M, int N, class ELT, int CS, int RS>
TRow SimTK::Mat< M, N, ELT, CS, RS >::sum ( ) const [inline]
The documentation for this class was generated from the following files:
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines
Generated by  doxygen 1.7.3