Simbody  3.7
SimTK::InverseRotation_< P > Class Template Reference

(Advanced) This InverseRotation class is the inverse of a Rotation. More...

+ Inheritance diagram for SimTK::InverseRotation_< P >:

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 ELT E
 
typedef CNT< E >::TNeg ENeg
 
typedef CNT< E >::TWithoutNegator EWithoutNegator
 
typedef CNT< E >::TReal EReal
 
typedef CNT< E >::TImag EImag
 
typedef CNT< E >::TComplex EComplex
 
typedef CNT< E >::THerm EHerm
 
typedef CNT< E >::TPosTrans EPosTrans
 
typedef CNT< E >::TSqHermT ESqHermT
 
typedef CNT< E >::TSqTHerm ESqTHerm
 
typedef CNT< E >::TSqrt ESqrt
 
typedef CNT< E >::TAbs EAbs
 
typedef CNT< E >::TStandard EStandard
 
typedef CNT< E >::TInvert EInvert
 
typedef CNT< E >::TNormalize ENormalize
 
typedef CNT< E >::Scalar EScalar
 
typedef CNT< E >::ULessScalar EULessScalar
 
typedef CNT< E >::Number ENumber
 
typedef CNT< E >::StdNumber EStdNumber
 
typedef CNT< E >::Precision EPrecision
 
typedef CNT< E >::ScalarNormSq EScalarNormSq
 
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 >::RealStrideFactorTReal
 
typedef Mat< M, N, EImag, CS *CNT< E >::RealStrideFactor, RS *CNT< E >::RealStrideFactorTImag
 
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, ESqHermTTSqHermT
 
typedef SymMat< M, ESqTHermTSqTHerm
 
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)
 An explicit implementation of the default copy constructor. More...
 
InverseRotation_operator= (const InverseRotation_ &R)
 An explicit implementation of the default copy assignment operator. More...
 
SymMat< 3, P > reexpressSymMat33 (const SymMat< 3, P > &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. More...
 
const ColTypegetAxisUnitVec (CoordinateAxis axis) const
 Given a CoordinateAxis (XAxis,YAxis, or ZAxis) return a reference to the corresponding column of this InverseRotation matrix. More...
 
const UnitVec< P, 1 > getAxisUnitVec (CoordinateDirection dir) const
 Given a CoordinateDirection (+/-XAxis, etc.) return a unit vector in that direction. More...
 
const Rotation_< P > & invert () const
 We can invert an InverseRotation just by recasting it to a Rotation at zero cost. More...
 
Rotation_< P > & updInvert ()
 We can invert an InverseRotation just by recasting it to a Rotation at zero cost. More...
 
const Rotation_< P > & transpose () const
 Transpose, and transpose operators (override BaseMat versions of transpose). More...
 
const Rotation_< P > & operator~ () const
 Transpose, and transpose operators (override BaseMat versions of transpose). More...
 
Rotation_< P > & updTranspose ()
 Transpose, and transpose operators (override BaseMat versions of transpose). More...
 
Rotation_< P > & operator~ ()
 Transpose, and transpose operators (override BaseMat versions of transpose). More...
 
const RowTyperow (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 RowTypeoperator[] (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 ColTypecol (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 ColTypeoperator() (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 ColTypex () 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 ColTypey () 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 ColTypez () 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 BaseMatasMat33 () 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...
 
Matoperator= (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>
Matoperator= (const Mat< M, N, EE, CSS, RSS > &mm)
 
template<class EE >
Matoperator= (const EE *p)
 
template<class EE , int CSS, int RSS>
Matoperator+= (const Mat< M, N, EE, CSS, RSS > &mm)
 
template<class EE , int CSS, int RSS>
Matoperator+= (const Mat< M, N, negator< EE >, CSS, RSS > &mm)
 
template<class EE , int CSS, int RSS>
Matoperator-= (const Mat< M, N, EE, CSS, RSS > &mm)
 
template<class EE , int CSS, int RSS>
Matoperator-= (const Mat< M, N, negator< EE >, CSS, RSS > &mm)
 
template<class EE , int CSS, int RSS>
Matoperator*= (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 TRowoperator[] (int i) const
 
TRowoperator[] (int i)
 
const TColoperator() (int j) const
 
TColoperator() (int j)
 
const Eoperator() (int i, int j) const
 
Eoperator() (int i, int j)
 
ScalarNormSq normSqr () const
 
CNT< ScalarNormSq >::TSqrt norm () const
 
TNormalize normalize () const
 
TInvert invert () const
 
const Matoperator+ () const
 
const TNegoperator- () const
 
TNegoperator- ()
 
const THermoperator~ () const
 
THermoperator~ ()
 
const TNegnegate () const
 
TNegupdNegate ()
 
const THermtranspose () const
 
THermupdTranspose ()
 
const TPosTranspositionalTranspose () const
 
TPosTransupdPositionalTranspose ()
 
const TRealreal () const
 
TRealreal ()
 
const TImagimag () const
 
TImagimag ()
 
const TWithoutNegatorcastAwayNegatorIfAny () const
 
TWithoutNegatorupdCastAwayNegatorIfAny ()
 
const TRowrow (int i) const
 
TRowrow (int i)
 
const TColcol (int j) const
 
TColcol (int j)
 
const Eelt (int i, int j) const
 
Eelt (int i, int j)
 
const TDiagdiag () 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...
 
TDiagupdDiag ()
 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...
 
TDiagdiag ()
 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 >
Matoperator= (const EE &e)
 
template<class EE >
Matoperator+= (const EE &e)
 
template<class EE >
Matoperator-= (const EE &e)
 
template<class EE >
Matoperator*= (const EE &e)
 
template<class EE >
Matoperator/= (const EE &e)
 
template<class EE >
MatscalarEq (const EE &ee)
 
template<class EE >
MatscalarPlusEq (const EE &ee)
 
template<class EE >
MatscalarMinusEq (const EE &ee)
 
template<class EE >
MatscalarMinusEqFromLeft (const EE &ee)
 
template<class EE >
MatscalarTimesEq (const EE &ee)
 
template<class EE >
MatscalarTimesEqFromLeft (const EE &ee)
 
template<class EE >
MatscalarDivideEq (const EE &ee)
 
template<class EE >
MatscalarDivideEqFromLeft (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 parameter M. More...
 
static int ncol ()
 Return the number of columns in this Mat, echoing the value supplied for the template parameter N. More...
 
static const MatgetAs (const ELT *p)
 
static MatupdAs (ELT *p)
 
static Mat< M, N, ELT, M, 1 > getNaN ()
 
static double getDefaultTolerance ()
 For approximate comparisons, the default tolerance to use for a matrix is its shortest dimension times its elements' default tolerance. More...
 

Detailed Description

template<class P>
class SimTK::InverseRotation_< P >

(Advanced) This InverseRotation class is the inverse of a Rotation.

See the Rotation class for more information.

Member Typedef Documentation

◆ BaseMat

template<class P>
typedef Mat<3,3,P>::TransposeType SimTK::InverseRotation_< P >::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.

◆ ColType

template<class P>
typedef UnitVec<P,BaseMat::RowSpacing> SimTK::InverseRotation_< P >::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.

◆ RowType

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

This is the type of a row of this InverseRotation.

Constructor & Destructor Documentation

◆ InverseRotation_() [1/2]

template<class P>
SimTK::InverseRotation_< P >::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.

◆ InverseRotation_() [2/2]

template<class P>
SimTK::InverseRotation_< P >::InverseRotation_ ( const InverseRotation_< P > &  R)
inline

An explicit implementation of the default copy constructor.

Member Function Documentation

◆ operator=()

template<class P>
InverseRotation_& SimTK::InverseRotation_< P >::operator= ( const InverseRotation_< P > &  R)
inline

An explicit implementation of the default copy assignment operator.

◆ reexpressSymMat33()

template<class P>
SymMat<3,P> SimTK::InverseRotation_< P >::reexpressSymMat33 ( const SymMat< 3, P > &  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, unit inertia (gyration) or covariance matrices. This can be done efficiently exploiting properties of R and S. Cost is 57 flops.

See also
Rotation::reexpressSymMat33()

◆ invert()

template<class P>
const Rotation_<P>& SimTK::InverseRotation_< P >::invert ( ) const
inline

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

◆ updInvert()

template<class P>
Rotation_<P>& SimTK::InverseRotation_< P >::updInvert ( )
inline

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

◆ transpose()

template<class P>
const Rotation_<P>& SimTK::InverseRotation_< P >::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.

◆ operator~() [1/2]

template<class P>
const Rotation_<P>& SimTK::InverseRotation_< P >::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.

◆ updTranspose()

template<class P>
Rotation_<P>& SimTK::InverseRotation_< P >::updTranspose ( )
inline

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

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

◆ operator~() [2/2]

template<class P>
Rotation_<P>& SimTK::InverseRotation_< P >::operator~ ( )
inline

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

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

◆ row()

template<class P>
const RowType& SimTK::InverseRotation_< P >::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.

There are no writable versions of these methods since changing a single row or column would violate the contract that these are always legitimate rotation matrices.

◆ operator[]()

template<class P>
const RowType& SimTK::InverseRotation_< P >::operator[] ( 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.

There are no writable versions of these methods since changing a single row or column would violate the contract that these are always legitimate rotation matrices.

◆ col()

template<class P>
const ColType& SimTK::InverseRotation_< P >::col ( int  j) const
inline

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

There are no writable versions of these methods since changing a single row or column would violate the contract that these are always legitimate rotation matrices.

◆ operator()()

template<class P>
const ColType& SimTK::InverseRotation_< P >::operator() ( int  j) const
inline

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

There are no writable versions of these methods since changing a single row or column would violate the contract that these are always legitimate rotation matrices.

◆ x()

template<class P>
const ColType& SimTK::InverseRotation_< P >::x ( ) const
inline

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

There are no writable versions of these methods since changing a single row or column would violate the contract that these are always legitimate rotation matrices.

◆ y()

template<class P>
const ColType& SimTK::InverseRotation_< P >::y ( ) const
inline

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

There are no writable versions of these methods since changing a single row or column would violate the contract that these are always legitimate rotation matrices.

◆ z()

template<class P>
const ColType& SimTK::InverseRotation_< P >::z ( ) const
inline

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

There are no writable versions of these methods since changing a single row or column would violate the contract that these are always legitimate rotation matrices.

◆ getAxisUnitVec() [1/2]

template<class P>
const ColType& SimTK::InverseRotation_< P >::getAxisUnitVec ( CoordinateAxis  axis) const
inline

Given a CoordinateAxis (XAxis,YAxis, or ZAxis) return a reference to the corresponding column of this InverseRotation matrix.

The result is equivalent to multiplying R_AB*v_B where v_B is [1,0,0],[0,1,0], or [0,0,1], which would cost 15 flops, but requires no computation.

◆ getAxisUnitVec() [2/2]

template<class P>
const UnitVec<P,1> SimTK::InverseRotation_< P >::getAxisUnitVec ( CoordinateDirection  dir) const
inline

Given a CoordinateDirection (+/-XAxis, etc.) return a unit vector in that direction.

The result is equivalent to multiplying R_AB*v_B where v_B is [+/-1,0,0], [0,+/-1,0], or [0,0,+/-1], which would cost 15 flops, but this method requires at most 3 flops.

◆ asMat33()

template<class P>
const BaseMat& SimTK::InverseRotation_< P >::asMat33 ( ) const
inline

Conversion from InverseRotation_ to BaseMat.

Note: asMat33 is slightly more efficient than toMat33() (no copy), but you have to know the internal layout.

◆ toMat33()

template<class P>
BaseMat SimTK::InverseRotation_< P >::toMat33 ( ) const
inline

Conversion from InverseRotation_ to BaseMat.

Note: asMat33 is slightly more efficient than toMat33() (no copy), but you have to know the internal layout.


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