SimTK::SymMat< M, ELT, RS > Class Template Reference

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

#include <SymMat.h>

List of all members.

Classes
struct	EltResult
struct	Result
struct	Substitute
Public Types
enum	{   NRows = M, NCols = M, NDiagElements = M, NLowerElements = (M*(M-1))/2,   NPackedElements = NDiagElements+NLowerElements, NActualElements = RS * NPackedElements, NActualScalars = CNT<E>::NActualScalars * NActualElements, RowSpacing = RS,   ColSpacing = NActualElements, ImagOffset = NTraits<ENumber>::ImagOffset, RealStrideFactor = 1, ArgDepth,   IsScalar = 0, IsULessScalar = 0, IsNumber = 0, IsStdNumber = 0,   IsPrecision = 0, SignInterpretation = CNT<E>::SignInterpretation }
typedef SymMat< M, E, RS >	T
typedef SymMat< M, ENeg, RS >	TNeg
typedef SymMat< M, EWithoutNegator, RS >	TWithoutNegator
typedef SymMat< M, EReal, RS *CNT< E >::RealStrideFactor >	TReal
typedef SymMat< M, EImag, RS *CNT< E >::RealStrideFactor >	TImag
typedef SymMat< M, EComplex, RS >	TComplex
typedef T	THerm
typedef SymMat< M, EHerm, RS >	TPosTrans
typedef E	TElement
typedef Vec< M, E, RS >	TDiag
typedef Vec<(M *(M-1))/2, E, RS	TLower )
typedef Vec<(M *(M-1))/2, EHerm, RS	TUpper )
typedef Vec<(M *(M+1))/2, E, RS	TAsVec )
typedef Row< M, E, 1 >	TRow
typedef Vec< M, E, 1 >	TCol
typedef SymMat< M, ESqrt, 1 >	TSqrt
typedef SymMat< M, EAbs, 1 >	TAbs
typedef SymMat< M, EStandard, 1 >	TStandard
typedef SymMat< M, EInvert, 1 >	TInvert
typedef SymMat< M, ENormalize, 1 >	TNormalize
typedef SymMat< M, ESqHermT, 1 >	TSqHermT
typedef SymMat< M, ESqTHerm, 1 >	TSqTHerm
typedef SymMat< M, E, 1 >	TPacked
typedef EScalar	Scalar
typedef EULessScalar	ULessScalar
typedef ENumber	Number
typedef EStdNumber	StdNumber
typedef EPrecision	Precision
typedef EScalarNormSq	ScalarNormSq
Public Member Functions
int	size () const
int	nrow () const
int	ncol () const
ScalarNormSq	scalarNormSqr () const
TSqrt	sqrt () const
TAbs	abs () const
TStandard	standardize () const
EStandard	trace () const
	SymMat ()
	Default construction initializes to NaN when debugging but is left uninitialized otherwise.
	SymMat (const SymMat &src)
	Copy constructor.
SymMat &	operator= (const SymMat &src)
	Copy assignment; no harm if source and this are the same matrix.
template<class EE , int CSS, int RSS>
	SymMat (const Mat< M, M, EE, CSS, RSS > &m)
	This is an explicit conversion from square Mat of right size, assuming that the source matrix is symmetric to within a reasonable numerical tolerance.
template<class EE , int CSS, int RSS>
SymMat &	setFromLower (const Mat< M, M, EE, CSS, RSS > &m)
	Create a new SymMat of this type from a square Mat of the right size, looking only at lower elements and the real part of the diagonal.
template<class EE , int CSS, int RSS>
SymMat &	setFromUpper (const Mat< M, M, EE, CSS, RSS > &m)
	Create a new SymMat of this type from a square Mat of the right size, looking only at upper elements and the real part of the diagonal.
template<class EE , int CSS, int RSS>
SymMat &	setFromSymmetric (const Mat< M, M, EE, CSS, RSS > &m)
	Create a new SymMat of this type from a square Mat of the right size, that is expected to be symmetric (hermitian) to within a tolerance.
template<int RSS>
	SymMat (const SymMat< M, E, RSS > &src)
	This is an implicit conversion from a SymMat of the same length and element type but with different spacing.
template<int RSS>
	SymMat (const SymMat< M, ENeg, RSS > &src)
	This is an implicit conversion from a SymMat of the same length and negated element type, possibly with different spacing.
template<class EE , int RSS>
	SymMat (const SymMat< M, EE, RSS > &src)
	Construct a SymMat from a SymMat of the same dimensions, with any element type and spacing.
	SymMat (const E &e)
	SymMat (const ENeg &e)
	SymMat (int i)
	SymMat (const E &e0, const E &e1, const E &e2)
	A bevy of constructors from individual exact-match elements IN ROW ORDER, giving the LOWER TRIANGLE, like this:
	SymMat (const E &e0, const E &e1, const E &e2, const E &e3, const E &e4, const E &e5)
	SymMat (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)
	SymMat (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)
	SymMat (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, const E &e16, const E &e17, const E &e18, const E &e19, const E &e20)
template<class EE >
	SymMat (const EE *p)
template<class EE >
SymMat &	operator= (const EE *p)
template<class EE , int RSS>
SymMat &	operator= (const SymMat< M, EE, RSS > &mm)
template<class EE , int RSS>
SymMat &	operator+= (const SymMat< M, EE, RSS > &mm)
template<class EE , int RSS>
SymMat &	operator+= (const SymMat< M, negator< EE >, RSS > &mm)
template<class EE , int RSS>
SymMat &	operator-= (const SymMat< M, EE, RSS > &mm)
template<class EE , int RSS>
SymMat &	operator-= (const SymMat< M, negator< EE >, RSS > &mm)
template<class EE , int RSS>
SymMat &	operator*= (const SymMat< M, EE, RSS > &mm)
template<class E2 , int RS2>
Result< SymMat< M, E2, RS2 > >::Add	conformingAdd (const SymMat< M, E2, RS2 > &r) const
template<class E2 , int RS2>
Result< SymMat< M, E2, RS2 > >::Sub	conformingSubtract (const SymMat< M, E2, RS2 > &r) const
template<class E2 , int RS2>
Result< SymMat< M, E2, RS2 > >::Mul	conformingMultiply (const SymMat< M, E2, RS2 > &s) const
const E &	operator() (int i, int j) const
E &	operator() (int i, int j)
TRow	operator[] (int i) const
TCol	operator() (int j) const
ScalarNormSq	normSqr () const
CNT< ScalarNormSq >::TSqrt	norm () const
TNormalize	normalize () const
	There is no conventional meaning for normalize() applied to a matrix.
TInvert	invert () const
const SymMat &	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 ()
template<class EE >
SymMat< M, typename CNT< E > ::template Result< EE >::Mul >	scalarMultiply (const EE &e) const
template<class EE >
SymMat< M, typename CNT< EE > ::template Result< E >::Mul >	scalarMultiplyFromLeft (const EE &e) const
template<class EE >
SymMat< M, typename CNT< E > ::template Result< EE >::Dvd >	scalarDivide (const EE &e) const
template<class EE >
SymMat< M, typename CNT< EE > ::template Result< E >::Dvd >	scalarDivideFromLeft (const EE &e) const
template<class EE >
SymMat< M, typename CNT< E > ::template Result< EE >::Add >	scalarAdd (const EE &e) const
template<class EE >
SymMat< M, typename CNT< E > ::template Result< EE >::Sub >	scalarSubtract (const EE &e) const
template<class EE >
SymMat< M, typename CNT< EE > ::template Result< E >::Sub >	scalarSubtractFromLeft (const EE &e) const
template<class EE >
SymMat &	operator= (const EE &e)
template<class EE >
SymMat &	operator+= (const EE &e)
template<class EE >
SymMat &	operator-= (const EE &e)
template<class EE >
SymMat &	operator*= (const EE &e)
template<class EE >
SymMat &	operator/= (const EE &e)
template<class EE >
SymMat &	scalarEq (const EE &ee)
template<class EE >
SymMat &	scalarPlusEq (const EE &ee)
template<class EE >
SymMat &	scalarMinusEq (const EE &ee)
template<class EE >
SymMat &	scalarMinusEqFromLeft (const EE &ee)
template<class EE >
SymMat &	scalarTimesEq (const EE &ee)
template<class EE >
SymMat &	scalarTimesEqFromLeft (const EE &ee)
template<class EE >
SymMat &	scalarDivideEq (const EE &ee)
template<class EE >
SymMat &	scalarDivideEqFromLeft (const EE &ee)
void	setToNaN ()
void	setToZero ()
bool	isNaN () const
	Return true if any element of this SymMat contains a NaN anywhere.
bool	isInf () const
	Return true if any element of this SymMat 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 RS2>
bool	isNumericallyEqual (const SymMat< M, E2, 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 RS2>
bool	isNumericallyEqual (const SymMat< M, E2, 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).
TRow	row (int i) const
TCol	col (int j) const
E	elt (int i, int j) const
	Return a value for any element of a symmetric matrix, even those in the upper triangle which aren't actually stored anywhere.
const TDiag &	getDiag () const
TDiag &	updDiag ()
const TDiag &	diag () const
TDiag &	diag ()
const TLower &	getLower () const
TLower &	updLower ()
const TUpper &	getUpper () const
TUpper &	updUpper ()
const TAsVec &	getAsVec () const
TAsVec &	updAsVec ()
const E &	getEltDiag (int i) const
E &	updEltDiag (int i)
const E &	getEltLower (int i, int j) const
E &	updEltLower (int i, int j)
const EHerm &	getEltUpper (int i, int j) const
EHerm &	updEltUpper (int i, int j)
TRow	sum () const
Static Public Member Functions
static const SymMat &	getAs (const ELT *p)
static SymMat &	updAs (ELT *p)
static TPacked	getNaN ()
static double	getDefaultTolerance ()
	For approximate comparisions, the default tolerance to use for a matrix is its shortest dimension times its elements' default tolerance.
Friends
class	SymMat

---

Detailed Description

template<int M, class ELT, int RS>
class SimTK::SymMat< M, ELT, RS >

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

---

Member Typedef Documentation

template<int M, class ELT, int RS>

typedef SymMat<M,E,RS> SimTK::SymMat< M, ELT, RS >::T

template<int M, class ELT, int RS>

typedef SymMat<M,ENeg,RS> SimTK::SymMat< M, ELT, RS >::TNeg

template<int M, class ELT, int RS>

typedef SymMat<M,EWithoutNegator,RS> SimTK::SymMat< M, ELT, RS >::TWithoutNegator

template<int M, class ELT, int RS>

typedef SymMat<M,EReal,RS*CNT<E>::RealStrideFactor> SimTK::SymMat< M, ELT, RS >::TReal

template<int M, class ELT, int RS>

typedef SymMat<M,EImag,RS*CNT<E>::RealStrideFactor> SimTK::SymMat< M, ELT, RS >::TImag

template<int M, class ELT, int RS>

typedef SymMat<M,EComplex,RS> SimTK::SymMat< M, ELT, RS >::TComplex

template<int M, class ELT, int RS>

typedef T SimTK::SymMat< M, ELT, RS >::THerm

template<int M, class ELT, int RS>

typedef SymMat<M,EHerm,RS> SimTK::SymMat< M, ELT, RS >::TPosTrans

template<int M, class ELT, int RS>

typedef E SimTK::SymMat< M, ELT, RS >::TElement

template<int M, class ELT, int RS>

typedef Vec<M,E,RS> SimTK::SymMat< M, ELT, RS >::TDiag

template<int M, class ELT, int RS>

typedef Vec<(M*(M-1))/2,E,RS SimTK::SymMat< M, ELT, RS >::TLower)

template<int M, class ELT, int RS>

typedef Vec<(M*(M-1))/2,EHerm,RS SimTK::SymMat< M, ELT, RS >::TUpper)

template<int M, class ELT, int RS>

typedef Vec<(M*(M+1))/2,E,RS SimTK::SymMat< M, ELT, RS >::TAsVec)

template<int M, class ELT, int RS>

typedef Row<M,E,1> SimTK::SymMat< M, ELT, RS >::TRow

template<int M, class ELT, int RS>

typedef Vec<M,E,1> SimTK::SymMat< M, ELT, RS >::TCol

template<int M, class ELT, int RS>

typedef SymMat<M,ESqrt,1> SimTK::SymMat< M, ELT, RS >::TSqrt

template<int M, class ELT, int RS>

typedef SymMat<M,EAbs,1> SimTK::SymMat< M, ELT, RS >::TAbs

template<int M, class ELT, int RS>

typedef SymMat<M,EStandard,1> SimTK::SymMat< M, ELT, RS >::TStandard

template<int M, class ELT, int RS>

typedef SymMat<M,EInvert,1> SimTK::SymMat< M, ELT, RS >::TInvert

template<int M, class ELT, int RS>

typedef SymMat<M,ENormalize,1> SimTK::SymMat< M, ELT, RS >::TNormalize

template<int M, class ELT, int RS>

typedef SymMat<M,ESqHermT,1> SimTK::SymMat< M, ELT, RS >::TSqHermT

template<int M, class ELT, int RS>

typedef SymMat<M,ESqTHerm,1> SimTK::SymMat< M, ELT, RS >::TSqTHerm

template<int M, class ELT, int RS>

typedef SymMat<M,E,1> SimTK::SymMat< M, ELT, RS >::TPacked

template<int M, class ELT, int RS>

typedef EScalar SimTK::SymMat< M, ELT, RS >::Scalar

template<int M, class ELT, int RS>

typedef EULessScalar SimTK::SymMat< M, ELT, RS >::ULessScalar

template<int M, class ELT, int RS>

typedef ENumber SimTK::SymMat< M, ELT, RS >::Number

template<int M, class ELT, int RS>

typedef EStdNumber SimTK::SymMat< M, ELT, RS >::StdNumber

template<int M, class ELT, int RS>

typedef EPrecision SimTK::SymMat< M, ELT, RS >::Precision

template<int M, class ELT, int RS>

typedef EScalarNormSq SimTK::SymMat< M, ELT, RS >::ScalarNormSq

---

Member Enumeration Documentation

template<int M, class ELT, int RS>

anonymous enum

Enumerator:

NRows
NCols
NDiagElements
NLowerElements
NPackedElements
NActualElements
NActualScalars
RowSpacing
ColSpacing
ImagOffset
RealStrideFactor
ArgDepth
IsScalar
IsULessScalar
IsNumber
IsStdNumber
IsPrecision
SignInterpretation

---

Constructor & Destructor Documentation

template<int M, class ELT, int RS>

SimTK::SymMat< M, ELT, RS >::SymMat

(

)

[inline]

Default construction initializes to NaN when debugging but is left uninitialized otherwise.

template<int M, class ELT, int RS>

SimTK::SymMat< M, ELT, RS >::SymMat

(

const SymMat< M, ELT, RS > &

src

)

[inline]

Copy constructor.

template<int M, class ELT, int RS>

template<class EE , int CSS, int RSS>

SimTK::SymMat< M, ELT, RS >::SymMat

(

const Mat< M, M, EE, CSS, RSS > &

m

)

[inline, explicit]

This is an explicit conversion from square Mat of right size, assuming that the source matrix is symmetric to within a reasonable numerical tolerance.

In Debug mode we'll test that assumption and throw an exception if it is wrong. In Release mode you're on your own. All the elements of the source Mat are used; off-diagonal elements (i,j) are averaged with their corresponding element (j,i); the imaginary part of the diagonal is set exactly to zero. If you don't want to spend the flops to average the off-diagonals, and you're sure the source is symmetric, use either setFromLower() or setFromUpper() which will just copy the elements.

See also:

setFromLower(), setFromUpper()

template<int M, class ELT, int RS>

template<int RSS>

SimTK::SymMat< M, ELT, RS >::SymMat

(

const SymMat< M, E, RSS > &

src

)

[inline]

This is an implicit conversion from a SymMat of the same length and element type but with different spacing.

template<int M, class ELT, int RS>

template<int RSS>

SimTK::SymMat< M, ELT, RS >::SymMat

(

const SymMat< M, ENeg, RSS > &

src

)

[inline]

This is an implicit conversion from a SymMat of the same length and negated element type, possibly with different spacing.

template<int M, class ELT, int RS>

template<class EE , int RSS>

SimTK::SymMat< M, ELT, RS >::SymMat

(

const SymMat< M, EE, RSS > &

src

)

[inline, explicit]

Construct a SymMat from a SymMat of the same dimensions, with any element type and spacing.

Works as long as the element types are assignment compatible.

template<int M, class ELT, int RS>

SimTK::SymMat< M, ELT, RS >::SymMat

(

const E &

e

)

[inline, explicit]

template<int M, class ELT, int RS>

SimTK::SymMat< M, ELT, RS >::SymMat

(

const ENeg &

e

)

[inline, explicit]

template<int M, class ELT, int RS>

SimTK::SymMat< M, ELT, RS >::SymMat

(

int

i

)

[inline, explicit]

template<int M, class ELT, int RS>

SimTK::SymMat< M, ELT, RS >::SymMat	(	const E &	e0,
		const E &	e1,
		const E &	e2
	)		[inline]

A bevy of constructors from individual exact-match elements IN ROW ORDER, giving the LOWER TRIANGLE, like this:

            a
            b c
            d e f
            g h i j
        

Note that this will be mapped to our diagonal/lower layout, which in the above example would be:

            [a c f j][b d g e h i]
        

template<int M, class ELT, int RS>

SimTK::SymMat< M, ELT, RS >::SymMat	(	const E &	e0,
		const E &	e1,
		const E &	e2,
		const E &	e3,
		const E &	e4,
		const E &	e5
	)		[inline]

template<int M, class ELT, int RS>

SimTK::SymMat< M, ELT, RS >::SymMat	(	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, class ELT, int RS>

SimTK::SymMat< M, ELT, RS >::SymMat	(	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, class ELT, int RS>

SimTK::SymMat< M, ELT, RS >::SymMat	(	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,
		const E &	e16,
		const E &	e17,
		const E &	e18,
		const E &	e19,
		const E &	e20
	)		[inline]

template<int M, class ELT, int RS>

template<class EE >

SimTK::SymMat< M, ELT, RS >::SymMat

(

const EE *

p

)

[inline, explicit]

---

Member Function Documentation

template<int M, class ELT, int RS>

int SimTK::SymMat< M, ELT, RS >::size

(

)

const [inline]

template<int M, class ELT, int RS>

int SimTK::SymMat< M, ELT, RS >::nrow

(

)

const [inline]

template<int M, class ELT, int RS>

int SimTK::SymMat< M, ELT, RS >::ncol

(

)

const [inline]

template<int M, class ELT, int RS>

ScalarNormSq SimTK::SymMat< M, ELT, RS >::scalarNormSqr

(

)

const [inline]

template<int M, class ELT, int RS>

TSqrt SimTK::SymMat< M, ELT, RS >::sqrt

(

)

const [inline]

template<int M, class ELT, int RS>

TAbs SimTK::SymMat< M, ELT, RS >::abs

(

)

const [inline]

template<int M, class ELT, int RS>

TStandard SimTK::SymMat< M, ELT, RS >::standardize

(

)

const [inline]

template<int M, class ELT, int RS>

EStandard SimTK::SymMat< M, ELT, RS >::trace

(

)

const [inline]

template<int M, class ELT, int RS>

SymMat& SimTK::SymMat< M, ELT, RS >::operator=

(

const SymMat< M, ELT, RS > &

src

)

[inline]

Copy assignment; no harm if source and this are the same matrix.

template<int M, class ELT, int RS>

template<class EE , int CSS, int RSS>

SymMat& SimTK::SymMat< M, ELT, RS >::setFromLower

(

const Mat< M, M, EE, CSS, RSS > &

m

)

[inline]

Create a new SymMat of this type from a square Mat of the right size, looking only at lower elements and the real part of the diagonal.

template<int M, class ELT, int RS>

template<class EE , int CSS, int RSS>

SymMat& SimTK::SymMat< M, ELT, RS >::setFromUpper

(

const Mat< M, M, EE, CSS, RSS > &

m

)

[inline]

Create a new SymMat of this type from a square Mat of the right size, looking only at upper elements and the real part of the diagonal.

Note that the SymMat's stored elements are still in its lower triangle; they are just initialized from the Mat's upper triangle. There is no transposing of elements here; we simply copy the upper elements of the Mat to the corresponding lower elements of the SymMat.

template<int M, class ELT, int RS>

template<class EE , int CSS, int RSS>

SymMat& SimTK::SymMat< M, ELT, RS >::setFromSymmetric

(

const Mat< M, M, EE, CSS, RSS > &

m

)

[inline]

Create a new SymMat of this type from a square Mat of the right size, that is expected to be symmetric (hermitian) to within a tolerance.

All elements are used; we average the upper and lower elements of the Mat to produce the corresponding element of the SymMat.

template<int M, class ELT, int RS>

template<class EE >

SymMat& SimTK::SymMat< M, ELT, RS >::operator=

(

const EE *

p

)

[inline]

template<int M, class ELT, int RS>

template<class EE , int RSS>

SymMat& SimTK::SymMat< M, ELT, RS >::operator=

(

const SymMat< M, EE, RSS > &

mm

)

[inline]

template<int M, class ELT, int RS>

template<class EE , int RSS>

SymMat& SimTK::SymMat< M, ELT, RS >::operator+=

(

const SymMat< M, EE, RSS > &

mm

)

[inline]

template<int M, class ELT, int RS>

template<class EE , int RSS>

SymMat& SimTK::SymMat< M, ELT, RS >::operator+=

(

const SymMat< M, negator< EE >, RSS > &

mm

)

[inline]

template<int M, class ELT, int RS>

template<class EE , int RSS>

SymMat& SimTK::SymMat< M, ELT, RS >::operator-=

(

const SymMat< M, EE, RSS > &

mm

)

[inline]

template<int M, class ELT, int RS>

template<class EE , int RSS>

SymMat& SimTK::SymMat< M, ELT, RS >::operator-=

(

const SymMat< M, negator< EE >, RSS > &

mm

)

[inline]

template<int M, class ELT, int RS>

template<class EE , int RSS>

SymMat& SimTK::SymMat< M, ELT, RS >::operator*=

(

const SymMat< M, EE, RSS > &

mm

)

[inline]

template<int M, class ELT, int RS>

template<class E2 , int RS2>

Result<SymMat<M,E2,RS2> >::Add SimTK::SymMat< M, ELT, RS >::conformingAdd

(

const SymMat< M, E2, RS2 > &

r

)

const [inline]

template<int M, class ELT, int RS>

template<class E2 , int RS2>

Result<SymMat<M,E2,RS2> >::Sub SimTK::SymMat< M, ELT, RS >::conformingSubtract

(

const SymMat< M, E2, RS2 > &

r

)

const [inline]

template<int M, class ELT, int RS>

template<class E2 , int RS2>

Result<SymMat<M,E2,RS2> >::Mul SimTK::SymMat< M, ELT, RS >::conformingMultiply

(

const SymMat< M, E2, RS2 > &

s

)

const [inline]

template<int M, class ELT, int RS>

const E& SimTK::SymMat< M, ELT, RS >::operator()	(	int	i,
		int	j
	)		const [inline]

template<int M, class ELT, int RS>

E& SimTK::SymMat< M, ELT, RS >::operator()	(	int	i,
		int	j
	)		[inline]

template<int M, class ELT, int RS>

TRow SimTK::SymMat< M, ELT, RS >::operator[]

(

int

i

)

const [inline]

template<int M, class ELT, int RS>

TCol SimTK::SymMat< M, ELT, RS >::operator()

(

int

j

)

const [inline]

template<int M, class ELT, int RS>

ScalarNormSq SimTK::SymMat< M, ELT, RS >::normSqr

(

)

const [inline]

template<int M, class ELT, int RS>

CNT<ScalarNormSq>::TSqrt SimTK::SymMat< M, ELT, RS >::norm

(

)

const [inline]

template<int M, class ELT, int RS>

TNormalize SimTK::SymMat< M, ELT, RS >::normalize

(

)

const [inline]

There is no conventional meaning for normalize() applied to a matrix.

We choose to define it as follows: If the elements of this SymMat are scalars, the result is what you get by dividing each element by the Frobenius norm() calculated above. If the elements are not* scalars, then the elements are *separately* normalized.

Normalize returns a matrix of the same dimension but in new, packed storage and with a return type that does not include negator<> even if the original SymMat<> does, because we can eliminate the negation here almost for free. But we can't standardize (change conjugate to complex) for free, so we'll retain conjugates if there are any.

template<int M, class ELT, int RS>

TInvert SimTK::SymMat< M, ELT, RS >::invert

(

)

const [inline]

template<int M, class ELT, int RS>

const SymMat& SimTK::SymMat< M, ELT, RS >::operator+

(

)

const [inline]

template<int M, class ELT, int RS>

const TNeg& SimTK::SymMat< M, ELT, RS >::operator-

(

)

const [inline]

template<int M, class ELT, int RS>

TNeg& SimTK::SymMat< M, ELT, RS >::operator-

(

)

[inline]

template<int M, class ELT, int RS>

const THerm& SimTK::SymMat< M, ELT, RS >::operator~

(

)

const [inline]

template<int M, class ELT, int RS>

THerm& SimTK::SymMat< M, ELT, RS >::operator~

(

)

[inline]

template<int M, class ELT, int RS>

const TNeg& SimTK::SymMat< M, ELT, RS >::negate

(

)

const [inline]

template<int M, class ELT, int RS>

TNeg& SimTK::SymMat< M, ELT, RS >::updNegate

(

)

[inline]

template<int M, class ELT, int RS>

const THerm& SimTK::SymMat< M, ELT, RS >::transpose

(

)

const [inline]

template<int M, class ELT, int RS>

THerm& SimTK::SymMat< M, ELT, RS >::updTranspose

(

)

[inline]

template<int M, class ELT, int RS>

const TPosTrans& SimTK::SymMat< M, ELT, RS >::positionalTranspose

(

)

const [inline]

template<int M, class ELT, int RS>

TPosTrans& SimTK::SymMat< M, ELT, RS >::updPositionalTranspose

(

)

[inline]

template<int M, class ELT, int RS>

const TReal& SimTK::SymMat< M, ELT, RS >::real

(

)

const [inline]

template<int M, class ELT, int RS>

TReal& SimTK::SymMat< M, ELT, RS >::real

(

)

[inline]

template<int M, class ELT, int RS>

const TImag& SimTK::SymMat< M, ELT, RS >::imag

(

)

const [inline]

template<int M, class ELT, int RS>

TImag& SimTK::SymMat< M, ELT, RS >::imag

(

)

[inline]

template<int M, class ELT, int RS>

const TWithoutNegator& SimTK::SymMat< M, ELT, RS >::castAwayNegatorIfAny

(

)

const [inline]

template<int M, class ELT, int RS>

TWithoutNegator& SimTK::SymMat< M, ELT, RS >::updCastAwayNegatorIfAny

(

)

[inline]

template<int M, class ELT, int RS>

template<class EE >

SymMat<M, typename CNT<E>::template Result<EE>::Mul> SimTK::SymMat< M, ELT, RS >::scalarMultiply

(

const EE &

e

)

const [inline]

template<int M, class ELT, int RS>

template<class EE >

SymMat<M, typename CNT<EE>::template Result<E>::Mul> SimTK::SymMat< M, ELT, RS >::scalarMultiplyFromLeft

(

const EE &

e

)

const [inline]

template<int M, class ELT, int RS>

template<class EE >

SymMat<M, typename CNT<E>::template Result<EE>::Dvd> SimTK::SymMat< M, ELT, RS >::scalarDivide

(

const EE &

e

)

const [inline]

template<int M, class ELT, int RS>

template<class EE >

SymMat<M, typename CNT<EE>::template Result<E>::Dvd> SimTK::SymMat< M, ELT, RS >::scalarDivideFromLeft

(

const EE &

e

)

const [inline]

template<int M, class ELT, int RS>

template<class EE >

SymMat<M, typename CNT<E>::template Result<EE>::Add> SimTK::SymMat< M, ELT, RS >::scalarAdd

(

const EE &

e

)

const [inline]

template<int M, class ELT, int RS>

template<class EE >

SymMat<M, typename CNT<E>::template Result<EE>::Sub> SimTK::SymMat< M, ELT, RS >::scalarSubtract

(

const EE &

e

)

const [inline]

template<int M, class ELT, int RS>

template<class EE >

SymMat<M, typename CNT<EE>::template Result<E>::Sub> SimTK::SymMat< M, ELT, RS >::scalarSubtractFromLeft

(

const EE &

e

)

const [inline]

template<int M, class ELT, int RS>

template<class EE >

SymMat& SimTK::SymMat< M, ELT, RS >::operator=

(

const EE &

e

)

[inline]

template<int M, class ELT, int RS>

template<class EE >

SymMat& SimTK::SymMat< M, ELT, RS >::operator+=

(

const EE &

e

)

[inline]

template<int M, class ELT, int RS>

template<class EE >

SymMat& SimTK::SymMat< M, ELT, RS >::operator-=

(

const EE &

e

)

[inline]

template<int M, class ELT, int RS>

template<class EE >

SymMat& SimTK::SymMat< M, ELT, RS >::operator*=

(

const EE &

e

)

[inline]

template<int M, class ELT, int RS>

template<class EE >

SymMat& SimTK::SymMat< M, ELT, RS >::operator/=

(

const EE &

e

)

[inline]

template<int M, class ELT, int RS>

template<class EE >

SymMat& SimTK::SymMat< M, ELT, RS >::scalarEq

(

const EE &

ee

)

[inline]

template<int M, class ELT, int RS>

template<class EE >

SymMat& SimTK::SymMat< M, ELT, RS >::scalarPlusEq

(

const EE &

ee

)

[inline]

template<int M, class ELT, int RS>

template<class EE >

SymMat& SimTK::SymMat< M, ELT, RS >::scalarMinusEq

(

const EE &

ee

)

[inline]

template<int M, class ELT, int RS>

template<class EE >

SymMat& SimTK::SymMat< M, ELT, RS >::scalarMinusEqFromLeft

(

const EE &

ee

)

[inline]

template<int M, class ELT, int RS>

template<class EE >

SymMat& SimTK::SymMat< M, ELT, RS >::scalarTimesEq

(

const EE &

ee

)

[inline]

template<int M, class ELT, int RS>

template<class EE >

SymMat& SimTK::SymMat< M, ELT, RS >::scalarTimesEqFromLeft

(

const EE &

ee

)

[inline]

template<int M, class ELT, int RS>

template<class EE >

SymMat& SimTK::SymMat< M, ELT, RS >::scalarDivideEq

(

const EE &

ee

)

[inline]

template<int M, class ELT, int RS>

template<class EE >

SymMat& SimTK::SymMat< M, ELT, RS >::scalarDivideEqFromLeft

(

const EE &

ee

)

[inline]

template<int M, class ELT, int RS>

void SimTK::SymMat< M, ELT, RS >::setToNaN

(

)

[inline]

template<int M, class ELT, int RS>

void SimTK::SymMat< M, ELT, RS >::setToZero

(

)

[inline]

template<int M, class ELT, int RS>

static const SymMat& SimTK::SymMat< M, ELT, RS >::getAs

(

const ELT *

p

)

[inline, static]

template<int M, class ELT, int RS>

static SymMat& SimTK::SymMat< M, ELT, RS >::updAs

(

ELT *

p

)

[inline, static]

template<int M, class ELT, int RS>

static TPacked SimTK::SymMat< M, ELT, RS >::getNaN

(

)

[inline, static]

template<int M, class ELT, int RS>

bool SimTK::SymMat< M, ELT, RS >::isNaN

(

)

const [inline]

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

template<int M, class ELT, int RS>

bool SimTK::SymMat< M, ELT, RS >::isInf

(

)

const [inline]

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

template<int M, class ELT, int RS>

bool SimTK::SymMat< M, ELT, RS >::isFinite

(

)

const [inline]

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

template<int M, class ELT, int RS>

static double SimTK::SymMat< M, ELT, 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, class ELT, int RS>

template<class E2 , int RS2>

bool SimTK::SymMat< M, ELT, RS >::isNumericallyEqual	(	const SymMat< M, E2, 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, class ELT, int RS>

template<class E2 , int RS2>

bool SimTK::SymMat< M, ELT, RS >::isNumericallyEqual

(

const SymMat< M, E2, 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, class ELT, int RS>

bool SimTK::SymMat< M, ELT, 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, class ELT, int RS>

TRow SimTK::SymMat< M, ELT, RS >::row

(

int

i

)

const [inline]

template<int M, class ELT, int RS>

TCol SimTK::SymMat< M, ELT, RS >::col

(

int

j

)

const [inline]

template<int M, class ELT, int RS>

E SimTK::SymMat< M, ELT, RS >::elt	(	int	i,
		int	j
	)		const [inline]

Return a value for any element of a symmetric matrix, even those in the upper triangle which aren't actually stored anywhere.

For elements whose underlying numeric types are complex, this will require computation in order to return the conjugates. So we always have to copy out the element, and may also have to conjugate it (one flop per complex number).

template<int M, class ELT, int RS>

const TDiag& SimTK::SymMat< M, ELT, RS >::getDiag

(

)

const [inline]

template<int M, class ELT, int RS>

TDiag& SimTK::SymMat< M, ELT, RS >::updDiag

(

)

[inline]

template<int M, class ELT, int RS>

const TDiag& SimTK::SymMat< M, ELT, RS >::diag

(

)

const [inline]

template<int M, class ELT, int RS>

TDiag& SimTK::SymMat< M, ELT, RS >::diag

(

)

[inline]

template<int M, class ELT, int RS>

const TLower& SimTK::SymMat< M, ELT, RS >::getLower

(

)

const [inline]

template<int M, class ELT, int RS>

TLower& SimTK::SymMat< M, ELT, RS >::updLower

(

)

[inline]

template<int M, class ELT, int RS>

const TUpper& SimTK::SymMat< M, ELT, RS >::getUpper

(

)

const [inline]

template<int M, class ELT, int RS>

TUpper& SimTK::SymMat< M, ELT, RS >::updUpper

(

)

[inline]

template<int M, class ELT, int RS>

const TAsVec& SimTK::SymMat< M, ELT, RS >::getAsVec

(

)

const [inline]

template<int M, class ELT, int RS>

TAsVec& SimTK::SymMat< M, ELT, RS >::updAsVec

(

)

[inline]

template<int M, class ELT, int RS>

const E& SimTK::SymMat< M, ELT, RS >::getEltDiag

(

int

i

)

const [inline]

template<int M, class ELT, int RS>

E& SimTK::SymMat< M, ELT, RS >::updEltDiag

(

int

i

)

[inline]

template<int M, class ELT, int RS>

const E& SimTK::SymMat< M, ELT, RS >::getEltLower	(	int	i,
		int	j
	)		const [inline]

template<int M, class ELT, int RS>

E& SimTK::SymMat< M, ELT, RS >::updEltLower	(	int	i,
		int	j
	)		[inline]

template<int M, class ELT, int RS>

const EHerm& SimTK::SymMat< M, ELT, RS >::getEltUpper	(	int	i,
		int	j
	)		const [inline]

template<int M, class ELT, int RS>

EHerm& SimTK::SymMat< M, ELT, RS >::updEltUpper	(	int	i,
		int	j
	)		[inline]

template<int M, class ELT, int RS>

TRow SimTK::SymMat< M, ELT, RS >::sum

(

)

const [inline]

---

Friends And Related Function Documentation

template<int M, class ELT, int RS>

friend class SymMat [friend]

---

The documentation for this class was generated from the following file:

• SymMat.h