ltl::FMatrix< T, M, N > Class Template Reference
[The classes ltl::FVector and ltl::FMatrix]

Matrix with compile-time dimensions. More...

List of all members.

Public Types

Public Member Functions

Static Public Member Functions

Protected Attributes

Friends

Related Functions

(Note that these are not member functions.)

Detailed Description

template<class T, int M, int N>
class ltl::FMatrix< T, M, N >

Matrix with compile-time dimensions.

Indices are 1-based. STL-compatible iterators and types.


Member Typedef Documentation

template<class T, int M, int N>
typedef T ltl::FMatrix< T, M, N >::value_type

STL-compatible type definitions.

template<class T, int M, int N>
typedef FMIter<T,M,N> ltl::FMatrix< T, M, N >::iterator

template<class T, int M, int N>
typedef FMIterConst<T,M,N> ltl::FMatrix< T, M, N >::const_iterator

template<class T, int M, int N>
typedef T& ltl::FMatrix< T, M, N >::reference

template<class T, int M, int N>
typedef const T& ltl::FMatrix< T, M, N >::const_reference

template<class T, int M, int N>
typedef std::size_t ltl::FMatrix< T, M, N >::size_type

template<class T, int M, int N>
typedef std::ptrdiff_t ltl::FMatrix< T, M, N >::difference_type

template<class T, int M, int N>
typedef FVector<T,M,N> ltl::FMatrix< T, M, N >::ColumnVector

template<class T, int M, int N>
typedef FVector<T,N,1> ltl::FMatrix< T, M, N >::RowVector

template<class T, int M, int N>
typedef FVector<T,M,N+1> ltl::FMatrix< T, M, N >::TraceVector


Member Enumeration Documentation

template<class T, int M, int N>
anonymous enum

Used by expression engine to decide which loops to unroll.

Enumerator:
static_size 


Constructor & Destructor Documentation

template<class T, int M, int N>
ltl::FMatrix< T, M, N >::FMatrix (  )  [inline]

default constructor

template<class T, int M, int N>
ltl::FMatrix< T, M, N >::~FMatrix (  )  [inline]

default destructor

template<class T, int M, int N>
ltl::FMatrix< T, M, N >::FMatrix ( const FMatrix< T, M, N > &  other  ) 

copy constructor: copy elements of other.

template<class T, int M, int N>
ltl::FMatrix< T, M, N >::FMatrix ( const T *  t  ) 

copy contents of memory pointed to by t.

template<class T, int M, int N>
ltl::FMatrix< T, M, N >::FMatrix ( const T  t  ) 

fill with value t.

template<class T, int M, int N>
template<class Expr>
ltl::FMatrix< T, M, N >::FMatrix ( const FMExprNode< Expr, M, N > &  e  )  [inline]

construct from expression.


Member Function Documentation

template<class T, int M, int N>
static size_type ltl::FMatrix< T, M, N >::size (  )  [inline, static]

STL return M*N.

Functions needed for STL container conformance

template<class T, int M, int N>
static bool ltl::FMatrix< T, M, N >::empty (  )  [inline, static]

STL empty(). Always false.

template<class T, int M, int N>
static size_type ltl::FMatrix< T, M, N >::max_size (  )  [inline, static]

STL: Maximum capacity. Always ==size().

template<class T, int M, int N>
ListInitializationSwitch< FMatrix<T,M,N> > ltl::FMatrix< T, M, N >::operator= ( x  )  [inline]

Initialize with list of values or single value.

Assign values through initialization list. A bit more comlicated since we have to discriminate between A = 3; and A = 1, 2, 3, 4; which is done using ListInitializationSwitch which either calls ListInitializer or FVector::fill().

template<class T, int M, int N>
int ltl::FMatrix< T, M, N >::length (  )  const [inline]

return length of container (M*N).

template<class T, int M, int N>
int ltl::FMatrix< T, M, N >::minIndex ( const int  dim  )  const [inline]

return lowest index of dimension dim. Always 1.

template<class T, int M, int N>
int ltl::FMatrix< T, M, N >::maxIndex ( const int  dim  )  const [inline]

return highest index of dimension dim. Returns M or N.

template<class T, int M, int N>
T ltl::FMatrix< T, M, N >::operator() ( const int  i,
const int  j 
) const [inline]

1-based access to elements.

template<class T, int M, int N>
T& ltl::FMatrix< T, M, N >::operator() ( const int  i,
const int  j 
) [inline]

1-based access to elements.

template<class T, int M, int N>
T ltl::FMatrix< T, M, N >::operator[] ( const int  i  )  const [inline]

Direct zero-based access to the (linear) block of memory.

template<class T, int M, int N>
T& ltl::FMatrix< T, M, N >::operator[] ( const int  i  )  [inline]

Direct zero-based access to the (linear) block of memory.

template<class T, int M, int N>
ColumnVector ltl::FMatrix< T, M, N >::col ( const int  col  )  [inline]

Return an ltl::FVector object REFERENCEING the column vector col.

template<class T, int M, int N>
RowVector ltl::FMatrix< T, M, N >::row ( const int  row  )  [inline]

Return an ltl::FVector object REFERENCEING the row vector row.

template<class T, int M, int N>
TraceVector ltl::FMatrix< T, M, N >::traceVector (  )  [inline]

Return an ltl::FVector object REFERENCEING the trace vector.

template<class T, int M, int N>
T* ltl::FMatrix< T, M, N >::data (  )  [inline]

Return a pointer to the data.

template<class T, int M, int N>
const T* ltl::FMatrix< T, M, N >::data (  )  const [inline]

Return a const pointer to the data.

template<class T, int M, int N>
iterator ltl::FMatrix< T, M, N >::begin (  )  [inline]

return an iterator pointing to the first element.

template<class T, int M, int N>
const_iterator ltl::FMatrix< T, M, N >::begin (  )  const [inline]

return a const iterator pointing to the first element.

template<class T, int M, int N>
void ltl::FMatrix< T, M, N >::fill ( const T  x  ) 

fill with value x.

template<class T, int M, int N>
template<class Expr>
FMatrix<T,M,N>& ltl::FMatrix< T, M, N >::operator= ( const FMExprNode< Expr, M, N > &  e  )  [inline]

operatorX= for expression rhs.

template<class T, int M, int N>
template<class Expr>
FMatrix<T,M,N>& ltl::FMatrix< T, M, N >::operator+= ( const FMExprNode< Expr, M, N > &  e  )  [inline]

template<class T, int M, int N>
template<class Expr>
FMatrix<T,M,N>& ltl::FMatrix< T, M, N >::operator-= ( const FMExprNode< Expr, M, N > &  e  )  [inline]

template<class T, int M, int N>
template<class Expr>
FMatrix<T,M,N>& ltl::FMatrix< T, M, N >::operator *= ( const FMExprNode< Expr, M, N > &  e  )  [inline]

template<class T, int M, int N>
template<class Expr>
FMatrix<T,M,N>& ltl::FMatrix< T, M, N >::operator/= ( const FMExprNode< Expr, M, N > &  e  )  [inline]

template<class T, int M, int N>
template<class Expr>
FMatrix<T,M,N>& ltl::FMatrix< T, M, N >::operator%= ( const FMExprNode< Expr, M, N > &  e  )  [inline]

template<class T, int M, int N>
template<class Expr>
FMatrix<T,M,N>& ltl::FMatrix< T, M, N >::operator^= ( const FMExprNode< Expr, M, N > &  e  )  [inline]

template<class T, int M, int N>
template<class Expr>
FMatrix<T,M,N>& ltl::FMatrix< T, M, N >::operator &= ( const FMExprNode< Expr, M, N > &  e  )  [inline]

template<class T, int M, int N>
template<class Expr>
FMatrix<T,M,N>& ltl::FMatrix< T, M, N >::operator|= ( const FMExprNode< Expr, M, N > &  e  )  [inline]

template<class T, int M, int N>
template<class Expr>
FMatrix<T,M,N>& ltl::FMatrix< T, M, N >::operator<<= ( const FMExprNode< Expr, M, N > &  e  )  [inline]

template<class T, int M, int N>
template<class Expr>
FMatrix<T,M,N>& ltl::FMatrix< T, M, N >::operator>>= ( const FMExprNode< Expr, M, N > &  e  )  [inline]

template<class T, int M, int N>
template<class T2>
FMatrix<T,M,N>& ltl::FMatrix< T, M, N >::operator= ( const FMatrix< T2, M, N > &  v  )  [inline]

operatorX for FMatrix rhs.

template<class T, int M, int N>
FMatrix<T,M,N>& ltl::FMatrix< T, M, N >::operator= ( const FMatrix< T, M, N > &  v  ) 

template<class T, int M, int N>
template<class T2>
FMatrix<T,M,N>& ltl::FMatrix< T, M, N >::operator+= ( const FMatrix< T2, M, N > &  v  )  [inline]

template<class T, int M, int N>
template<class T2>
FMatrix<T,M,N>& ltl::FMatrix< T, M, N >::operator-= ( const FMatrix< T2, M, N > &  v  )  [inline]

template<class T, int M, int N>
template<class T2>
FMatrix<T,M,N>& ltl::FMatrix< T, M, N >::operator *= ( const FMatrix< T2, M, N > &  v  )  [inline]

template<class T, int M, int N>
template<class T2>
FMatrix<T,M,N>& ltl::FMatrix< T, M, N >::operator/= ( const FMatrix< T2, M, N > &  v  )  [inline]

template<class T, int M, int N>
template<class T2>
FMatrix<T,M,N>& ltl::FMatrix< T, M, N >::operator%= ( const FMatrix< T2, M, N > &  v  )  [inline]

template<class T, int M, int N>
template<class T2>
FMatrix<T,M,N>& ltl::FMatrix< T, M, N >::operator^= ( const FMatrix< T2, M, N > &  v  )  [inline]

template<class T, int M, int N>
template<class T2>
FMatrix<T,M,N>& ltl::FMatrix< T, M, N >::operator &= ( const FMatrix< T2, M, N > &  v  )  [inline]

template<class T, int M, int N>
template<class T2>
FMatrix<T,M,N>& ltl::FMatrix< T, M, N >::operator|= ( const FMatrix< T2, M, N > &  v  )  [inline]

template<class T, int M, int N>
template<class T2>
FMatrix<T,M,N>& ltl::FMatrix< T, M, N >::operator<<= ( const FMatrix< T2, M, N > &  v  )  [inline]

template<class T, int M, int N>
template<class T2>
FMatrix<T,M,N>& ltl::FMatrix< T, M, N >::operator>>= ( const FMatrix< T2, M, N > &  v  )  [inline]

template<class T, int M, int N>
FMatrix<T,M,N>& ltl::FMatrix< T, M, N >::operator+= ( const T  t  ) 

operatorX= for scalar rhs.

template<class T, int M, int N>
FMatrix<T,M,N>& ltl::FMatrix< T, M, N >::operator-= ( const T  t  ) 

template<class T, int M, int N>
FMatrix<T,M,N>& ltl::FMatrix< T, M, N >::operator *= ( const T  t  ) 

template<class T, int M, int N>
FMatrix<T,M,N>& ltl::FMatrix< T, M, N >::operator/= ( const T  t  ) 

template<class T, int M, int N>
FMatrix<T,M,N>& ltl::FMatrix< T, M, N >::operator%= ( const T  t  ) 

template<class T, int M, int N>
FMatrix<T,M,N>& ltl::FMatrix< T, M, N >::operator^= ( const T  t  ) 

template<class T, int M, int N>
FMatrix<T,M,N>& ltl::FMatrix< T, M, N >::operator &= ( const T  t  ) 

template<class T, int M, int N>
FMatrix<T,M,N>& ltl::FMatrix< T, M, N >::operator|= ( const T  t  ) 

template<class T, int M, int N>
FMatrix<T,M,N>& ltl::FMatrix< T, M, N >::operator<<= ( const T  t  ) 

template<class T, int M, int N>
FMatrix<T,M,N>& ltl::FMatrix< T, M, N >::operator>>= ( const T  t  ) 

template<class T, int M, int N>
void ltl::FMatrix< T, M, N >::swapRows ( const int  row1,
const int  row2 
)

Swap the values in two row vectors.

template<class T, int M, int N>
void ltl::FMatrix< T, M, N >::swapCols ( const int  col1,
const int  col2 
)

Swap the values in two column vectors.


Friends And Related Function Documentation

template<class T, int M, int N>
friend class FMIter< T, M, N > [friend]

template<class T, int M, int N>
friend class FMIterConst< T, M, N > [friend]

template<class T, int M, int N>
friend class ListInitializationSwitch< FMatrix< T, M, N > > [friend]

template<class T, int M, int N>
ostream & operator<< ( ostream &  os,
const FMatrix< T, M, N > &  A 
) [related]


Member Data Documentation

template<class T, int M, int N>
T* ltl::FMatrix< T, M, N >::data_ [protected]

Pointer used for one-based access to the data.

template<class T, int M, int N>
T ltl::FMatrix< T, M, N >::__data_[M *N] [protected]

Storage for the matrix elements.


Generated on Wed Mar 11 17:44:36 2009 for LTL by  doxygen 1.5.3