SOFA API  e18b59ce
Open source framework for multi-physics simuation
sofa::defaulttype::Mat< L, C, real > Class Template Reference

#include <Mat.h>

Inheritance diagram for sofa::defaulttype::Mat< L, C, real >:

Static Public Attributes

static const Size nbLines = L
 
static const Size nbCols = C
 
static Mat< L, L, real > s_identity = Mat<L,L,real>::Identity()
 precomputed identity matrix of size (L,L) More...
 

Public Member Functions

 Mat ()
 
 Mat (NoInit)
 
 Mat (Line r1, Line r2)
 Specific constructor with 2 lines. More...
 
 Mat (Line r1, Line r2, Line r3)
 Specific constructor with 3 lines. More...
 
 Mat (Line r1, Line r2, Line r3, Line r4)
 Specific constructor with 4 lines. More...
 
 Mat (const real &v)
 Constructor from an element. More...
 
template<typename real2 >
 Mat (const Mat< L, C, real2 > &m)
 Constructor from another matrix. More...
 
template<Size L2, Size C2, typename real2 >
 Mat (const Mat< L2, C2, real2 > &m)
 Constructor from another matrix with different size (with null default entries and ignoring outside entries) More...
 
template<typename real2 >
 Mat (const real2 *p)
 Constructor from an array of elements (stored per line). More...
 
Size getNbLines () const
 number of lines More...
 
Size getNbCols () const
 number of colums More...
 
void operator= (const real *p)
 Assignment from an array of elements (stored per line). More...
 
template<typename real2 >
void operator= (const Mat< L, C, real2 > &m)
 Assignment from another matrix. More...
 
template<Size L2, Size C2>
void operator= (const Mat< L2, C2, real > &m)
 Assignment from a matrix of different size. More...
 
template<Size L2, Size C2>
void getsub (Size L0, Size C0, Mat< L2, C2, real > &m) const
 
template<Size L2, Size C2>
void setsub (Size L0, Size C0, const Mat< L2, C2, real > &m)
 
template<Size L2>
void setsub (Size L0, Size C0, const Vec< L2, real > &v)
 
void clear ()
 Sets each element to 0. More...
 
void fill (real r)
 Sets each element to r. More...
 
const Lineline (Size i) const
 Read-only access to line i. More...
 
Col col (Size j) const
 Copy of column j. More...
 
LineNoInitoperator[] (Size i)
 Write acess to line i. More...
 
const LineNoInitoperator[] (Size i) const
 Read-only access to line i. More...
 
LineNoInitoperator() (Size i)
 Write acess to line i. More...
 
const LineNoInitoperator() (Size i) const
 Read-only access to line i. More...
 
real & operator() (Size i, Size j)
 Write access to element (i,j). More...
 
const real & operator() (Size i, Size j) const
 Read-only access to element (i,j). More...
 
const Linelptr () const
 Cast into a standard C array of lines (read-only). More...
 
Linelptr ()
 Cast into a standard C array of lines. More...
 
const real * ptr () const
 Cast into a standard C array of elements (stored per line) (read-only). More...
 
real * ptr ()
 Cast into a standard C array of elements (stored per line). More...
 
Linex ()
 Special access to first line. More...
 
Liney ()
 Special access to second line. More...
 
Linez ()
 Special access to third line. More...
 
Linew ()
 Special access to fourth line. More...
 
const Linex () const
 Special access to first line (read-only). More...
 
const Liney () const
 Special access to second line (read-only). More...
 
const Linez () const
 Special access to thrid line (read-only). More...
 
const Linew () const
 Special access to fourth line (read-only). More...
 
void identity ()
 Set matrix to identity. More...
 
void transpose (const Mat< C, L, real > &m)
 Set matrix as the transpose of m. More...
 
Mat< C, L, real > transposed () const
 Return the transpose of m. More...
 
void transpose ()
 Transpose the square matrix. More...
 
template<Size P>
Mat< L, P, real > operator* (const Mat< C, P, real > &m) const
 Matrix multiplication operator. More...
 
Mat< L, C, real > operator+ (const Mat< L, C, real > &m) const
 Matrix addition operator. More...
 
Mat< L, C, real > operator- (const Mat< L, C, real > &m) const
 Matrix subtraction operator. More...
 
Mat< L, C, real > operator- () const
 Matrix negation operator. More...
 
Col operator* (const Line &v) const
 Multiplication operator Matrix * Line. More...
 
Mat< L, C, real > multDiagonal (const Line &d) const
 Multiplication with a diagonal Matrix CxC represented as a vector of size C. More...
 
Line multTranspose (const Col &v) const
 Multiplication of the transposed Matrix * Column. More...
 
template<Size P>
Mat< C, P, real > multTranspose (const Mat< L, P, real > &m) const
 Transposed Matrix multiplication operator. More...
 
template<Size P>
Mat< L, P, real > multTransposed (const Mat< P, C, real > &m) const
 Multiplication with the transposed of the given matrix operator. More...
 
Mat< L, C, real > plusTransposed (const Mat< C, L, real > &m) const
 Addition with the transposed of the given matrix operator. More...
 
Mat< L, C, real > minusTransposed (const Mat< C, L, real > &m) const
 Substraction with the transposed of the given matrix operator. More...
 
Mat< L, C, real > operator* (real f) const
 Scalar multiplication operator. More...
 
Mat< L, C, real > operator/ (real f) const
 Scalar division operator. More...
 
void operator*= (real r)
 Scalar multiplication assignment operator. More...
 
void operator/= (real r)
 Scalar division assignment operator. More...
 
void operator+= (const Mat< L, C, real > &m)
 Addition assignment operator. More...
 
void addTransposed (const Mat< C, L, real > &m)
 Addition of the transposed of m. More...
 
void subTransposed (const Mat< C, L, real > &m)
 Substraction of the transposed of m. More...
 
void operator-= (const Mat< L, C, real > &m)
 Substraction assignment operator. More...
 
Mat< L, C, real > inverted () const
 invert this More...
 
bool invert (const Mat< L, C, real > &m)
 Invert square matrix m. More...
 
bool isTransform () const
 
Vec< C-1, real > transform (const Vec< C-1, real > &v) const
 Multiplication operator Matrix * Vector considering the matrix as a transformation. More...
 
bool transformInvert (const Mat< L, C, real > &m)
 Invert transformation matrix m. More...
 
void symmetrize ()
 
Tests operators
bool operator== (const Mat< L, C, real > &b) const
 
bool operator!= (const Mat< L, C, real > &b) const
 
bool isSymmetric () const
 
bool isDiagonal () const
 
- Public Member Functions inherited from sofa::helper::fixed_array< VecNoInit< C, real >, L >
 fixed_array ()
 
 fixed_array (value_type r1)
 Specific constructor for 1-element vectors. More...
 
 fixed_array (value_type r1, value_type r2)
 Specific constructor for 2-elements vectors. More...
 
 fixed_array (value_type r1, value_type r2, value_type r3)
 Specific constructor for 3-elements vectors. More...
 
 fixed_array (value_type r1, value_type r2, value_type r3, value_type r4)
 Specific constructor for 4-elements vectors. More...
 
 fixed_array (value_type r1, value_type r2, value_type r3, value_type r4, value_type r5)
 Specific constructor for 5-elements vectors. More...
 
 fixed_array (value_type r1, value_type r2, value_type r3, value_type r4, value_type r5, value_type r6)
 Specific constructor for 6-elements vectors. More...
 
 fixed_array (value_type r1, value_type r2, value_type r3, value_type r4, value_type r5, value_type r6, value_type r7)
 Specific constructor for 7-elements vectors. More...
 
 fixed_array (value_type r1, value_type r2, value_type r3, value_type r4, value_type r5, value_type r6, value_type r7, value_type r8)
 Specific constructor for 8-elements vectors. More...
 
 fixed_array (value_type r1, value_type r2, value_type r3, value_type r4, value_type r5, value_type r6, value_type r7, value_type r8, value_type r9)
 Specific constructor for 9-elements vectors. More...
 
 fixed_array (value_type r1, value_type r2, value_type r3, value_type r4, value_type r5, value_type r6, value_type r7, value_type r8, value_type r9, value_type r10)
 Specific constructor for 10-elements vectors. More...
 
iterator begin ()
 
const_iterator begin () const
 
iterator end ()
 
const_iterator end () const
 
reference operator[] (Size i)
 
const_reference operator[] (Size i) const
 
reference at (Size i)
 
const_reference at (Size i) const
 
reference front ()
 
const_reference front () const
 
reference back ()
 
const_reference back () const
 
void swap (fixed_array< VecNoInit< C, real >, N > &y)
 
const VecNoInit< C, real > * data () const
 
const Arrayarray () const
 direct access to array More...
 
Arrayarray ()
 direct access to array More...
 
fixed_array< VecNoInit< C, real >, N > & operator= (const fixed_array< T2, N > &rhs)
 
void assign (const VecNoInit< C, real > &value)
 
bool operator< (const fixed_array &v) const
 

Static Public Member Functions

static Mat< L, L, real > Identity ()
 Returns the identity matrix. More...
 
template<Size S>
static bool canSelfTranspose (const Mat< S, S, real > &lhs, const Mat< S, S, real > &rhs)
 
template<Size I, Size J>
static bool canSelfTranspose (const Mat< I, J, real > &, const Mat< J, I, real > &)
 
static Mat< L, C, real > transformTranslation (const Vec< C-1, real > &t)
 
static Mat< L, C, real > transformScale (real s)
 
static Mat< L, C, real > transformScale (const Vec< C-1, real > &s)
 
template<class Quat >
static Mat< L, C, real > transformRotation (const Quat &q)
 
- Static Public Member Functions inherited from sofa::helper::fixed_array< VecNoInit< C, real >, L >
static Size size ()
 
static bool empty ()
 
static Size max_size ()
 

Friends

Mat< L, C, real > operator* (real r, const Mat< L, C, real > &m)
 Scalar matrix multiplication operator. More...
 

Additional Inherited Members

- Public Attributes inherited from sofa::helper::fixed_array< VecNoInit< C, real >, L >
VecNoInit< C, real > elems [N]
 

Attribute details

template<sofa::Size L, sofa::Size C, class real = float>
const Size sofa::defaulttype::Mat< L, C, real >::nbCols = C
static
template<sofa::Size L, sofa::Size C, class real = float>
const Size sofa::defaulttype::Mat< L, C, real >::nbLines = L
static
template<sofa::Size L, sofa::Size C, class real = float>
Mat< L, L, real > sofa::defaulttype::Mat< L, C, real >::s_identity = Mat<L,L,real>::Identity()
static

precomputed identity matrix of size (L,L)

Constructor details

template<sofa::Size L, sofa::Size C, class real = float>
sofa::defaulttype::Mat< L, C, real >::Mat ( )
inline
template<sofa::Size L, sofa::Size C, class real = float>
sofa::defaulttype::Mat< L, C, real >::Mat ( NoInit  )
inlineexplicit
template<sofa::Size L, sofa::Size C, class real = float>
sofa::defaulttype::Mat< L, C, real >::Mat ( Line  r1,
Line  r2 
)
inline

Specific constructor with 2 lines.

template<sofa::Size L, sofa::Size C, class real = float>
sofa::defaulttype::Mat< L, C, real >::Mat ( Line  r1,
Line  r2,
Line  r3 
)
inline

Specific constructor with 3 lines.

template<sofa::Size L, sofa::Size C, class real = float>
sofa::defaulttype::Mat< L, C, real >::Mat ( Line  r1,
Line  r2,
Line  r3,
Line  r4 
)
inline

Specific constructor with 4 lines.

template<sofa::Size L, sofa::Size C, class real = float>
sofa::defaulttype::Mat< L, C, real >::Mat ( const real &  v)
inlineexplicit

Constructor from an element.

template<sofa::Size L, sofa::Size C, class real = float>
template<typename real2 >
sofa::defaulttype::Mat< L, C, real >::Mat ( const Mat< L, C, real2 > &  m)
inline

Constructor from another matrix.

template<sofa::Size L, sofa::Size C, class real = float>
template<Size L2, Size C2, typename real2 >
sofa::defaulttype::Mat< L, C, real >::Mat ( const Mat< L2, C2, real2 > &  m)
inlineexplicit

Constructor from another matrix with different size (with null default entries and ignoring outside entries)

template<sofa::Size L, sofa::Size C, class real = float>
template<typename real2 >
sofa::defaulttype::Mat< L, C, real >::Mat ( const real2 *  p)
inlineexplicit

Constructor from an array of elements (stored per line).

Function details

template<sofa::Size L, sofa::Size C, class real = float>
void sofa::defaulttype::Mat< L, C, real >::addTransposed ( const Mat< C, L, real > &  m)
inline

Addition of the transposed of m.

template<sofa::Size L, sofa::Size C, class real = float>
template<Size S>
static bool sofa::defaulttype::Mat< L, C, real >::canSelfTranspose ( const Mat< S, S, real > &  lhs,
const Mat< S, S, real > &  rhs 
)
inlinestatic
template<sofa::Size L, sofa::Size C, class real = float>
template<Size I, Size J>
static bool sofa::defaulttype::Mat< L, C, real >::canSelfTranspose ( const Mat< I, J, real > &  ,
const Mat< J, I, real > &   
)
inlinestatic
template<sofa::Size L, sofa::Size C, class real = float>
void sofa::defaulttype::Mat< L, C, real >::clear ( )
inline

Sets each element to 0.

template<sofa::Size L, sofa::Size C, class real = float>
Col sofa::defaulttype::Mat< L, C, real >::col ( Size  j) const
inline

Copy of column j.

template<sofa::Size L, sofa::Size C, class real = float>
void sofa::defaulttype::Mat< L, C, real >::fill ( real  r)
inline

Sets each element to r.

template<sofa::Size L, sofa::Size C, class real = float>
Size sofa::defaulttype::Mat< L, C, real >::getNbCols ( ) const
inline

number of colums

template<sofa::Size L, sofa::Size C, class real = float>
Size sofa::defaulttype::Mat< L, C, real >::getNbLines ( ) const
inline

number of lines

template<sofa::Size L, sofa::Size C, class real = float>
template<Size L2, Size C2>
void sofa::defaulttype::Mat< L, C, real >::getsub ( Size  L0,
Size  C0,
Mat< L2, C2, real > &  m 
) const
inline
template<sofa::Size L, sofa::Size C, class real = float>
void sofa::defaulttype::Mat< L, C, real >::identity ( )
inline

Set matrix to identity.

template<sofa::Size L, sofa::Size C, class real = float>
static Mat<L,L,real> sofa::defaulttype::Mat< L, C, real >::Identity ( )
inlinestatic

Returns the identity matrix.

template<sofa::Size L, sofa::Size C, class real = float>
bool sofa::defaulttype::Mat< L, C, real >::invert ( const Mat< L, C, real > &  m)
inline

Invert square matrix m.

template<sofa::Size L, sofa::Size C, class real = float>
Mat<L,C,real> sofa::defaulttype::Mat< L, C, real >::inverted ( ) const
inline

invert this

template<sofa::Size L, sofa::Size C, class real = float>
bool sofa::defaulttype::Mat< L, C, real >::isDiagonal ( ) const
inline
template<sofa::Size L, sofa::Size C, class real = float>
bool sofa::defaulttype::Mat< L, C, real >::isSymmetric ( ) const
inline
template<sofa::Size L, sofa::Size C, class real = float>
bool sofa::defaulttype::Mat< L, C, real >::isTransform ( ) const
inline
Returns
True if and only if the Matrix is a transformation matrix
template<sofa::Size L, sofa::Size C, class real = float>
const Line& sofa::defaulttype::Mat< L, C, real >::line ( Size  i) const
inline

Read-only access to line i.

template<sofa::Size L, sofa::Size C, class real = float>
const Line* sofa::defaulttype::Mat< L, C, real >::lptr ( ) const
inline

Cast into a standard C array of lines (read-only).

template<sofa::Size L, sofa::Size C, class real = float>
Line* sofa::defaulttype::Mat< L, C, real >::lptr ( )
inline

Cast into a standard C array of lines.

template<sofa::Size L, sofa::Size C, class real = float>
Mat<L,C,real> sofa::defaulttype::Mat< L, C, real >::minusTransposed ( const Mat< C, L, real > &  m) const
inline

Substraction with the transposed of the given matrix operator.

Returns
this - mt
template<sofa::Size L, sofa::Size C, class real = float>
Mat<L,C,real> sofa::defaulttype::Mat< L, C, real >::multDiagonal ( const Line d) const
inline

Multiplication with a diagonal Matrix CxC represented as a vector of size C.

template<sofa::Size L, sofa::Size C, class real = float>
Line sofa::defaulttype::Mat< L, C, real >::multTranspose ( const Col v) const
inline

Multiplication of the transposed Matrix * Column.

template<sofa::Size L, sofa::Size C, class real = float>
template<Size P>
Mat<C,P,real> sofa::defaulttype::Mat< L, C, real >::multTranspose ( const Mat< L, P, real > &  m) const
inline

Transposed Matrix multiplication operator.

template<sofa::Size L, sofa::Size C, class real = float>
template<Size P>
Mat<L,P,real> sofa::defaulttype::Mat< L, C, real >::multTransposed ( const Mat< P, C, real > &  m) const
inline

Multiplication with the transposed of the given matrix operator.

Returns
this * mt
template<sofa::Size L, sofa::Size C, class real = float>
bool sofa::defaulttype::Mat< L, C, real >::operator!= ( const Mat< L, C, real > &  b) const
inline
template<sofa::Size L, sofa::Size C, class real = float>
LineNoInit& sofa::defaulttype::Mat< L, C, real >::operator() ( Size  i)
inline

Write acess to line i.

template<sofa::Size L, sofa::Size C, class real = float>
const LineNoInit& sofa::defaulttype::Mat< L, C, real >::operator() ( Size  i) const
inline

Read-only access to line i.

template<sofa::Size L, sofa::Size C, class real = float>
real& sofa::defaulttype::Mat< L, C, real >::operator() ( Size  i,
Size  j 
)
inline

Write access to element (i,j).

template<sofa::Size L, sofa::Size C, class real = float>
const real& sofa::defaulttype::Mat< L, C, real >::operator() ( Size  i,
Size  j 
) const
inline

Read-only access to element (i,j).

template<sofa::Size L, sofa::Size C, class real = float>
template<Size P>
Mat<L,P,real> sofa::defaulttype::Mat< L, C, real >::operator* ( const Mat< C, P, real > &  m) const
inline

Matrix multiplication operator.

template<sofa::Size L, sofa::Size C, class real = float>
Col sofa::defaulttype::Mat< L, C, real >::operator* ( const Line v) const
inline

Multiplication operator Matrix * Line.

template<sofa::Size L, sofa::Size C, class real = float>
Mat<L,C,real> sofa::defaulttype::Mat< L, C, real >::operator* ( real  f) const
inline

Scalar multiplication operator.

template<sofa::Size L, sofa::Size C, class real = float>
void sofa::defaulttype::Mat< L, C, real >::operator*= ( real  r)
inline

Scalar multiplication assignment operator.

template<sofa::Size L, sofa::Size C, class real = float>
Mat<L,C,real> sofa::defaulttype::Mat< L, C, real >::operator+ ( const Mat< L, C, real > &  m) const
inline

Matrix addition operator.

template<sofa::Size L, sofa::Size C, class real = float>
void sofa::defaulttype::Mat< L, C, real >::operator+= ( const Mat< L, C, real > &  m)
inline

Addition assignment operator.

template<sofa::Size L, sofa::Size C, class real = float>
Mat<L,C,real> sofa::defaulttype::Mat< L, C, real >::operator- ( const Mat< L, C, real > &  m) const
inline

Matrix subtraction operator.

template<sofa::Size L, sofa::Size C, class real = float>
Mat<L,C,real> sofa::defaulttype::Mat< L, C, real >::operator- ( ) const
inline

Matrix negation operator.

template<sofa::Size L, sofa::Size C, class real = float>
void sofa::defaulttype::Mat< L, C, real >::operator-= ( const Mat< L, C, real > &  m)
inline

Substraction assignment operator.

template<sofa::Size L, sofa::Size C, class real = float>
Mat<L,C,real> sofa::defaulttype::Mat< L, C, real >::operator/ ( real  f) const
inline

Scalar division operator.

template<sofa::Size L, sofa::Size C, class real = float>
void sofa::defaulttype::Mat< L, C, real >::operator/= ( real  r)
inline

Scalar division assignment operator.

template<sofa::Size L, sofa::Size C, class real = float>
void sofa::defaulttype::Mat< L, C, real >::operator= ( const real *  p)
inline

Assignment from an array of elements (stored per line).

template<sofa::Size L, sofa::Size C, class real = float>
template<typename real2 >
void sofa::defaulttype::Mat< L, C, real >::operator= ( const Mat< L, C, real2 > &  m)
inline

Assignment from another matrix.

template<sofa::Size L, sofa::Size C, class real = float>
template<Size L2, Size C2>
void sofa::defaulttype::Mat< L, C, real >::operator= ( const Mat< L2, C2, real > &  m)
inline

Assignment from a matrix of different size.

template<sofa::Size L, sofa::Size C, class real = float>
bool sofa::defaulttype::Mat< L, C, real >::operator== ( const Mat< L, C, real > &  b) const
inline
template<sofa::Size L, sofa::Size C, class real = float>
LineNoInit& sofa::defaulttype::Mat< L, C, real >::operator[] ( Size  i)
inline

Write acess to line i.

template<sofa::Size L, sofa::Size C, class real = float>
const LineNoInit& sofa::defaulttype::Mat< L, C, real >::operator[] ( Size  i) const
inline

Read-only access to line i.

template<sofa::Size L, sofa::Size C, class real = float>
Mat<L,C,real> sofa::defaulttype::Mat< L, C, real >::plusTransposed ( const Mat< C, L, real > &  m) const
inline

Addition with the transposed of the given matrix operator.

Returns
this + mt
template<sofa::Size L, sofa::Size C, class real = float>
const real* sofa::defaulttype::Mat< L, C, real >::ptr ( ) const
inline

Cast into a standard C array of elements (stored per line) (read-only).

template<sofa::Size L, sofa::Size C, class real = float>
real* sofa::defaulttype::Mat< L, C, real >::ptr ( )
inline

Cast into a standard C array of elements (stored per line).

template<sofa::Size L, sofa::Size C, class real = float>
template<Size L2, Size C2>
void sofa::defaulttype::Mat< L, C, real >::setsub ( Size  L0,
Size  C0,
const Mat< L2, C2, real > &  m 
)
inline
template<sofa::Size L, sofa::Size C, class real = float>
template<Size L2>
void sofa::defaulttype::Mat< L, C, real >::setsub ( Size  L0,
Size  C0,
const Vec< L2, real > &  v 
)
inline
template<sofa::Size L, sofa::Size C, class real = float>
void sofa::defaulttype::Mat< L, C, real >::subTransposed ( const Mat< C, L, real > &  m)
inline

Substraction of the transposed of m.

template<sofa::Size L, sofa::Size C, class real = float>
void sofa::defaulttype::Mat< L, C, real >::symmetrize ( )
inline

for square matrices

Warning
in-place simple symmetrization this = ( this + this.transposed() ) / 2.0
template<sofa::Size L, sofa::Size C, class real = float>
Vec<C-1,real> sofa::defaulttype::Mat< L, C, real >::transform ( const Vec< C-1, real > &  v) const
inline

Multiplication operator Matrix * Vector considering the matrix as a transformation.

template<sofa::Size L, sofa::Size C, class real = float>
bool sofa::defaulttype::Mat< L, C, real >::transformInvert ( const Mat< L, C, real > &  m)
inline

Invert transformation matrix m.

template<sofa::Size L, sofa::Size C, class real = float>
template<class Quat >
static Mat<L,C,real> sofa::defaulttype::Mat< L, C, real >::transformRotation ( const Quat q)
inlinestatic
template<sofa::Size L, sofa::Size C, class real = float>
static Mat<L,C,real> sofa::defaulttype::Mat< L, C, real >::transformScale ( real  s)
inlinestatic
template<sofa::Size L, sofa::Size C, class real = float>
static Mat<L,C,real> sofa::defaulttype::Mat< L, C, real >::transformScale ( const Vec< C-1, real > &  s)
inlinestatic
template<sofa::Size L, sofa::Size C, class real = float>
static Mat<L,C,real> sofa::defaulttype::Mat< L, C, real >::transformTranslation ( const Vec< C-1, real > &  t)
inlinestatic
template<sofa::Size L, sofa::Size C, class real = float>
void sofa::defaulttype::Mat< L, C, real >::transpose ( const Mat< C, L, real > &  m)
inline

Set matrix as the transpose of m.

template<sofa::Size L, sofa::Size C, class real = float>
void sofa::defaulttype::Mat< L, C, real >::transpose ( )
inline

Transpose the square matrix.

template<sofa::Size L, sofa::Size C, class real = float>
Mat<C,L,real> sofa::defaulttype::Mat< L, C, real >::transposed ( ) const
inline

Return the transpose of m.

template<sofa::Size L, sofa::Size C, class real = float>
Line& sofa::defaulttype::Mat< L, C, real >::w ( )
inline

Special access to fourth line.

template<sofa::Size L, sofa::Size C, class real = float>
const Line& sofa::defaulttype::Mat< L, C, real >::w ( ) const
inline

Special access to fourth line (read-only).

template<sofa::Size L, sofa::Size C, class real = float>
Line& sofa::defaulttype::Mat< L, C, real >::x ( )
inline

Special access to first line.

template<sofa::Size L, sofa::Size C, class real = float>
const Line& sofa::defaulttype::Mat< L, C, real >::x ( ) const
inline

Special access to first line (read-only).

template<sofa::Size L, sofa::Size C, class real = float>
Line& sofa::defaulttype::Mat< L, C, real >::y ( )
inline

Special access to second line.

template<sofa::Size L, sofa::Size C, class real = float>
const Line& sofa::defaulttype::Mat< L, C, real >::y ( ) const
inline

Special access to second line (read-only).

template<sofa::Size L, sofa::Size C, class real = float>
Line& sofa::defaulttype::Mat< L, C, real >::z ( )
inline

Special access to third line.

template<sofa::Size L, sofa::Size C, class real = float>
const Line& sofa::defaulttype::Mat< L, C, real >::z ( ) const
inline

Special access to thrid line (read-only).

Enum details

template<sofa::Size L, sofa::Size C, class real = float>
anonymous enum
Enumerator

Related details

template<sofa::Size L, sofa::Size C, class real = float>
Mat<L,C,real> operator* ( real  r,
const Mat< L, C, real > &  m 
)
friend

Scalar matrix multiplication operator.