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

#include <SymMat.h>

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

	SymMat (const SymMat &src)
	Copy constructor. More...

SymMat &	operator= (const SymMat &src)
	Copy assignment; no harm if source and this are the same matrix. More...

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

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

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

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

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

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

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

	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: More...

	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

template<class E2 , int RS2>
EltResult< E2 >::Mul	elementwiseMultiply (const SymMat< M, E2, RS2 > &r) const

template<class E2 , int RS2>
EltResult< E2 >::Dvd	elementwiseDivide (const SymMat< M, E2, RS2 > &r) 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. More...

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

bool	isInf () const
	Return true if any element of this SymMat contains a +Inf or -Inf somewhere but no element contains a NaN anywhere. More...

bool	isFinite () const
	Return true if no element contains an Infinity or a NaN. More...

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

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

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). More...

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

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	colSum () const
	Returns a row vector (Row) containing the column sums of this matrix. More...

TRow	sum () const
	This is an alternate name for colSum(); behaves like the Matlab function of the same name. More...

TCol	rowSum () const
	Returns a column vector (Vec) containing the row sums of this matrix. More...

Static Public Member Functions
static int	size ()

static int	nrow ()

static int	ncol ()

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

Friends
template<int MM, class EE , int RSS>
class	SymMat

Related Functions
(Note that these are not member functions.)
template<int M, class E , int RS>
void	writeUnformatted (std::ostream &o, const SymMat< M, E, RS > &v)
	Specialize for SymMat<M,E,RS> delegating to Row<M,E,RS> with newlines separating the rows, but no final newline. More...

template<int M, class E , int RS>
bool	readUnformatted (std::istream &in, SymMat< M, E, RS > &v)
	Specialize for SymMat<M,E,RS>. More...

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 )

inlineexplicit

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 )

inlineexplicit

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 )

inlineexplicit

template<int M, class ELT, int RS>

SimTK::SymMat< M, ELT, RS >::SymMat ( const ENeg & e )

inlineexplicit

template<int M, class ELT, int RS>

SimTK::SymMat< M, ELT, RS >::SymMat ( int i )

inlineexplicit

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 )

inlineexplicit

Member Function Documentation

template<int M, class ELT, int RS>

static int SimTK::SymMat< M, ELT, RS >::size ( )

inlinestatic

template<int M, class ELT, int RS>

static int SimTK::SymMat< M, ELT, RS >::nrow ( )

inlinestatic

template<int M, class ELT, int RS>

static int SimTK::SymMat< M, ELT, RS >::ncol ( )

inlinestatic

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>

template<class E2 , int RS2>

EltResult<E2>::Mul SimTK::SymMat< M, ELT, RS >::elementwiseMultiply ( const SymMat< M, E2, RS2 > & r ) const

inline

template<int M, class ELT, int RS>

template<class E2 , int RS2>

EltResult<E2>::Dvd SimTK::SymMat< M, ELT, RS >::elementwiseDivide ( const SymMat< M, E2, RS2 > & r ) 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 )

inlinestatic

template<int M, class ELT, int RS>

static SymMat& SimTK::SymMat< M, ELT, RS >::updAs ( ELT * p )

inlinestatic

template<int M, class ELT, int RS>

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

inlinestatic

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

inlinestatic

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 >::colSum ( ) const

inline

Returns a row vector (Row) containing the column sums of this matrix.

template<int M, class ELT, int RS>

TRow SimTK::SymMat< M, ELT, RS >::sum ( ) const

inline

This is an alternate name for colSum(); behaves like the Matlab function of the same name.

template<int M, class ELT, int RS>

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

inline

Returns a column vector (Vec) containing the row sums of this matrix.

This will be the conjugate transpose of the column sums.

Friends And Related Function Documentation

template<int M, class ELT, int RS>

template<int MM, class EE , int RSS>

friend class SymMat

friend

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

Classes

Public Types

Public Member Functions

Static Public Member Functions

Friends

Related Functions

Detailed Description

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

Member Typedef Documentation

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

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