----------------------------------------------------------------------------- This InverseRotation class is the inverse of a Rotation See the Rotation class for information. More...

#include <Rotation.h>

Inheritance diagram for SimTK::InverseRotation_:

Public Types
typedef Mat< 3, 3, P > ::TransposeType	BaseMat
	This is the type of the underlying 3x3 matrix; note that it will have unusual row and column spacing since we're viewing it as transposed. More...


typedef UnitVec< P, BaseMat::RowSpacing >	ColType
	Note that the unit vectors representing the rows and columns of this matrix do not necessarily have unit stride. More...

typedef UnitRow< P, BaseMat::ColSpacing >	RowType
	This is the type of a row of this InverseRotation. More...

Public Types inherited from SimTK::Mat< M, N, ELT, CS, RS >
enum	{ NRows = M, NCols = N, MinDim, RowSpacing = RS, ColSpacing = CS, NPackedElements = M * N, NActualElements = (N-1)CS + (M-1)RS + 1, NActualScalars = CNT<E>::NActualScalars * NActualElements, ImagOffset = NTraits<ENumber>::ImagOffset, RealStrideFactor = 1, ArgDepth, IsScalar = 0, IsULessScalar = 0, IsNumber = 0, IsStdNumber = 0, IsPrecision = 0, SignInterpretation = CNT<E>::SignInterpretation }
	Every Composite Numerical Type (CNT) must define these values. More...

typedef Mat< M, N, E, CS, RS >	T

typedef Mat< M, N, ENeg, CS, RS >	TNeg

typedef Mat< M, N, EWithoutNegator, CS, RS >	TWithoutNegator

typedef Mat< M, N, EReal, CS CNT< E >::RealStrideFactor, RS CNT< E >::RealStrideFactor >	TReal

typedef Mat< M, N, EImag, CS CNT< E >::RealStrideFactor, RS CNT< E >::RealStrideFactor >	TImag

typedef Mat< M, N, EComplex, CS, RS >	TComplex

typedef Mat< N, M, EHerm, RS, CS >	THerm

typedef Mat< N, M, E, RS, CS >	TPosTrans

typedef E	TElement

typedef Row< N, E, CS >	TRow

typedef Vec< M, E, RS >	TCol

typedef Vec< MinDim, E, RS+CS >	TDiag

typedef Mat< M, N, ESqrt, M, 1 >	TSqrt

typedef Mat< M, N, EAbs, M, 1 >	TAbs

typedef Mat< M, N, EStandard, M, 1 >	TStandard

typedef Mat< N, M, EInvert, N, 1 >	TInvert

typedef Mat< M, N, ENormalize, M, 1 >	TNormalize

typedef SymMat< N, ESqHermT >	TSqHermT

typedef SymMat< M, ESqTHerm >	TSqTHerm

typedef Mat< M, N, E, M, 1 >	TPacked

typedef Mat< M-1, N, E, M-1, 1 >	TDropRow

typedef Mat< M, N-1, E, M, 1 >	TDropCol

typedef Mat< M-1, N-1, E, M-1, 1 >	TDropRowCol

typedef Mat< M+1, N, E, M+1, 1 >	TAppendRow

typedef Mat< M, N+1, E, M, 1 >	TAppendCol

typedef Mat< M+1, N+1, E, M+1, 1 >	TAppendRowCol

typedef EScalar	Scalar

typedef EULessScalar	ULessScalar

typedef ENumber	Number

typedef EStdNumber	StdNumber

typedef EPrecision	Precision

typedef EScalarNormSq	ScalarNormSq

typedef THerm	TransposeType

Public Member Functions
	InverseRotation_ ()
	You should not ever construct one of these as they should only occur as expression intermediates resulting from use of the "~" operator on a Rotation. More...

	InverseRotation_ (const InverseRotation_ &R)
	This is an explicit implementation of the default copy constructor. More...

InverseRotation_ &	operator= (const InverseRotation_ &R)
	This is an explicit implementation of the default copy assignment operator. More...

SymMat33P	reexpressSymMat33 (const SymMat33P &S_BB) const
	Assuming this InverseRotation_ is R_AB, and given a symmetric dyadic matrix S_BB expressed in B, we can reexpress it in A using S_AA=R_ABS_BBR_BA. More...


const RotationP &	invert () const
	We can invert an InverseRotation just by recasting it to a Rotation at zero cost. More...

RotationP &	updInvert ()
	We can invert an InverseRotation just by recasting it to a Rotation at zero cost. More...


const RotationP &	transpose () const
	Transpose, and transpose operators (override BaseMat versions of transpose). More...

const RotationP &	operator~ () const
	Transpose, and transpose operators (override BaseMat versions of transpose). More...

RotationP &	updTranspose ()
	Transpose, and transpose operators (override BaseMat versions of transpose). More...

RotationP &	operator~ ()
	Transpose, and transpose operators (override BaseMat versions of transpose). More...


const RowType &	row (int i) const
	Access individual rows and columns of this InverseRotation; no cost or copying since suitably-cast references to the actual data are returned. More...

const ColType &	col (int j) const
	Access individual rows and columns of this InverseRotation; no cost or copying since suitably-cast references to the actual data are returned. More...

const ColType &	x () const
	Access individual rows and columns of this InverseRotation; no cost or copying since suitably-cast references to the actual data are returned. More...

const ColType &	y () const
	Access individual rows and columns of this InverseRotation; no cost or copying since suitably-cast references to the actual data are returned. More...

const ColType &	z () const
	Access individual rows and columns of this InverseRotation; no cost or copying since suitably-cast references to the actual data are returned. More...

const RowType &	operator[] (int i) const
	Access individual rows and columns of this InverseRotation; no cost or copying since suitably-cast references to the actual data are returned. More...

const ColType &	operator() (int j) const
	Access individual rows and columns of this InverseRotation; no cost or copying since suitably-cast references to the actual data are returned. More...


const BaseMat &	asMat33 () const
	Conversion from InverseRotation_ to BaseMat. More...

BaseMat	toMat33 () const
	Conversion from InverseRotation_ to BaseMat. More...

Public Member Functions inherited from SimTK::Mat< M, N, ELT, CS, RS >
ScalarNormSq	scalarNormSqr () const
	Scalar norm square is the sum of squares of all the scalars that comprise the value of this Mat. More...

TSqrt	sqrt () const
	Elementwise square root; that is, the return value has the same dimensions as this Mat but with each element replaced by whatever it thinks its square root is. More...

TAbs	abs () const
	Elementwise absolute value; that is, the return value has the same dimensions as this Mat but with each element replaced by whatever it thinks its absolute value is. More...

TStandard	standardize () const

	Mat ()
	Default construction initializes to NaN when debugging but is left uninitialized otherwise to ensure that there is no overhead. More...

	Mat (const Mat &src)
	Copy constructor copies only the elements that are present and does not touch any unused memory space between them if they are not packed. More...

Mat &	operator= (const Mat &src)
	Copy assignment copies only the elements that are present and does not touch any unused memory space between them if they are not packed. More...

	Mat (const SymMat< M, ELT > &src)
	Explicit construction of a Mat from a SymMat (symmetric/Hermitian matrix). More...

template<int CSS, int RSS>
	Mat (const Mat< M, N, E, CSS, RSS > &src)
	This provides an implicit conversion from a Mat of the same dimensions and element type but with different element spacing. More...

template<int CSS, int RSS>
	Mat (const Mat< M, N, ENeg, CSS, RSS > &src)
	This provides an implicit conversion from a Mat of the same dimensions and negated element type, possibly with different element spacing. More...

template<class EE , int CSS, int RSS>
	Mat (const Mat< M, N, EE, CSS, RSS > &mm)
	Explicit construction of a Mat from a source Mat of the same dimensions and an assignment-compatible element type, with any element spacing allowed. More...

	Mat (const E &e)
	Explicit construction from a single element e of this Mat's element type E sets all the main diagonal elements to e but sets the rest of the elements to zero. More...

	Mat (const ENeg &e)
	Explicit construction from a single element e whose type is negator<E> (abbreviated ENeg here) where E is this Mat's element type sets all the main diagonal elements to e but sets the rest of the elements to zero. More...

	Mat (int i)
	Explicit construction from an int value means we convert the int into an object of this Mat's element type E, and then apply the single-element constructor above which sets the Mat to zero except for its main diagonal elements which will all be set to the given value. More...

	Mat (const E &e0, const E &e1)

	Mat (const E &e0, const E &e1, const E &e2)

	Mat (const E &e0, const E &e1, const E &e2, const E &e3)

	Mat (const E &e0, const E &e1, const E &e2, const E &e3, const E &e4)

	Mat (const E &e0, const E &e1, const E &e2, const E &e3, const E &e4, const E &e5)

	Mat (const E &e0, const E &e1, const E &e2, const E &e3, const E &e4, const E &e5, const E &e6)

	Mat (const E &e0, const E &e1, const E &e2, const E &e3, const E &e4, const E &e5, const E &e6, const E &e7)

	Mat (const E &e0, const E &e1, const E &e2, const E &e3, const E &e4, const E &e5, const E &e6, const E &e7, const E &e8)

	Mat (const E &e0, const E &e1, const E &e2, const E &e3, const E &e4, const E &e5, const E &e6, const E &e7, const E &e8, const E &e9)

	Mat (const E &e0, const E &e1, const E &e2, const E &e3, const E &e4, const E &e5, const E &e6, const E &e7, const E &e8, const E &e9, const E &e10)

	Mat (const E &e0, const E &e1, const E &e2, const E &e3, const E &e4, const E &e5, const E &e6, const E &e7, const E &e8, const E &e9, const E &e10, const E &e11)

	Mat (const E &e0, const E &e1, const E &e2, const E &e3, const E &e4, const E &e5, const E &e6, const E &e7, const E &e8, const E &e9, const E &e10, const E &e11, const E &e12)

	Mat (const E &e0, const E &e1, const E &e2, const E &e3, const E &e4, const E &e5, const E &e6, const E &e7, const E &e8, const E &e9, const E &e10, const E &e11, const E &e12, const E &e13)

	Mat (const E &e0, const E &e1, const E &e2, const E &e3, const E &e4, const E &e5, const E &e6, const E &e7, const E &e8, const E &e9, const E &e10, const E &e11, const E &e12, const E &e13, const E &e14)

	Mat (const E &e0, const E &e1, const E &e2, const E &e3, const E &e4, const E &e5, const E &e6, const E &e7, const E &e8, const E &e9, const E &e10, const E &e11, const E &e12, const E &e13, const E &e14, const E &e15)

	Mat (const TRow &r0)

	Mat (const TRow &r0, const TRow &r1)

	Mat (const TRow &r0, const TRow &r1, const TRow &r2)

	Mat (const TRow &r0, const TRow &r1, const TRow &r2, const TRow &r3)

	Mat (const TRow &r0, const TRow &r1, const TRow &r2, const TRow &r3, const TRow &r4)

	Mat (const TRow &r0, const TRow &r1, const TRow &r2, const TRow &r3, const TRow &r4, const TRow &r5)

template<class EE , int SS>
	Mat (const Row< N, EE, SS > &r0)

template<class EE , int SS>
	Mat (const Row< N, EE, SS > &r0, const Row< N, EE, SS > &r1)

template<class EE , int SS>
	Mat (const Row< N, EE, SS > &r0, const Row< N, EE, SS > &r1, const Row< N, EE, SS > &r2)

template<class EE , int SS>
	Mat (const Row< N, EE, SS > &r0, const Row< N, EE, SS > &r1, const Row< N, EE, SS > &r2, const Row< N, EE, SS > &r3)

template<class EE , int SS>
	Mat (const Row< N, EE, SS > &r0, const Row< N, EE, SS > &r1, const Row< N, EE, SS > &r2, const Row< N, EE, SS > &r3, const Row< N, EE, SS > &r4)

template<class EE , int SS>
	Mat (const Row< N, EE, SS > &r0, const Row< N, EE, SS > &r1, const Row< N, EE, SS > &r2, const Row< N, EE, SS > &r3, const Row< N, EE, SS > &r4, const Row< N, EE, SS > &r5)

	Mat (const TCol &r0)

	Mat (const TCol &r0, const TCol &r1)

	Mat (const TCol &r0, const TCol &r1, const TCol &r2)

	Mat (const TCol &r0, const TCol &r1, const TCol &r2, const TCol &r3)

	Mat (const TCol &r0, const TCol &r1, const TCol &r2, const TCol &r3, const TCol &r4)

	Mat (const TCol &r0, const TCol &r1, const TCol &r2, const TCol &r3, const TCol &r4, const TCol &r5)

template<class EE , int SS>
	Mat (const Vec< M, EE, SS > &r0)

template<class EE , int SS>
	Mat (const Vec< M, EE, SS > &r0, const Vec< M, EE, SS > &r1)

template<class EE , int SS>
	Mat (const Vec< M, EE, SS > &r0, const Vec< M, EE, SS > &r1, const Vec< M, EE, SS > &r2)

template<class EE , int SS>
	Mat (const Vec< M, EE, SS > &r0, const Vec< M, EE, SS > &r1, const Vec< M, EE, SS > &r2, const Vec< M, EE, SS > &r3)

template<class EE , int SS>
	Mat (const Vec< M, EE, SS > &r0, const Vec< M, EE, SS > &r1, const Vec< M, EE, SS > &r2, const Vec< M, EE, SS > &r3, const Vec< M, EE, SS > &r4)

template<class EE , int SS>
	Mat (const Vec< M, EE, SS > &r0, const Vec< M, EE, SS > &r1, const Vec< M, EE, SS > &r2, const Vec< M, EE, SS > &r3, const Vec< M, EE, SS > &r4, const Vec< M, EE, SS > &r5)

template<class EE >
	Mat (const EE *p)

template<class EE , int CSS, int RSS>
Mat &	operator= (const Mat< M, N, EE, CSS, RSS > &mm)

template<class EE >
Mat &	operator= (const EE *p)

template<class EE , int CSS, int RSS>
Mat &	operator+= (const Mat< M, N, EE, CSS, RSS > &mm)

template<class EE , int CSS, int RSS>
Mat &	operator+= (const Mat< M, N, negator< EE >, CSS, RSS > &mm)

template<class EE , int CSS, int RSS>
Mat &	operator-= (const Mat< M, N, EE, CSS, RSS > &mm)

template<class EE , int CSS, int RSS>
Mat &	operator-= (const Mat< M, N, negator< EE >, CSS, RSS > &mm)

template<class EE , int CSS, int RSS>
Mat &	operator*= (const Mat< N, N, EE, CSS, RSS > &mm)

template<class E2 , int CS2, int RS2>
Result< Mat< M, N, E2, CS2, RS2 > >::Add	conformingAdd (const Mat< M, N, E2, CS2, RS2 > &r) const

template<class E2 , int CS2, int RS2>
Result< Mat< M, N, E2, CS2, RS2 > >::Sub	conformingSubtract (const Mat< M, N, E2, CS2, RS2 > &r) const

template<class E2 , int CS2, int RS2>
Mat< M, N, E2, CS2, RS2 > ::template Result< Mat >::Sub	conformingSubtractFromLeft (const Mat< M, N, E2, CS2, RS2 > &l) const

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

template<class E2 , int CS2, int RS2>
EltResult< E2 >::Dvd	elementwiseDivide (const Mat< M, N, E2, CS2, RS2 > &r) const

template<class E2 , int RS2>
Result< SymMat< M, E2, RS2 > >::Add	conformingAdd (const SymMat< M, E2, RS2 > &sy) const

template<class E2 , int RS2>
Result< SymMat< M, E2, RS2 > >::Sub	conformingSubtract (const SymMat< M, E2, RS2 > &sy) const

template<class E2 , int RS2>
SymMat< M, E2, RS2 >::template Result< Mat >::Sub	conformingSubtractFromLeft (const SymMat< M, E2, RS2 > &sy) const

template<int N2, class E2 , int CS2, int RS2>
Result< Mat< N, N2, E2, CS2, RS2 > >::Mul	conformingMultiply (const Mat< N, N2, E2, CS2, RS2 > &m) const

template<int M2, class E2 , int CS2, int RS2>
Mat< M2, M, E2, CS2, RS2 > ::template Result< Mat >::Mul	conformingMultiplyFromLeft (const Mat< M2, M, E2, CS2, RS2 > &m) const

template<int M2, class E2 , int CS2, int RS2>
Result< Mat< M2, N, E2, CS2, RS2 > >::Dvd	conformingDivide (const Mat< M2, N, E2, CS2, RS2 > &m) const

template<int M2, class E2 , int CS2, int RS2>
Mat< M2, N, E2, CS2, RS2 > ::template Result< Mat >::Dvd	conformingDivideFromLeft (const Mat< M2, N, E2, CS2, RS2 > &m) const

const TRow &	operator[] (int i) const

TRow &	operator[] (int i)

const TCol &	operator() (int j) const

TCol &	operator() (int j)

const E &	operator() (int i, int j) const

E &	operator() (int i, int j)

ScalarNormSq	normSqr () const

CNT< ScalarNormSq >::TSqrt	norm () const

TNormalize	normalize () const

TInvert	invert () const

const Mat &	operator+ () const

const TNeg &	operator- () const

TNeg &	operator- ()

const THerm &	operator~ () const

THerm &	operator~ ()

const TNeg &	negate () const

TNeg &	updNegate ()

const THerm &	transpose () const

THerm &	updTranspose ()

const TPosTrans &	positionalTranspose () const

TPosTrans &	updPositionalTranspose ()

const TReal &	real () const

TReal &	real ()

const TImag &	imag () const

TImag &	imag ()

const TWithoutNegator &	castAwayNegatorIfAny () const

TWithoutNegator &	updCastAwayNegatorIfAny ()

const TRow &	row (int i) const

TRow &	row (int i)

const TCol &	col (int j) const

TCol &	col (int j)

const E &	elt (int i, int j) const

E &	elt (int i, int j)

const TDiag &	diag () const
	Select main diagonal (of largest leading square if rectangular) and return it as a read-only view (as a Vec) of the diagonal elements of this Mat. More...

TDiag &	updDiag ()
	Select main diagonal (of largest leading square if rectangular) and return it as a writable view (as a Vec) of the diagonal elements of this Mat. More...

TDiag &	diag ()
	This non-const version of diag() is an alternate name for updDiag() available for historical reasons. More...

EStandard	trace () const

template<class EE >
Mat< M, N, typename CNT< E > ::template Result< EE >::Mul >	scalarMultiply (const EE &e) const

template<class EE >
Mat< M, N, typename CNT< EE > ::template Result< E >::Mul >	scalarMultiplyFromLeft (const EE &e) const

template<class EE >
Mat< M, N, typename CNT< E > ::template Result< EE >::Dvd >	scalarDivide (const EE &e) const

template<class EE >
Mat< M, N, typename CNT< EE > ::template Result< E >::Dvd >	scalarDivideFromLeft (const EE &e) const

template<class EE >
Mat< M, N, typename CNT< E > ::template Result< EE >::Add >	scalarAdd (const EE &e) const

template<class EE >
Mat< M, N, typename CNT< E > ::template Result< EE >::Sub >	scalarSubtract (const EE &e) const

template<class EE >
Mat< M, N, typename CNT< EE > ::template Result< E >::Sub >	scalarSubtractFromLeft (const EE &e) const

template<class EE >
Mat &	operator= (const EE &e)

template<class EE >
Mat &	operator+= (const EE &e)

template<class EE >
Mat &	operator-= (const EE &e)

template<class EE >
Mat &	operator*= (const EE &e)

template<class EE >
Mat &	operator/= (const EE &e)

template<class EE >
Mat &	scalarEq (const EE &ee)

template<class EE >
Mat &	scalarPlusEq (const EE &ee)

template<class EE >
Mat &	scalarMinusEq (const EE &ee)

template<class EE >
Mat &	scalarMinusEqFromLeft (const EE &ee)

template<class EE >
Mat &	scalarTimesEq (const EE &ee)

template<class EE >
Mat &	scalarTimesEqFromLeft (const EE &ee)

template<class EE >
Mat &	scalarDivideEq (const EE &ee)

template<class EE >
Mat &	scalarDivideEqFromLeft (const EE &ee)

void	setToNaN ()

void	setToZero ()

template<int MM, int NN>
const SubMat< MM, NN >::Type &	getSubMat (int i, int j) const

template<int MM, int NN>
SubMat< MM, NN >::Type &	updSubMat (int i, int j)

template<int MM, int NN>
void	setSubMat (int i, int j, const typename SubMat< MM, NN >::Type &value)

TDropRow	dropRow (int i) const
	Return a matrix one row smaller than this one by dropping row i. More...

TDropCol	dropCol (int j) const
	Return a matrix one column smaller than this one by dropping column j. More...

TDropRowCol	dropRowCol (int i, int j) const
	Return a matrix one row and one column smaller than this one by dropping row i and column j. More...

template<class EE , int SS>
TAppendRow	appendRow (const Row< N, EE, SS > &row) const
	Return a matrix one row larger than this one by adding a row to the end. More...

template<class EE , int SS>
TAppendCol	appendCol (const Vec< M, EE, SS > &col) const
	Return a matrix one column larger than this one by adding a column to the end. More...

template<class ER , int SR, class EC , int SC>
TAppendRowCol	appendRowCol (const Row< N+1, ER, SR > &row, const Vec< M+1, EC, SC > &col) const
	Return a matrix one row and one column larger than this one by adding a row to the bottom and a column to the right. More...

template<class EE , int SS>
TAppendRow	insertRow (int i, const Row< N, EE, SS > &row) const
	Return a matrix one row larger than this one by inserting a row before row i. More...

template<class EE , int SS>
TAppendCol	insertCol (int j, const Vec< M, EE, SS > &col) const
	Return a matrix one column larger than this one by inserting a column before column j. More...

template<class ER , int SR, class EC , int SC>
TAppendRowCol	insertRowCol (int i, int j, const Row< N+1, ER, SR > &row, const Vec< M+1, EC, SC > &col) const
	Return a matrix one row and one column larger than this one by inserting a row before row i and a column before column j. More...

bool	isNaN () const
	Return true if any element of this Mat contains a NaN anywhere. More...

bool	isInf () const
	Return true if any element of this Mat 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 CS2, int RS2>
bool	isNumericallyEqual (const Mat< M, N, E2, CS2, RS2 > &m, double tol) const
	Test whether this matrix is numerically equal to some other matrix with the same shape, using a specified tolerance. More...

template<class E2 , int CS2, int RS2>
bool	isNumericallyEqual (const Mat< M, N, E2, CS2, RS2 > &m) const
	Test whether this matrix is numerically equal to some other matrix with the same shape, using a default tolerance which is the looser of the default tolerances of the two objects being compared. 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...

bool	isNumericallySymmetric (double tol=getDefaultTolerance()) const
	A Matrix is symmetric (actually Hermitian) if it is square and each element (i,j) is the Hermitian transpose of element (j,i). More...

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

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

std::string	toString () const
	toString() returns a string representation of the Mat. More...

const ELT &	get (int i, int j) const
	Variant of indexing operator that's scripting friendly to get entry (i, j) More...

void	set (int i, int j, const ELT &value)
	Variant of indexing operator that's scripting friendly to set entry (i, j) More...

Additional Inherited Members
Static Public Member Functions inherited from SimTK::Mat< M, N, ELT, CS, RS >
static int	size ()
	Return the total number of elements M*N contained in this Mat. More...

static int	nrow ()
	Return the number of rows in this Mat, echoing the value supplied for the template paramter M. More...

static int	ncol ()
	Return the number of columns in this Mat, echoing the value supplied for the template paramter N. More...

static const Mat &	getAs (const ELT *p)

static Mat &	updAs (ELT *p)

static Mat< M, N, ELT, M, 1 >	getNaN ()

static double	getDefaultTolerance ()
	For approximate comparisions, the default tolerance to use for a matrix is its shortest dimension times its elements' default tolerance. More...

Related Functions inherited from SimTK::Mat< M, N, ELT, CS, RS >
template<int M, int N, class E , int CS, int RS>
void	writeUnformatted (std::ostream &o, const Mat< M, N, E, CS, RS > &v)
	Specialize for Mat<M,N,E,CS,RS> delegating to Row<N,E,RS> with newlines separating the rows, but no final newline. More...

template<int M, int N, class E , int CS, int RS>
bool	readUnformatted (std::istream &in, Mat< M, N, E, CS, RS > &v)
	Specialize for Mat<M,N,E,CS,RS> delegating to Row<N,E,RS>. More...

Detailed Description

template<class P>
class SimTK::InverseRotation_

----------------------------------------------------------------------------- This InverseRotation class is the inverse of a Rotation See the Rotation class for information.

—————————————————————————–

Member Typedef Documentation

template<class P>

typedef Mat<3,3,P>::TransposeType SimTK::InverseRotation_::BaseMat

This is the type of the underlying 3x3 matrix; note that it will have unusual row and column spacing since we're viewing it as transposed.

template<class P>

typedef UnitVec<P,BaseMat::RowSpacing> SimTK::InverseRotation_::ColType

Note that the unit vectors representing the rows and columns of this matrix do not necessarily have unit stride.

This is the type of a column of this InverseRotation.

template<class P>

typedef UnitRow<P,BaseMat::ColSpacing> SimTK::InverseRotation_::RowType

This is the type of a row of this InverseRotation.

Constructor & Destructor Documentation

template<class P>

SimTK::InverseRotation_::InverseRotation_ ( )

inline

You should not ever construct one of these as they should only occur as expression intermediates resulting from use of the "~" operator on a Rotation.

But if you must, the default will produce an identity rotation.

template<class P>

SimTK::InverseRotation_::InverseRotation_ ( const InverseRotation_ & R )

inline

This is an explicit implementation of the default copy constructor.

Member Function Documentation

template<class P>

InverseRotation_& SimTK::InverseRotation_::operator= ( const InverseRotation_ & R )

inline

This is an explicit implementation of the default copy assignment operator.

template<class P>

SymMat33P SimTK::InverseRotation_::reexpressSymMat33 ( const SymMat33P & S_BB ) const

Assuming this InverseRotation_ is R_AB, and given a symmetric dyadic matrix S_BB expressed in B, we can reexpress it in A using S_AA=R_AB*S_BB*R_BA.

The matrix should be one that is formed as products of vectors expressed in A, such as inertia, gyration or covariance matrices. This can be done efficiently exploiting properties of R and S. Cost is 57 flops.

See Also: Rotation::reexpressSymMat33()

template<class P>

const RotationP& SimTK::InverseRotation_::invert ( ) const

inline

We can invert an InverseRotation just by recasting it to a Rotation at zero cost.

template<class P>

RotationP& SimTK::InverseRotation_::updInvert ( )

inline

We can invert an InverseRotation just by recasting it to a Rotation at zero cost.

template<class P>

const RotationP& SimTK::InverseRotation_::transpose ( ) const

inline

Transpose, and transpose operators (override BaseMat versions of transpose).

For an orthogonal matrix like this one transpose is the same as inverse.

template<class P>

const RotationP& SimTK::InverseRotation_::operator~ ( ) const

inline

Transpose, and transpose operators (override BaseMat versions of transpose).

For an orthogonal matrix like this one transpose is the same as inverse.

template<class P>

RotationP& SimTK::InverseRotation_::updTranspose ( )

inline

Transpose, and transpose operators (override BaseMat versions of transpose).

For an orthogonal matrix like this one transpose is the same as inverse.

template<class P>

RotationP& SimTK::InverseRotation_::operator~ ( )

inline

Transpose, and transpose operators (override BaseMat versions of transpose).

For an orthogonal matrix like this one transpose is the same as inverse.

template<class P>

const RowType& SimTK::InverseRotation_::row ( int i ) const

inline

Access individual rows and columns of this InverseRotation; no cost or copying since suitably-cast references to the actual data are returned.