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 >::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) | |
| 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 ColType & | getAxisUnitVec (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 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 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 & | 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 & | 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 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 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 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 Mat & | getAs (const ELT *p) |
| static Mat & | updAs (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... | |
| 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_< 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>
|
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>
|
inline |
An explicit implementation of the default copy constructor.
Member Function Documentation
◆ operator=()
template<class P>
|
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>
|
inline |
We can invert an InverseRotation just by recasting it to a Rotation at zero cost.
◆ updInvert()
template<class P>
|
inline |
We can invert an InverseRotation just by recasting it to a Rotation at zero cost.
◆ transpose()
template<class P>
|
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>
|
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>
|
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>
|
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>
|
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>
|
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>
|
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>
|
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>
|
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>
|
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>
|
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>
|
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>
|
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>
|
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>
|
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:
