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

typedef ENumber Number

typedef EPrecision Precision

typedef EScalar Scalar

typedef EScalarNormSq ScalarNormSq

typedef EStdNumber StdNumber

typedef SymMat<M,E,RS> T

typedef SymMat<M,EAbs,1> TAbs

typedef Vec<(M*(M+1))/2,E,RS TAsVec)

typedef Vec<M,E,1> TCol

typedef SymMat<M,EComplex,RS> TComplex

typedef Vec<M,E,RS> TDiag

typedef E TElement

typedef T THerm

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

typedef SymMat<M,EInvert,1> TInvert

typedef Vec<(M*(M-1))/2,E,RS TLower)

typedef SymMat<M,ENeg,RS> TNeg

typedef SymMat<M,ENormalize,1> TNormalize

typedef SymMat<M,E,1> TPacked

typedef SymMat<M,EHerm,RS> TPosTrans

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

typedef Row<M,E,1> TRow

typedef SymMat<M,ESqHermT,1> TSqHermT

typedef SymMat<M,ESqrt,1> TSqrt

typedef SymMat<M,ESqTHerm,1> TSqTHerm

typedef SymMat<M,EStandard,1> TStandard

typedef Vec<(M*(M-1))/2,EHerm,RS TUpper)

typedef SymMat<M,EWithoutNegator,RS> TWithoutNegator

typedef EULessScalar ULessScalar

---

Member Enumeration Documentation

anonymous enum

Enumerator:

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

---

Constructor & Destructor Documentation

SymMat

(

)

[inline]

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

SymMat

(

const SymMat< M, ELT, RS > &

src

)

[inline]

Copy constructor.

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

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.

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.

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.

SymMat

(

const E &

e

)

[inline, explicit]

SymMat

(

const ENeg &

e

)

[inline, explicit]

SymMat

(

int

i

)

[inline, explicit]

Referenced by SymMat< 3, P >::SymMat().

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]
        

SymMat	(	const E &	e0,
		const E &	e1,
		const E &	e2,
		const E &	e3,
		const E &	e4,
		const E &	e5
	)			[inline]

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]

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]

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]

SymMat

(

const EE *

p

)

[inline, explicit]

---

Member Function Documentation

TAbs abs

(

)

const [inline]

Referenced by SimTK::abs(), and SymMat< 3, P >::abs().

const TWithoutNegator& castAwayNegatorIfAny

(

)

const [inline]

Referenced by SymMat< 3, P >::normalize().

TCol col

(

int

j

)

const [inline]

Referenced by SymMat< 3, P >::operator()().

Result<SymMat<M,E2,RS2> >::Add conformingAdd

(

const SymMat< M, E2, RS2 > &

r

)

const [inline]

Referenced by Mat< 3, 3, P >::conformingAdd().

Result<SymMat<M,E2,RS2> >::Mul conformingMultiply

(

const SymMat< M, E2, RS2 > &

s

)

const [inline]

Result<SymMat<M,E2,RS2> >::Sub conformingSubtract

(

const SymMat< M, E2, RS2 > &

r

)

const [inline]

Referenced by Mat< 3, 3, P >::conformingSubtractFromLeft().

TDiag& diag

(

)

[inline]

const TDiag& diag

(

)

const [inline]

Referenced by SimTK::det(), SimTK::inverse(), SymMat< 3, P >::isNumericallyEqual(), Inertia_< Real >::isValidInertiaMatrix(), Mat< 3, 3, P >::Mat(), SymMat< 3, P >::scalarSubtract(), and SymMat< 3, P >::scalarSubtractFromLeft().

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

static const SymMat& getAs

(

const ELT *

p

)

[inline, static]

Referenced by SymMat< 3, P >::getAsVec(), and SymMat< 3, P >::getLower().

const TAsVec& getAsVec

(

)

const [inline]

Referenced by SymMat< 3, P >::abs(), SymMat< 3, P >::conformingAdd(), SymMat< 3, P >::conformingSubtract(), SymMat< 3, P >::isFinite(), SymMat< 3, P >::isInf(), SymMat< 3, P >::isNaN(), SymMat< 3, P >::isNumericallyEqual(), SymMat< 3, P >::normalize(), Test::numericallyEqual(), SymMat< 3, P >::operator+=(), SymMat< 3, P >::operator-=(), SymMat< 3, P >::operator=(), SimTK::operator==(), SymMat< 3, P >::scalarDivide(), SymMat< 3, P >::scalarDivideFromLeft(), SymMat< 3, P >::scalarMultiply(), SymMat< 3, P >::scalarMultiplyFromLeft(), SymMat< 3, P >::sqrt(), SymMat< 3, P >::standardize(), and SymMat< 3, P >::SymMat().

static double getDefaultTolerance

(

)

[inline, static]

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

Referenced by SymMat< 3, P >::getDefaultTolerance(), and SymMat< 3, P >::isNumericallyEqual().

const TDiag& getDiag

(

)

const [inline]

Referenced by SymMat< 3, P >::diag(), SymMat< 3, P >::getEltDiag(), SimTK::max(), SimTK::min(), SymMat< 3, P >::operator()(), SimTK::operator*(), SimTK::operator==(), SymMat< 3, P >::scalarNormSqr(), SymMat< 3, P >::sum(), and SymMat< 3, P >::trace().

const E& getEltDiag

(

int

i

)

const [inline]

Referenced by SymMat< 3, P >::col(), SimTK::det(), SymMat< 3, P >::elt(), and SymMat< 3, P >::row().

const E& getEltLower	(	int	i,
		int	j
	)			const [inline]

Referenced by SymMat< 3, P >::col(), SimTK::det(), SymMat< 3, P >::elt(), Mat< 3, 3, P >::Mat(), SimTK::max(), SimTK::min(), SymMat< 3, P >::operator()(), SimTK::operator*(), SimTK::operator==(), SymMat< 3, P >::row(), and SymMat< 3, P >::sum().

const EHerm& getEltUpper	(	int	i,
		int	j
	)			const [inline]

Referenced by SymMat< 3, P >::col(), SimTK::det(), SymMat< 3, P >::elt(), Mat< 3, 3, P >::Mat(), SimTK::operator*(), SimTK::operator==(), and SymMat< 3, P >::row().

const TLower& getLower

(

)

const [inline]

Referenced by SymMat< 3, P >::getEltLower(), SymMat< 3, P >::getUpper(), SymMat< 3, P >::isNumericallyEqual(), and SymMat< 3, P >::scalarNormSqr().

static TPacked getNaN

(

)

[inline, static]

const TUpper& getUpper

(

)

const [inline]

Referenced by SymMat< 3, P >::getEltUpper().

TImag& imag

(

)

[inline]

const TImag& imag

(

)

const [inline]

TInvert invert

(

)

const [inline]

bool isFinite

(

)

const [inline]

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

bool isInf

(

)

const [inline]

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

bool isNaN

(

)

const [inline]

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

Referenced by Inertia_< Real >::isValidInertiaMatrix().

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

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

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

Referenced by SymMat< 3, P >::isNumericallyEqual().

int ncol

(

)

const [inline]

const TNeg& negate

(

)

const [inline]

Referenced by SymMat< 3, P >::operator-().

CNT<ScalarNormSq>::TSqrt norm

(

)

const [inline]

Referenced by SymMat< 3, P >::normalize().

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

ScalarNormSq normSqr

(

)

const [inline]

int nrow

(

)

const [inline]

TCol operator()

(

int

j

)

const [inline]

E& operator()	(	int	i,
		int	j
	)			[inline]

const E& operator()	(	int	i,
		int	j
	)			const [inline]

SymMat& operator*=

(

const EE &

e

)

[inline]

SymMat& operator*=

(

const SymMat< M, EE, RSS > &

mm

)

[inline]

const SymMat& operator+

(

)

const [inline]

SymMat& operator+=

(

const EE &

e

)

[inline]

SymMat& operator+=

(

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

mm

)

[inline]

SymMat& operator+=

(

const SymMat< M, EE, RSS > &

mm

)

[inline]

TNeg& operator-

(

)

[inline]

const TNeg& operator-

(

)

const [inline]

SymMat& operator-=

(

const EE &

e

)

[inline]

SymMat& operator-=

(

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

mm

)

[inline]

SymMat& operator-=

(

const SymMat< M, EE, RSS > &

mm

)

[inline]

SymMat& operator/=

(

const EE &

e

)

[inline]

SymMat& operator=

(

const EE &

e

)

[inline]

SymMat& operator=

(

const SymMat< M, EE, RSS > &

mm

)

[inline]

SymMat& operator=

(

const EE *

p

)

[inline]

SymMat& operator=

(

const SymMat< M, ELT, RS > &

src

)

[inline]

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

TRow operator[]

(

int

i

)

const [inline]

THerm& operator~

(

)

[inline]

const THerm& operator~

(

)

const [inline]

const TPosTrans& positionalTranspose

(

)

const [inline]

TReal& real

(

)

[inline]

const TReal& real

(

)

const [inline]

Referenced by SymMat< 3, P >::operator=(), and SymMat< 3, P >::SymMat().

TRow row

(

int

i

)

const [inline]

Referenced by SymMat< 3, P >::operator[]().

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

(

const EE &

e

)

const [inline]

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

(

const EE &

e

)

const [inline]

SymMat& scalarDivideEq

(

const EE &

ee

)

[inline]

Referenced by SymMat< 3, P >::operator/=().

SymMat& scalarDivideEqFromLeft

(

const EE &

ee

)

[inline]

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

(

const EE &

e

)

const [inline]

SymMat& scalarEq

(

const EE &

ee

)

[inline]

Referenced by SymMat< 3, P >::operator=().

SymMat& scalarMinusEq

(

const EE &

ee

)

[inline]

Referenced by SymMat< 3, P >::operator-=().

SymMat& scalarMinusEqFromLeft

(

const EE &

ee

)

[inline]

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

(

const EE &

e

)

const [inline]

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

(

const EE &

e

)

const [inline]

ScalarNormSq scalarNormSqr

(

)

const [inline]

Referenced by SymMat< 3, P >::norm(), and SymMat< 3, P >::normSqr().

SymMat& scalarPlusEq

(

const EE &

ee

)

[inline]

Referenced by SymMat< 3, P >::operator+=().

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

(

const EE &

e

)

const [inline]

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

(

const EE &

e

)

const [inline]

SymMat& scalarTimesEq

(

const EE &

ee

)

[inline]

Referenced by SymMat< 3, P >::operator*=().

SymMat& scalarTimesEqFromLeft

(

const EE &

ee

)

[inline]

SymMat& 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.

SymMat& 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.

Referenced by SymMat< 3, P >::SymMat().

SymMat& 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.

void setToNaN

(

)

[inline]

Referenced by SymMat< 3, P >::SymMat().

void setToZero

(

)

[inline]

int size

(

)

const [inline]

TSqrt sqrt

(

)

const [inline]

Referenced by SymMat< 3, P >::norm(), and SymMat< 3, P >::sqrt().

TStandard standardize

(

)

const [inline]

Referenced by SymMat< 3, P >::standardize().

TRow sum

(

)

const [inline]

Referenced by SimTK::sum().

EStandard trace

(

)

const [inline]

const THerm& transpose

(

)

const [inline]

Referenced by SymMat< 3, P >::operator~(), and SymMat< 3, P >::setFromSymmetric().

static SymMat& updAs

(

ELT *

p

)

[inline, static]

Referenced by SymMat< 3, P >::updAsVec(), and SymMat< 3, P >::updLower().

TAsVec& updAsVec

(

)

[inline]

Referenced by SymMat< 3, P >::normalize(), SymMat< 3, P >::operator+=(), SymMat< 3, P >::operator-=(), SymMat< 3, P >::operator=(), Test::randSymMat(), SymMat< 3, P >::scalarDivide(), SymMat< 3, P >::scalarDivideEq(), SymMat< 3, P >::scalarDivideEqFromLeft(), SymMat< 3, P >::scalarDivideFromLeft(), SymMat< 3, P >::scalarMultiply(), SymMat< 3, P >::scalarMultiplyFromLeft(), SymMat< 3, P >::scalarTimesEq(), SymMat< 3, P >::scalarTimesEqFromLeft(), SymMat< 3, P >::setToNaN(), SymMat< 3, P >::setToZero(), and SymMat< 3, P >::SymMat().

TWithoutNegator& updCastAwayNegatorIfAny

(

)

[inline]

TDiag& updDiag

(

)

[inline]

Referenced by SymMat< 3, P >::diag(), SymMat< 3, P >::operator()(), SymMat< 3, P >::operator=(), SymMat< 3, P >::scalarAdd(), SymMat< 3, P >::scalarEq(), SymMat< 3, P >::scalarMinusEq(), SymMat< 3, P >::scalarMinusEqFromLeft(), SymMat< 3, P >::scalarPlusEq(), SymMat< 3, P >::setFromLower(), SymMat< 3, P >::setFromSymmetric(), SymMat< 3, P >::setFromUpper(), SymMat< 3, P >::SymMat(), and SymMat< 3, P >::updEltDiag().

E& updEltDiag

(

int

i

)

[inline]

E& updEltLower	(	int	i,
		int	j
	)			[inline]

Referenced by SymMat< 3, P >::operator()(), SymMat< 3, P >::operator=(), SymMat< 3, P >::setFromLower(), SymMat< 3, P >::setFromSymmetric(), SymMat< 3, P >::setFromUpper(), and SymMat< 3, P >::SymMat().

EHerm& updEltUpper	(	int	i,
		int	j
	)			[inline]

TLower& updLower

(

)

[inline]

Referenced by SymMat< 3, P >::scalarEq(), SymMat< 3, P >::scalarMinusEqFromLeft(), SymMat< 3, P >::SymMat(), SymMat< 3, P >::updEltLower(), and SymMat< 3, P >::updUpper().

TNeg& updNegate

(

)

[inline]

Referenced by SymMat< 3, P >::operator-().

TPosTrans& updPositionalTranspose

(

)

[inline]

THerm& updTranspose

(

)

[inline]

Referenced by SymMat< 3, P >::operator~().

TUpper& updUpper

(

)

[inline]

Referenced by SymMat< 3, P >::updEltUpper().

---

Friends And Related Function Documentation

friend class SymMat [friend]

---

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

• SymMat.h