Simbody
3.7
|
This class represents a small matrix whose size is known at compile time, containing elements of any Composite Numerical Type (CNT) and engineered to have no runtime overhead whatsoever. More...
Classes | |
struct | EltResult |
struct | Result |
struct | SubMat |
struct | Substitute |
Public Types | |
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 | |
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... | |
Static Public Member Functions | |
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 | |
(Note that these are not member functions.) | |
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... | |
This class represents a small matrix whose size is known at compile time, containing elements of any Composite Numerical Type (CNT) and engineered to have no runtime overhead whatsoever.
Memory layout defaults to packed, column-ordered storage but can be specified to have any regular row and column spacing. A Mat object is itself a Composite Numerical Type and can thus be the element type for other matrix and vector types. Some common use cases are provided below.
M | The number of rows in this matrix (no default). |
N | The number of columns in this matrix (no default). |
ELT | The element type; default is Real. |
CS | Column spacing in memory as a multiple of element size (default M). |
RS | Row spacing in memory as a multiple of element size (default 1). |
Construction
A 3x3 identity matrix can be constructed in the following ways:
Note that the default element type is Real, and that Mat33 is a typedef for Mat<3,3>; analogous typedefs exist for matrices of up to 9x9 elements.
Manipulation
Standard arithmetic operators can be used, as well as methods like trace() and transpose(). Here are some usage examples, each of which prints a 2x2 identity matrix:
Conversion
It may be necessary to convert between a Mat and a Matrix (to interface with FactorQTZ, for instance). In the example below, we print a Mat33 created from a 3x3 Matrix:
Converting from a Mat33 to a Matrix is straightforward:
typedef ELT SimTK::Mat< M, N, ELT, CS, RS >::E |
typedef CNT<E>::TNeg SimTK::Mat< M, N, ELT, CS, RS >::ENeg |
typedef CNT<E>::TWithoutNegator SimTK::Mat< M, N, ELT, CS, RS >::EWithoutNegator |
typedef CNT<E>::TReal SimTK::Mat< M, N, ELT, CS, RS >::EReal |
typedef CNT<E>::TImag SimTK::Mat< M, N, ELT, CS, RS >::EImag |
typedef CNT<E>::TComplex SimTK::Mat< M, N, ELT, CS, RS >::EComplex |
typedef CNT<E>::THerm SimTK::Mat< M, N, ELT, CS, RS >::EHerm |
typedef CNT<E>::TPosTrans SimTK::Mat< M, N, ELT, CS, RS >::EPosTrans |
typedef CNT<E>::TSqHermT SimTK::Mat< M, N, ELT, CS, RS >::ESqHermT |
typedef CNT<E>::TSqTHerm SimTK::Mat< M, N, ELT, CS, RS >::ESqTHerm |
typedef CNT<E>::TSqrt SimTK::Mat< M, N, ELT, CS, RS >::ESqrt |
typedef CNT<E>::TAbs SimTK::Mat< M, N, ELT, CS, RS >::EAbs |
typedef CNT<E>::TStandard SimTK::Mat< M, N, ELT, CS, RS >::EStandard |
typedef CNT<E>::TInvert SimTK::Mat< M, N, ELT, CS, RS >::EInvert |
typedef CNT<E>::TNormalize SimTK::Mat< M, N, ELT, CS, RS >::ENormalize |
typedef CNT<E>::Scalar SimTK::Mat< M, N, ELT, CS, RS >::EScalar |
typedef CNT<E>::ULessScalar SimTK::Mat< M, N, ELT, CS, RS >::EULessScalar |
typedef CNT<E>::Number SimTK::Mat< M, N, ELT, CS, RS >::ENumber |
typedef CNT<E>::StdNumber SimTK::Mat< M, N, ELT, CS, RS >::EStdNumber |
typedef CNT<E>::Precision SimTK::Mat< M, N, ELT, CS, RS >::EPrecision |
typedef CNT<E>::ScalarNormSq SimTK::Mat< M, N, ELT, CS, RS >::EScalarNormSq |
typedef Mat<M,N,E,CS,RS> SimTK::Mat< M, N, ELT, CS, RS >::T |
typedef Mat<M,N,ENeg,CS,RS> SimTK::Mat< M, N, ELT, CS, RS >::TNeg |
typedef Mat<M,N,EWithoutNegator,CS,RS> SimTK::Mat< M, N, ELT, CS, RS >::TWithoutNegator |
typedef Mat<M,N,EReal,CS*CNT<E>::RealStrideFactor,RS*CNT<E>::RealStrideFactor> SimTK::Mat< M, N, ELT, CS, RS >::TReal |
typedef Mat<M,N,EImag,CS*CNT<E>::RealStrideFactor,RS*CNT<E>::RealStrideFactor> SimTK::Mat< M, N, ELT, CS, RS >::TImag |
typedef Mat<M,N,EComplex,CS,RS> SimTK::Mat< M, N, ELT, CS, RS >::TComplex |
typedef Mat<N,M,EHerm,RS,CS> SimTK::Mat< M, N, ELT, CS, RS >::THerm |
typedef Mat<N,M,E,RS,CS> SimTK::Mat< M, N, ELT, CS, RS >::TPosTrans |
typedef E SimTK::Mat< M, N, ELT, CS, RS >::TElement |
typedef Row<N,E,CS> SimTK::Mat< M, N, ELT, CS, RS >::TRow |
typedef Vec<M,E,RS> SimTK::Mat< M, N, ELT, CS, RS >::TCol |
typedef Vec<MinDim,E,RS+CS> SimTK::Mat< M, N, ELT, CS, RS >::TDiag |
typedef Mat<M,N,ESqrt,M,1> SimTK::Mat< M, N, ELT, CS, RS >::TSqrt |
typedef Mat<M,N,EAbs,M,1> SimTK::Mat< M, N, ELT, CS, RS >::TAbs |
typedef Mat<M,N,EStandard,M,1> SimTK::Mat< M, N, ELT, CS, RS >::TStandard |
typedef Mat<N,M,EInvert,N,1> SimTK::Mat< M, N, ELT, CS, RS >::TInvert |
typedef Mat<M,N,ENormalize,M,1> SimTK::Mat< M, N, ELT, CS, RS >::TNormalize |
typedef SymMat<N,ESqHermT> SimTK::Mat< M, N, ELT, CS, RS >::TSqHermT |
typedef SymMat<M,ESqTHerm> SimTK::Mat< M, N, ELT, CS, RS >::TSqTHerm |
typedef Mat<M,N,E,M,1> SimTK::Mat< M, N, ELT, CS, RS >::TPacked |
typedef Mat<M-1,N,E,M-1,1> SimTK::Mat< M, N, ELT, CS, RS >::TDropRow |
typedef Mat<M,N-1,E,M,1> SimTK::Mat< M, N, ELT, CS, RS >::TDropCol |
typedef Mat<M-1,N-1,E,M-1,1> SimTK::Mat< M, N, ELT, CS, RS >::TDropRowCol |
typedef Mat<M+1,N,E,M+1,1> SimTK::Mat< M, N, ELT, CS, RS >::TAppendRow |
typedef Mat<M,N+1,E,M,1> SimTK::Mat< M, N, ELT, CS, RS >::TAppendCol |
typedef Mat<M+1,N+1,E,M+1,1> SimTK::Mat< M, N, ELT, CS, RS >::TAppendRowCol |
typedef EScalar SimTK::Mat< M, N, ELT, CS, RS >::Scalar |
typedef EULessScalar SimTK::Mat< M, N, ELT, CS, RS >::ULessScalar |
typedef ENumber SimTK::Mat< M, N, ELT, CS, RS >::Number |
typedef EStdNumber SimTK::Mat< M, N, ELT, CS, RS >::StdNumber |
typedef EPrecision SimTK::Mat< M, N, ELT, CS, RS >::Precision |
typedef EScalarNormSq SimTK::Mat< M, N, ELT, CS, RS >::ScalarNormSq |
typedef THerm SimTK::Mat< M, N, ELT, CS, RS >::TransposeType |
anonymous enum |
Every Composite Numerical Type (CNT) must define these values.
|
inline |
Default construction initializes to NaN when debugging but is left uninitialized otherwise to ensure that there is no overhead.
|
inline |
Copy constructor copies only the elements that are present and does not touch any unused memory space between them if they are not packed.
|
inlineexplicit |
|
inline |
|
inline |
|
inlineexplicit |
|
inlineexplicit |
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.
|
inlineexplicit |
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.
|
inlineexplicit |
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.
To convert an int to an element, we first turn it into the appropriate-precision floating point number, and then call E's constructor that takes a single scalar.
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inlineexplicit |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inlineexplicit |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inlineexplicit |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inlineexplicit |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inlineexplicit |
|
inlinestatic |
Return the total number of elements M*N contained in this Mat.
|
inlinestatic |
Return the number of rows in this Mat, echoing the value supplied for the template parameter M.
|
inlinestatic |
Return the number of columns in this Mat, echoing the value supplied for the template parameter N.
|
inline |
|
inline |
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.
|
inline |
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.
|
inline |
|
inline |
Copy assignment copies only the elements that are present and does not touch any unused memory space between them if they are not packed.
Works correctly even if source and destination are the same object.
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
Return a matrix one row smaller than this one by dropping row i.
The result is packed but has same element type as this one.
|
inline |
Return a matrix one column smaller than this one by dropping column j.
The result is packed but has same element type as this one.
|
inline |
Return a matrix one row and one column smaller than this one by dropping row i and column j.
The result is packed but has same element type as this one.
|
inline |
Return a matrix one row larger than this one by adding a row to the end.
The result is packed but has same element type as this one. Works for any assignment compatible row.
|
inline |
Return a matrix one column larger than this one by adding a column to the end.
The result is packed but has same element type as this one. Works for any assignment compatible column.
|
inline |
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.
The final element of the row is ignored; that value is taken from the final element of the column instead. The result is packed but has same element type as this one. Works for any assignment compatible row and column.
|
inline |
Return a matrix one row larger than this one by inserting a row before row i.
The result is packed but has same element type as this one. Works for any assignment compatible row. The index can be one greater than normally allowed in which case the row is appended.
|
inline |
Return a matrix one column larger than this one by inserting a column before column j.
The result is packed but has same element type as this one. Works for any assignment compatible column. The index can be one greater than normally allowed in which case the column is appended.
|
inline |
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.
The intersecting element of the row is ignored; that element is taken from the column. The result is packed but has same element type as this one. Works for any assignment compatible row and column. The indices can be one greater than normally allowed in which case the row or column is appended.
|
inlinestatic |
|
inlinestatic |
|
inlinestatic |
|
inline |
Return true if any element of this Mat contains a NaN anywhere.
|
inline |
Return true if any element of this Mat contains a +Inf or -Inf somewhere but no element contains a NaN anywhere.
|
inline |
Return true if no element contains an Infinity or a NaN.
|
inlinestatic |
For approximate comparisons, the default tolerance to use for a matrix is its shortest dimension times its elements' default tolerance.
|
inline |
Test whether this matrix is numerically equal to some other matrix with the same shape, using a specified tolerance.
|
inline |
Test whether this matrix is numerically equal to some other matrix with the same shape, using a default tolerance which is the looser of the default tolerances of the two objects being compared.
|
inline |
Test whether this is numerically a "scalar" matrix, meaning that it is a diagonal matrix in which each diagonal element is numerically equal to the same scalar, using either a specified tolerance or the matrix's default tolerance (which is always the same or looser than the default tolerance for one of its elements).
|
inline |
A Matrix is symmetric (actually Hermitian) if it is square and each element (i,j) is the Hermitian transpose of element (j,i).
Here we are testing for numerical symmetry, meaning that the symmetry condition is satisified to within a tolerance (supplied or default). This is a relatively expensive test since all elements must be examined but can be very useful in Debug mode to check assumptions.
|
inline |
A Matrix is symmetric (actually Hermitian) if it is square and each element (i,j) is the Hermitian (conjugate) transpose of element (j,i).
This method tests for exact (bitwise) equality and is too stringent for most purposes; don't use it unless you know that the corresponding elements should be bitwise conjugates, typically because you put them there directly.
|
inline |
Returns a row vector (Row) containing the column sums of this matrix.
|
inline |
This is an alternate name for colSum(); behaves like the Matlab function of the same name.
|
inline |
Returns a column vector (Vec) containing the row sums of this matrix.
|
inline |
toString() returns a string representation of the Mat.
Please refer to operator<< for details.
|
inline |
Variant of indexing operator that's scripting friendly to get entry (i, j)
|
inline |
Variant of indexing operator that's scripting friendly to set entry (i, j)