Highly flexible and optimized matrix class implementation. More...

#include <DynMatrix.h>

Inheritance diagram for icl::math::DynMatrix< T >:

Classes
struct	col_iterator
	Internal column iterator struct (using height-stride) More...
class	DynMatrixColumn
	Internally used Utility structure referencing a matrix column shallowly. More...
Public Types
typedef T *	iterator
	default iterator type (just a data-pointer)
typedef const T *	const_iterator
	dafault const_iterator type (just a data-pointer)
typedef T *	row_iterator
	comples row_iterator type
typedef const T *	const_row_iterator
	complex const_row_iterator type
typedef const col_iterator	const_col_iterator
	const column iterator typedef
typedef void(*	GESDD )(const char , const int , const int , T , const int , T , T , const int , T , const int , T , const int , int , int )
typedef void(*	CBLAS_GEMM )(CBLAS_ORDER, CBLAS_TRANSPOSE, CBLAS_TRANSPOSE, int, int, int, T, const T , int, const T , int, T, T *, int)
Public Member Functions
	DynMatrix (const DynMatrixColumn &column)
	creates a column matrix from given column of other matrix
	DynMatrix ()
	Default empty constructor creates a null-matrix.
	DynMatrix (unsigned int cols, unsigned int rows, const T &initValue=0) throw (InvalidMatrixDimensionException)
	Create a dyn matrix with given dimensions (and optional initialValue)
	DynMatrix (unsigned int cols, unsigned int rows, T *data, bool deepCopy=true) throw (InvalidMatrixDimensionException)
	Create a matrix with given data.
	DynMatrix (unsigned int cols, unsigned int rows, const T *data) throw (InvalidMatrixDimensionException)
	Create a matrix with given data (const version: deepCopy only)
	DynMatrix (const DynMatrix &other)
	Default copy constructor.
	DynMatrix (const std::string &filename)
	creates a new DynMatrix from given csv filename
void	saveCSV (const std::string &filename) throw (utils::ICLException)
	writes the current matrix to a csv file
bool	isNull () const
	returns with this matrix has a valid data pointer
	~DynMatrix ()
	Destructor (deletes data if no wrapped shallowly)
DynMatrix &	operator= (const DynMatrix &other)
	Assignment operator (using deep/shallow-copy)
void	setBounds (unsigned int cols, unsigned int rows, bool holdContent=false, const T &initializer=0) throw (InvalidMatrixDimensionException)
	resets matrix dimensions
bool	isSimilar (const DynMatrix &other, T tollerance=0.0001) const
	tests weather a matrix is enough similar to another matrix
bool	operator== (const DynMatrix &other) const
	elementwise comparison (==)
bool	operator!= (const DynMatrix &other) const
	elementwise comparison (!=)
DynMatrix	operator* (T f) const
	Multiply elements with scalar.
DynMatrix &	mult (T f, DynMatrix &dst) const
	Multiply elements with scalar (in source destination fashion)
DynMatrix &	operator*= (T f)
	Multiply elements with scalar (inplace)
DynMatrix	operator/ (T f) const
	Device elements by scalar.
DynMatrix &	operator/= (T f)
	Device elements by scalar (inplace)
DynMatrix &	mult (const DynMatrix &m, DynMatrix &dst) const throw (IncompatibleMatrixDimensionException)
	Matrix multiplication (in source destination fashion) [IPP-Supported].
DynMatrix &	elementwise_mult (const DynMatrix &m, DynMatrix &dst) const throw (IncompatibleMatrixDimensionException)
	Elementwise matrix multiplication (in source destination fashion) [IPP-Supported].
DynMatrix	elementwise_mult (const DynMatrix &m) const throw (IncompatibleMatrixDimensionException)
	Elementwise matrix multiplication (without destination matrix) [IPP-Supported].
DynMatrix &	elementwise_div (const DynMatrix &m, DynMatrix &dst) const throw (IncompatibleMatrixDimensionException)
	Elementwise division (in source destination fashion) [IPP-Supported].
DynMatrix	elementwise_div (const DynMatrix &m) const throw (IncompatibleMatrixDimensionException)
	Elementwise matrix multiplication (without destination matrix) [IPP-Supported].
DynMatrix	operator* (const DynMatrix &m) const throw (IncompatibleMatrixDimensionException)
	Essential matrix multiplication [IPP-Supported].
DynMatrix &	operator*= (const DynMatrix &m) throw (IncompatibleMatrixDimensionException)
	inplace matrix multiplication applying this = this*m [IPP-Supported]
DynMatrix	operator/ (const DynMatrix &m) const throw (IncompatibleMatrixDimensionException, InvalidMatrixDimensionException, SingularMatrixException)
	inplace matrix devision (calling this/m.inv()) [IPP-Supported]
DynMatrix &	operator/= (const DynMatrix &m) const throw (IncompatibleMatrixDimensionException, InvalidMatrixDimensionException, SingularMatrixException)
	inplace matrix devision (calling this/m.inv()) (inplace)
DynMatrix	operator+ (const T &t) const
	adds a scalar to each element
DynMatrix	operator- (const T &t) const
	substacts a scalar from each element
DynMatrix &	operator+= (const T &t)
	adds a scalar to each element (inplace)
DynMatrix &	operator-= (const T &t)
	substacts a scalar from each element (inplace)
DynMatrix	operator+ (const DynMatrix &m) const throw (IncompatibleMatrixDimensionException)
	Matrix addition.
DynMatrix	operator- (const DynMatrix &m) const throw (IncompatibleMatrixDimensionException)
	Matrix substraction.
DynMatrix &	operator+= (const DynMatrix &m) throw (IncompatibleMatrixDimensionException)
	Matrix addition (inplace)
DynMatrix &	operator-= (const DynMatrix &m) throw (IncompatibleMatrixDimensionException)
	Matrix substraction (inplace)
T &	operator() (unsigned int col, unsigned int row)
	element access operator (x,y)-access index begin 0!
const T &	operator() (unsigned int col, unsigned int row) const
	element access operator (x,y)-access index begin 0! (const)
T &	at (unsigned int col, unsigned int row) throw (InvalidIndexException)
	element access with index check
const T &	at (unsigned int col, unsigned int row) const throw (InvalidIndexException)
	element access with index check (const)
T &	operator[] (unsigned int idx)
	linear access to actual data array
const T &	operator[] (unsigned int idx) const
	linear access to actual data array (const)
T	norm (double l=2) const
	applies an L_l norm on the matrix elements (all elements are treated as vector)
T	sqrDistanceTo (const DynMatrix &other) const throw (InvalidMatrixDimensionException)
	returns the squared distance of the inner data vectors (linearly interpreted) (IPP accelerated)
T	distanceTo (const DynMatrix &other) const throw (InvalidMatrixDimensionException)
	returns the distance of the inner data vectors (linearly interpreted) (IPP accelerated)
unsigned int	rows () const
	height of the matrix (number of rows)
unsigned int	cols () const
	width of the matrix (number of columns)
T *	data ()
	internal data pointer
const T *	data () const
	internal data pointer (const)
unsigned int	dim () const
	matrix dimension (widthheight) or (colsrows)
int	stride0 () const
	returns sizeof (T)*dim()
int	stride1 () const
	returns sizeof(T)*cols()
int	stride2 () const
	returns sizeof (T)
DynMatrix &	operator= (const DynMatrixColumn &col)
iterator	begin ()
	returns an iterator to the begin of internal data array
iterator	end ()
	returns an iterator to the end of internal data array
const_iterator	begin () const
	returns an iterator to the begin of internal data array (const)
const_iterator	end () const
	returns an iterator to the end of internal data array (const)
col_iterator	col_begin (unsigned int col)
	returns an iterator running through a certain matrix column
col_iterator	col_end (unsigned int col)
	returns an iterator end of a certain matrix column
const_col_iterator	col_begin (unsigned int col) const
	returns an iterator running through a certain matrix column (const)
const_col_iterator	col_end (unsigned int col) const
	returns an iterator end of a certain matrix column (const)
row_iterator	row_begin (unsigned int row)
	returns an iterator running through a certain matrix row
row_iterator	row_end (unsigned int row)
	returns an iterator of a certains row's end
const_row_iterator	row_begin (unsigned int row) const
	returns an iterator running through a certain matrix row (const)
const_row_iterator	row_end (unsigned int row) const
	returns an iterator of a certains row's end (const)
DynMatrix	row (int row)
	Extracts a shallow copied matrix row.
const DynMatrix	row (int row) const
	Extracts a shallow copied matrix row (const)
DynMatrixColumn	col (int col)
	Extracts a shallow copied matrix column.
const DynMatrixColumn	col (int col) const
void	decompose_QR (DynMatrix &Q, DynMatrix &R) const
	applies QR-decomposition using stabilized Gram-Schmidt orthonormalization (only for icl32f and icl64f)
void	decompose_RQ (DynMatrix &R, DynMatrix &Q) const
	applies RQ-decomposition (by exploiting implemnetation of QR-decomposition) (only for icl32f, and icl64f)
void	decompose_LU (DynMatrix &L, DynMatrix &U, T zeroThreshold=1E-16) const
	applies LU-decomposition (without using partial pivoting) (only for icl32f and icl64f)
DynMatrix	solve_upper_triangular (const DynMatrix &b) const throw (InvalidMatrixDimensionException)
	solves Mx=b for M=*this (only if M is a squared upper triangular matrix) (only for icl32f and icl64f)
DynMatrix	solve_lower_triangular (const DynMatrix &b) const throw (InvalidMatrixDimensionException)
	solves Mx=b for M=*this (only if M is a squared lower triangular matrix) (only for icl32f and icl64f)
DynMatrix	solve (const DynMatrix &b, const std::string &method="lu", T zeroThreshold=1E-16) throw (InvalidMatrixDimensionException, utils::ICLException, SingularMatrixException)
	solves Mx=b for M=*this (only for icl32f and icl64f)
DynMatrix	inv () const throw (InvalidMatrixDimensionException, SingularMatrixException)
	invert the matrix (only for icl32f and icl64f)
void	eigen (DynMatrix &eigenvectors, DynMatrix &eigenvalues) const throw (InvalidMatrixDimensionException, utils::ICLException)
	Extracts the matrix's eigenvalues and eigenvectors.
void	svd (DynMatrix &U, DynMatrix &S, DynMatrix &V) const throw (utils::ICLException)
	Computes Singular Value Decomposition of a matrix - decomposes A into USV'.
DynMatrix	pinv (bool useSVD=false, T zeroThreshold=1E-16) const throw (InvalidMatrixDimensionException,SingularMatrixException,utils::ICLException)
	calculates the Moore-Penrose pseudo-inverse (only implemented for icl32f and icl64f)
DynMatrix	big_matrix_pinv (T zeroThreshold=1E-16) const throw (InvalidMatrixDimensionException,SingularMatrixException,utils::ICLException)
	calculates the Moore-Penrose pseudo-inverse (specialized for big matrices)
DynMatrix	big_matrix_pinv (T zeroThreshold, GESDD gesdd, CBLAS_GEMM cblas_gemm) const throw (InvalidMatrixDimensionException,SingularMatrixException,utils::ICLException)
T	det () const throw (InvalidMatrixDimensionException)
	matrix determinant (only for icl32f and icl64f)
DynMatrix	transp () const
	matrix transposed
const DynMatrix< T >	shallowTransposed () const
	returns a shallow transposed copy of this matrix (dimensions are swapped, data is not re-aranged) (const)
const DynMatrix< T >	shallowTransposed ()
	returns a shallow transposed copy of this matrix (dimensions are swapped, data is not re-aranged)
void	reshape (int newCols, int newRows) throw (InvalidMatrixDimensionException)
	resets the matrix dimensions without changing the content
T	element_wise_inner_product (const DynMatrix< T > &other) const
	inner product of data pointers (not matrix-mulitiplication)
DynMatrix< T >	dot (const DynMatrix< T > &M) const throw (InvalidMatrixDimensionException)
	returns the inner product of two matrices (i.e. dot-product)
DynMatrix< T >	diag () const
	returns diagonal-elements as column-vector
T	trace () const
	computes the sum of all diagonal elements
T	cond (const double p=2) const
	computes the condition of a matrix
T *	set_data (T *newData)
	sets new data internally and returns old data pointer (for experts only!)
Static Public Member Functions
static DynMatrix< T >	loadCSV (const std::string &filename) throw (utils::ICLException)
	loads a dynmatrix from given CSV file
static DynMatrix< T >	cross (const DynMatrix< T > &x, const DynMatrix< T > &y) throw (InvalidMatrixDimensionException)
	computes the cross product
static DynMatrix	id (unsigned int dim)
	creates a dim-D identity Matrix
Private Member Functions
void	row_check (unsigned int row) const
void	col_check (unsigned int col) const
void	idx_check (unsigned int col, unsigned int row) const
void	idx_check (unsigned int idx) const
Private Attributes
int	m_rows
int	m_cols
T *	m_data
bool	m_ownData

Detailed Description

template<class T>
struct icl::math::DynMatrix< T >

Highly flexible and optimized matrix class implementation.

In contrast to the FixedMatrix template class, the DynMatrix instances are dynamically sized at runtime The template class is instantiated for the common ICL types uint8_t, int16_t, int32_t, float and double

Member Typedef Documentation

template<class T>

typedef void(* icl::math::DynMatrix< T >::CBLAS_GEMM)(CBLAS_ORDER, CBLAS_TRANSPOSE, CBLAS_TRANSPOSE, int, int, int, T, const T *, int, const T *, int, T, T *, int)

template<class T>

typedef const col_iterator icl::math::DynMatrix< T >::const_col_iterator

const column iterator typedef

template<class T>

typedef const T* icl::math::DynMatrix< T >::const_iterator

dafault const_iterator type (just a data-pointer)

template<class T>

typedef const T* icl::math::DynMatrix< T >::const_row_iterator

complex const_row_iterator type

template<class T>

typedef void(* icl::math::DynMatrix< T >::GESDD)(const char *, const int *, const int *, T *, const int *, T *, T *, const int *, T *, const int *, T *, const int *, int *, int *)

template<class T>

typedef T* icl::math::DynMatrix< T >::iterator

default iterator type (just a data-pointer)

template<class T>

typedef T* icl::math::DynMatrix< T >::row_iterator

comples row_iterator type

Constructor & Destructor Documentation

template<class T>

icl::math::DynMatrix< T >::DynMatrix ( const DynMatrixColumn & column )

creates a column matrix from given column of other matrix

template<class T>

icl::math::DynMatrix< T >::DynMatrix ( ) [inline]

Default empty constructor creates a null-matrix.

template<class T>

icl::math::DynMatrix< T >::DynMatrix	(	unsigned int	cols,
		unsigned int	rows,
		const T &	initValue = `0`
	)		throw (InvalidMatrixDimensionException) `[inline]`

Create a dyn matrix with given dimensions (and optional initialValue)

template<class T>

icl::math::DynMatrix< T >::DynMatrix	(	unsigned int	cols,
		unsigned int	rows,
		T *	data,
		bool	deepCopy = `true`
	)		throw (InvalidMatrixDimensionException) `[inline]`

Create a matrix with given data.

Data can be wrapped deeply or shallowly. If the latter is true, given data pointer will not be released in the destructor

template<class T>

icl::math::DynMatrix< T >::DynMatrix	(	unsigned int	cols,
		unsigned int	rows,
		const T *	data
	)		throw (InvalidMatrixDimensionException) `[inline]`

Create a matrix with given data (const version: deepCopy only)

template<class T>

icl::math::DynMatrix< T >::DynMatrix ( const DynMatrix< T > & other ) [inline]

Default copy constructor.

template<class T>

icl::math::DynMatrix< T >::DynMatrix ( const std::string & filename ) [inline]

creates a new DynMatrix from given csv filename

See also:: DynMatrix<T>::loadCSV

template<class T>

icl::math::DynMatrix< T >::~DynMatrix ( ) [inline]

Destructor (deletes data if no wrapped shallowly)

Member Function Documentation

template<class T>

T& icl::math::DynMatrix< T >::at	(	unsigned int	col,
		unsigned int	row
	)		throw (InvalidIndexException) `[inline]`

element access with index check

template<class T>

const T& icl::math::DynMatrix< T >::at	(	unsigned int	col,
		unsigned int	row
	)		const throw (InvalidIndexException) `[inline]`

element access with index check (const)

template<class T>

iterator icl::math::DynMatrix< T >::begin ( ) [inline]

returns an iterator to the begin of internal data array

template<class T>

const_iterator icl::math::DynMatrix< T >::begin ( ) const [inline]

returns an iterator to the begin of internal data array (const)

template<class T>

DynMatrix icl::math::DynMatrix< T >::big_matrix_pinv ( T zeroThreshold = 1E-16 ) const throw (InvalidMatrixDimensionException,SingularMatrixException,utils::ICLException)

calculates the Moore-Penrose pseudo-inverse (specialized for big matrices)

Calculate pseudo inverse of given matrix using Intel MKL if possible. Based on singular value decomposition (SVD) and divide & conquer.

Parameters:

zeroThreshold singular values below threshold are set to zero

Returns:: pseudo inverse

template<class T>

DynMatrix icl::math::DynMatrix< T >::big_matrix_pinv	(	T	zeroThreshold,
		GESDD	gesdd,
		CBLAS_GEMM	cblas_gemm
	)		const throw (InvalidMatrixDimensionException,SingularMatrixException,utils::ICLException)

template<class T>

DynMatrixColumn icl::math::DynMatrix< T >::col ( int col ) [inline]

Extracts a shallow copied matrix column.

template<class T>

const DynMatrixColumn icl::math::DynMatrix< T >::col ( int col ) const [inline]

template<class T>

col_iterator icl::math::DynMatrix< T >::col_begin ( unsigned int col ) [inline]

returns an iterator running through a certain matrix column

template<class T>

const_col_iterator icl::math::DynMatrix< T >::col_begin ( unsigned int col ) const [inline]

returns an iterator running through a certain matrix column (const)

template<class T>

void icl::math::DynMatrix< T >::col_check ( unsigned int col ) const [inline, private]

template<class T>

col_iterator icl::math::DynMatrix< T >::col_end ( unsigned int col ) [inline]

returns an iterator end of a certain matrix column

template<class T>

const_col_iterator icl::math::DynMatrix< T >::col_end ( unsigned int col ) const [inline]

returns an iterator end of a certain matrix column (const)

template<class T>

unsigned int icl::math::DynMatrix< T >::cols ( ) const [inline]

width of the matrix (number of columns)

template<class T>

T icl::math::DynMatrix< T >::cond ( const double p = 2 ) const [inline]

computes the condition of a matrix

template<class T>

static DynMatrix<T> icl::math::DynMatrix< T >::cross	(	const DynMatrix< T > &	x,
		const DynMatrix< T > &	y
	)		throw (InvalidMatrixDimensionException) `[inline, static]`

computes the cross product

template<class T>

T* icl::math::DynMatrix< T >::data ( ) [inline]

internal data pointer

template<class T>

const T* icl::math::DynMatrix< T >::data ( ) const [inline]

internal data pointer (const)

template<class T>

void icl::math::DynMatrix< T >::decompose_LU	(	DynMatrix< T > &	L,
		DynMatrix< T > &	U,
		T	zeroThreshold = `1E-16`
	)		const

applies LU-decomposition (without using partial pivoting) (only for icl32f and icl64f)

Even though, implementation also works for non-sqared matrices, it's not recommended to apply this function on non-sqared matrices

template<class T>

void icl::math::DynMatrix< T >::decompose_QR	(	DynMatrix< T > &	Q,
		DynMatrix< T > &	R
	)		const

applies QR-decomposition using stabilized Gram-Schmidt orthonormalization (only for icl32f and icl64f)

template<class T>

void icl::math::DynMatrix< T >::decompose_RQ	(	DynMatrix< T > &	R,
		DynMatrix< T > &	Q
	)		const

applies RQ-decomposition (by exploiting implemnetation of QR-decomposition) (only for icl32f, and icl64f)

template<class T>

T icl::math::DynMatrix< T >::det ( ) const throw (InvalidMatrixDimensionException)

matrix determinant (only for icl32f and icl64f)

template<class T>

DynMatrix<T> icl::math::DynMatrix< T >::diag ( ) const [inline]

returns diagonal-elements as column-vector

template<class T>

unsigned int icl::math::DynMatrix< T >::dim ( ) const [inline]

matrix dimension (width*height) or (cols*rows)

template<class T>

T icl::math::DynMatrix< T >::distanceTo ( const DynMatrix< T > & other ) const throw (InvalidMatrixDimensionException) [inline]

returns the distance of the inner data vectors (linearly interpreted) (IPP accelerated)

template<class T>

DynMatrix<T> icl::math::DynMatrix< T >::dot ( const DynMatrix< T > & M ) const throw (InvalidMatrixDimensionException) [inline]

returns the inner product of two matrices (i.e. dot-product)

A.dot(B) is equivalent to A.transp() * B TODO: optimize implementation (current implementation _is_ A.transp() * B)

template<class T>

void icl::math::DynMatrix< T >::eigen	(	DynMatrix< T > &	eigenvectors,
		DynMatrix< T > &	eigenvalues
	)		const throw (InvalidMatrixDimensionException, utils::ICLException)

Extracts the matrix's eigenvalues and eigenvectors.

This function only works on squared symmetric matrices. Resulting eigenvalues are ordered in descending order. The destination matrices' sizes are adapted automatically.

The function is only available for icl32f and icl64f and it is IPP-accelerated in case of having Intel-IPP-Support. The Fallback implementation was basically taken from the Visualization Toolkit VTK (Version 5.6.0)

Note: There is no internal check if the matrix is really symmetric. If it is not symmetric, the behaviour of this function is not predictable

Parameters:

eigenvectors	contains the resulting eigenvectors in it's columns
eigenvalues	becomes a N-dimensional column vector which ith element is the eigenvalue that corresponds to the ith column of eigenvectors

template<class T>

T icl::math::DynMatrix< T >::element_wise_inner_product ( const DynMatrix< T > & other ) const [inline]

inner product of data pointers (not matrix-mulitiplication)

computes the inner-product of data vectors

template<class T>

DynMatrix& icl::math::DynMatrix< T >::elementwise_div	(	const DynMatrix< T > &	m,
		DynMatrix< T > &	dst
	)		const throw (IncompatibleMatrixDimensionException) `[inline]`

Elementwise division (in source destination fashion) [IPP-Supported].

template<class T>

DynMatrix icl::math::DynMatrix< T >::elementwise_div ( const DynMatrix< T > & m ) const throw (IncompatibleMatrixDimensionException) [inline]

Elementwise matrix multiplication (without destination matrix) [IPP-Supported].

template<class T>

DynMatrix& icl::math::DynMatrix< T >::elementwise_mult	(	const DynMatrix< T > &	m,
		DynMatrix< T > &	dst
	)		const throw (IncompatibleMatrixDimensionException) `[inline]`

Elementwise matrix multiplication (in source destination fashion) [IPP-Supported].

template<class T>

DynMatrix icl::math::DynMatrix< T >::elementwise_mult ( const DynMatrix< T > & m ) const throw (IncompatibleMatrixDimensionException) [inline]

Elementwise matrix multiplication (without destination matrix) [IPP-Supported].

template<class T>

iterator icl::math::DynMatrix< T >::end ( ) [inline]

returns an iterator to the end of internal data array

template<class T>

const_iterator icl::math::DynMatrix< T >::end ( ) const [inline]

returns an iterator to the end of internal data array (const)

template<class T>

static DynMatrix icl::math::DynMatrix< T >::id ( unsigned int dim ) [inline, static]

creates a dim-D identity Matrix

template<class T>

void icl::math::DynMatrix< T >::idx_check	(	unsigned int	col,
		unsigned int	row
	)		const `[inline, private]`

template<class T>

void icl::math::DynMatrix< T >::idx_check ( unsigned int idx ) const [inline, private]

template<class T>

DynMatrix icl::math::DynMatrix< T >::inv ( ) const throw (InvalidMatrixDimensionException, SingularMatrixException)

invert the matrix (only for icl32f and icl64f)

template<class T>

bool icl::math::DynMatrix< T >::isNull ( ) const [inline]

returns with this matrix has a valid data pointer

template<class T>

bool icl::math::DynMatrix< T >::isSimilar	(	const DynMatrix< T > &	other,
		T	tollerance = `0.0001`
	)		const `[inline]`

tests weather a matrix is enough similar to another matrix

template<class T>

static DynMatrix<T> icl::math::DynMatrix< T >::loadCSV ( const std::string & filename ) throw (utils::ICLException) [static]

loads a dynmatrix from given CSV file

supported types T are all icl8u, icl16s, icl32s, icl32f, icl64f. Each row of the CSV file becomes a matrix row. The column delimiter is ',' Rows, that begin with '#' or with ' ' or that have no length are ignored

template<class T>

DynMatrix& icl::math::DynMatrix< T >::mult	(	T	f,
		DynMatrix< T > &	dst
	)		const `[inline]`

Multiply elements with scalar (in source destination fashion)

template<class T>

DynMatrix& icl::math::DynMatrix< T >::mult	(	const DynMatrix< T > &	m,
		DynMatrix< T > &	dst
	)		const throw (IncompatibleMatrixDimensionException) `[inline]`

Matrix multiplication (in source destination fashion) [IPP-Supported].

template<class T>

T icl::math::DynMatrix< T >::norm ( double l = 2 ) const [inline]

applies an L_l norm on the matrix elements (all elements are treated as vector)

template<class T>

bool icl::math::DynMatrix< T >::operator!= ( const DynMatrix< T > & other ) const [inline]

elementwise comparison (!=)

template<class T>

T& icl::math::DynMatrix< T >::operator()	(	unsigned int	col,
		unsigned int	row
	)		`[inline]`

element access operator (x,y)-access index begin 0!

template<class T>

const T& icl::math::DynMatrix< T >::operator()	(	unsigned int	col,
		unsigned int	row
	)		const `[inline]`

element access operator (x,y)-access index begin 0! (const)

template<class T>

DynMatrix icl::math::DynMatrix< T >::operator* ( T f ) const [inline]

Multiply elements with scalar.

template<class T>

DynMatrix icl::math::DynMatrix< T >::operator* ( const DynMatrix< T > & m ) const throw (IncompatibleMatrixDimensionException) [inline]

Essential matrix multiplication [IPP-Supported].

template<class T>

DynMatrix& icl::math::DynMatrix< T >::operator*= ( T f ) [inline]

Multiply elements with scalar (inplace)

template<class T>

DynMatrix& icl::math::DynMatrix< T >::operator*= ( const DynMatrix< T > & m ) throw (IncompatibleMatrixDimensionException) [inline]

inplace matrix multiplication applying this = this*m [IPP-Supported]

template<class T>

DynMatrix icl::math::DynMatrix< T >::operator+ ( const T & t ) const [inline]

adds a scalar to each element

template<class T>

DynMatrix icl::math::DynMatrix< T >::operator+ ( const DynMatrix< T > & m ) const throw (IncompatibleMatrixDimensionException) [inline]

Matrix addition.

template<class T>

DynMatrix& icl::math::DynMatrix< T >::operator+= ( const T & t ) [inline]

adds a scalar to each element (inplace)

template<class T>

DynMatrix& icl::math::DynMatrix< T >::operator+= ( const DynMatrix< T > & m ) throw (IncompatibleMatrixDimensionException) [inline]

Matrix addition (inplace)

template<class T>

DynMatrix icl::math::DynMatrix< T >::operator- ( const T & t ) const [inline]

substacts a scalar from each element

template<class T>

DynMatrix icl::math::DynMatrix< T >::operator- ( const DynMatrix< T > & m ) const throw (IncompatibleMatrixDimensionException) [inline]

Matrix substraction.

template<class T>

DynMatrix& icl::math::DynMatrix< T >::operator-= ( const T & t ) [inline]

substacts a scalar from each element (inplace)

template<class T>

DynMatrix& icl::math::DynMatrix< T >::operator-= ( const DynMatrix< T > & m ) throw (IncompatibleMatrixDimensionException) [inline]

Matrix substraction (inplace)

template<class T>

DynMatrix icl::math::DynMatrix< T >::operator/ ( T f ) const [inline]

Device elements by scalar.

template<class T>

DynMatrix icl::math::DynMatrix< T >::operator/ ( const DynMatrix< T > & m ) const throw (IncompatibleMatrixDimensionException, InvalidMatrixDimensionException, SingularMatrixException) [inline]

inplace matrix devision (calling this/m.inv()) [IPP-Supported]

template<class T>

DynMatrix& icl::math::DynMatrix< T >::operator/= ( T f ) [inline]

Device elements by scalar (inplace)

template<class T>

DynMatrix& icl::math::DynMatrix< T >::operator/= ( const DynMatrix< T > & m ) const throw (IncompatibleMatrixDimensionException, InvalidMatrixDimensionException, SingularMatrixException) [inline]

inplace matrix devision (calling this/m.inv()) (inplace)

template<class T>

DynMatrix& icl::math::DynMatrix< T >::operator= ( const DynMatrix< T > & other ) [inline]

Assignment operator (using deep/shallow-copy)

In general, the assignment operator applys a deep copy only in case of (*this) is not initialized and other is a shallow copy, (*this) will also become a shallow copy of the data referenced by other

Reimplemented in icl::math::DynRowVector< T >, and icl::math::DynColVector< T >.

template<class T>

DynMatrix& icl::math::DynMatrix< T >::operator= ( const DynMatrixColumn & col ) [inline]

template<class T>

bool icl::math::DynMatrix< T >::operator== ( const DynMatrix< T > & other ) const [inline]

elementwise comparison (==)

template<class T>

T& icl::math::DynMatrix< T >::operator[] ( unsigned int idx ) [inline]

linear access to actual data array

template<class T>

const T& icl::math::DynMatrix< T >::operator[] ( unsigned int idx ) const [inline]

linear access to actual data array (const)

template<class T>

DynMatrix icl::math::DynMatrix< T >::pinv	(	bool	useSVD = `false`,
		T	zeroThreshold = `1E-16`
	)		const throw (InvalidMatrixDimensionException,SingularMatrixException,utils::ICLException)

calculates the Moore-Penrose pseudo-inverse (only implemented for icl32f and icl64f)

Internally, this functions can use either a QR-decomposition based approach, or it can use SVD. QR-Decomposition is already much more stable than the naiv approach pinv(X) = X*(X*X')^(-1)

          DynMatrix Q,R;
          decompose_QR(Q,R);
          return R.inv() * Q.transp();

The QR-decomposition based approach does not use the zeroThreshold variable.

If useSVD is set to true, internally an SVD based approach is used:

DynMatrix S,v,D; svd_dyn(*this,U,s,V);

DynMatrix S(s.rows(),s.rows(),0.0f); for(unsigned int i=0;i<s.rows();++i){ S(i,i) = (fabs(s[i]) > zeroThreshold) ? 1.0/s[i] : 0; } return V * S * U.transp();

template<class T>

void icl::math::DynMatrix< T >::reshape	(	int	newCols,
		int	newRows
	)		throw (InvalidMatrixDimensionException) `[inline]`

resets the matrix dimensions without changing the content

This methods can only be used in case of cols()*rows() equals to newCols*newRows. If this dependency is fulfilled, only the matrix's m_cols and m_rows member variables are adapted according to the new values. The internal data is not touched at all, so the matrix's internal row-major data order is not affected.

This method can particularly be used to cheaply convert a row-vector matrix into a column vector matrix.

template<class T>

DynMatrix icl::math::DynMatrix< T >::row ( int row ) [inline]

Extracts a shallow copied matrix row.

template<class T>

const DynMatrix icl::math::DynMatrix< T >::row ( int row ) const [inline]

Extracts a shallow copied matrix row (const)

template<class T>

row_iterator icl::math::DynMatrix< T >::row_begin ( unsigned int row ) [inline]

returns an iterator running through a certain matrix row

template<class T>

const_row_iterator icl::math::DynMatrix< T >::row_begin ( unsigned int row ) const [inline]

returns an iterator running through a certain matrix row (const)

template<class T>

void icl::math::DynMatrix< T >::row_check ( unsigned int row ) const [inline, private]

template<class T>

row_iterator icl::math::DynMatrix< T >::row_end ( unsigned int row ) [inline]

returns an iterator of a certains row's end

template<class T>

const_row_iterator icl::math::DynMatrix< T >::row_end ( unsigned int row ) const [inline]

returns an iterator of a certains row's end (const)

template<class T>

unsigned int icl::math::DynMatrix< T >::rows ( ) const [inline]

height of the matrix (number of rows)

template<class T>

void icl::math::DynMatrix< T >::saveCSV ( const std::string & filename ) throw (utils::ICLException)

writes the current matrix to a csv file

supported types T are all icl8u, icl16s, icl32s, icl32f, icl64f

template<class T>

T* icl::math::DynMatrix< T >::set_data ( T * newData ) [inline]

sets new data internally and returns old data pointer (for experts only!)

template<class T>

void icl::math::DynMatrix< T >::setBounds	(	unsigned int	cols,
		unsigned int	rows,
		bool	holdContent = `false`,
		const T &	initializer = `0`
	)		throw (InvalidMatrixDimensionException) `[inline]`

resets matrix dimensions

template<class T>

const DynMatrix<T> icl::math::DynMatrix< T >::shallowTransposed ( ) const [inline]

returns a shallow transposed copy of this matrix (dimensions are swapped, data is not re-aranged) (const)

This is usually only useful for transposing row- to colume vectors and vice versa.

template<class T>

const DynMatrix<T> icl::math::DynMatrix< T >::shallowTransposed ( ) [inline]

returns a shallow transposed copy of this matrix (dimensions are swapped, data is not re-aranged)

template<class T>

DynMatrix icl::math::DynMatrix< T >::solve	(	const DynMatrix< T > &	b,
		const std::string &	method = `"lu"`,
		T	zeroThreshold = `1E-16`
	)		throw (InvalidMatrixDimensionException, utils::ICLException, SingularMatrixException)

solves Mx=b for M=*this (only for icl32f and icl64f)

solves Mx=b using one of the following algorithms

Parameters:

b
method	"lu" (default) using LU-decomposition "svd" (using svd-based pseudo-inverse) "qr" (using QR-decomposition based pseudo-inverse) "inv" (using matrix inverse)

Benchmarks

While LU decomposition based solving provides the worst results, it is also the fastest method in general. Only in case of having very small matrices (e.g. 4x4), other methods are faster. A double precision random N by N system is solved up to an accuracy of about 10e-5 if LU decomposition is used. All other methods provide accuracies of about 10e-14 in case of double precision.

Here are some benchmarks for double precision: 10.000 times 4x4 matrix: inv 16.2 ms lu 26.7 ms qr 105 ms svd 142 ms 10.000 times 5x5 matrix: inv 20.2 ms lu 30.2 ms qr 148 ms svd 131 ms 10.000 times 6x6 matrix: inv 26.9 ms lu 35.6 ms qr 206 ms svd 192 ms 10.000 times 4x4 matrix: inv 448 ms lu 42 ms qr 642 ms svd 237 ms 10.000 times 10x10 matrix: inv 2200 ms lu 75 ms qr 3000 ms svd 495 ms 10 times 50x50 matrix: note: here we have inv and qr in seconds and only 10 trials! inv 5.7 s lu 2.5 ms qr 4.6 s svd 23.4 ms

Parameters:

zeroThreshold

template<class T>

DynMatrix icl::math::DynMatrix< T >::solve_lower_triangular ( const DynMatrix< T > & b ) const throw (InvalidMatrixDimensionException)

solves Mx=b for M=*this (only if M is a squared lower triangular matrix) (only for icl32f and icl64f)

template<class T>

DynMatrix icl::math::DynMatrix< T >::solve_upper_triangular ( const DynMatrix< T > & b ) const throw (InvalidMatrixDimensionException)

solves Mx=b for M=*this (only if M is a squared upper triangular matrix) (only for icl32f and icl64f)

template<class T>

T icl::math::DynMatrix< T >::sqrDistanceTo ( const DynMatrix< T > & other ) const throw (InvalidMatrixDimensionException) [inline]

returns the squared distance of the inner data vectors (linearly interpreted) (IPP accelerated)

template<class T>

int icl::math::DynMatrix< T >::stride0 ( ) const [inline]

returns sizeof (T)*dim()

template<class T>

int icl::math::DynMatrix< T >::stride1 ( ) const [inline]

returns sizeof(T)*cols()

template<class T>

int icl::math::DynMatrix< T >::stride2 ( ) const [inline]

returns sizeof (T)

template<class T>

void icl::math::DynMatrix< T >::svd	(	DynMatrix< T > &	U,
		DynMatrix< T > &	S,
		DynMatrix< T > &	V
	)		const throw (utils::ICLException)

Computes Singular Value Decomposition of a matrix - decomposes A into USV'.

Internaly, this function will always use double values. Other types are converted internally. This funciton is only instantiated for icl32f and icl64f.

Parameters:

U	is filled column-wise with the eigenvectors of AA'
S	is filled with the singular values of A (s is a ColumnVector and not diagonal matrix)
V	is filled column-wise with the eigenvectors of A'A (in V, V is stored not V')