Matrix< T, ALLOC > Class Template Reference

#include <vigra/matrix.hxx>

Inheritance diagram for Matrix< T, ALLOC >:

Public Member Functions
difference_type_1	columnCount () const
view_type	columnVector (difference_type_1 d) const
difference_type_1	elementCount () const
template<class U >
Matrix &	init (const U &init)
bool	isSymmetric () const
	Matrix ()
	Matrix (ALLOC const &alloc)
	Matrix (const difference_type &aShape, ALLOC const &alloc=allocator_type())
	Matrix (difference_type_1 rows, difference_type_1 columns, ALLOC const &alloc=allocator_type())
	Matrix (const difference_type &aShape, const_reference init, allocator_type const &alloc=allocator_type())
	Matrix (difference_type_1 rows, difference_type_1 columns, const_reference init, allocator_type const &alloc=allocator_type())
	Matrix (const difference_type &shape, const_pointer init, RawArrayMemoryLayout layout=RowMajor, allocator_type const &alloc=allocator_type())
	Matrix (difference_type_1 rows, difference_type_1 columns, const_pointer init, RawArrayMemoryLayout layout=RowMajor, allocator_type const &alloc=allocator_type())
	Matrix (const Matrix &rhs)
	Matrix (const TemporaryMatrix< T, ALLOC > &rhs)
template<class U , class C >
	Matrix (const MultiArrayView< 2, U, C > &rhs)
TemporaryMatrix< T >	mean () const
TemporaryMatrix< T >	mean (difference_type_1 d) const
NormTraits< Matrix >::NormType	norm () const
value_type &	operator() (difference_type_1 row, difference_type_1 column)
value_type	operator() (difference_type_1 row, difference_type_1 column) const
template<class U , class C >
Matrix &	operator*= (MultiArrayView< 2, U, C > const &other)
Matrix &	operator*= (T other)
template<class U , class C >
Matrix &	operator+= (MultiArrayView< 2, U, C > const &other)
Matrix &	operator+= (T other)
template<class U , class C >
Matrix &	operator-= (MultiArrayView< 2, U, C > const &other)
Matrix &	operator-= (T other)
template<class U , class C >
Matrix &	operator/= (MultiArrayView< 2, U, C > const &other)
Matrix &	operator/= (T other)
Matrix &	operator= (const Matrix &rhs)
Matrix &	operator= (const TemporaryMatrix< T, ALLOC > &rhs)
template<class U , class C >
Matrix &	operator= (const MultiArrayView< 2, U, C > &rhs)
Matrix &	operator= (value_type const &v)
void	reshape (difference_type_1 rows, difference_type_1 columns)
void	reshape (difference_type_1 rows, difference_type_1 columns, const_reference init)
void	reshape (difference_type const &newShape)
void	reshape (difference_type const &newShape, const_reference init)
difference_type_1	rowCount () const
view_type	rowVector (difference_type_1 d) const
NormTraits< Matrix > ::SquaredNormType	squaredNorm () const
TemporaryMatrix< T >	sum () const
TemporaryMatrix< T >	sum (difference_type_1 d) const
MultiArrayView< 2, vluae_type, StridedArrayTag >	transpose () const
Public Member Functions inherited from MultiArray< 2, T, ALLOC >
allocator_type const &	allocator () const
MultiArray &	init (const U &init)
	MultiArray ()
	MultiArray (allocator_type const &alloc)
	MultiArray (difference_type_1 length, allocator_type const &alloc=allocator_type())
	MultiArray (difference_type_1 width, difference_type_1 height, allocator_type const &alloc=allocator_type())
	MultiArray (const difference_type &shape, allocator_type const &alloc=allocator_type())
	MultiArray (const difference_type &shape, const_reference init, allocator_type const &alloc=allocator_type())
	MultiArray (const difference_type &shape, MultiArrayInitializationTag init, allocator_type const &alloc=allocator_type())
	MultiArray (const difference_type &shape, const_pointer init, allocator_type const &alloc=allocator_type())
	MultiArray (const MultiArray &rhs)
	MultiArray (multi_math::MultiMathOperand< Expression > const &rhs, allocator_type const &alloc=allocator_type())
	MultiArray (const MultiArrayView< N, U, StrideTag > &rhs, allocator_type const &alloc=allocator_type())
MultiArray &	operator*= (const MultiArrayView< N, U, StrideTag > &rhs)
MultiArray &	operator*= (const T &rhs)
MultiArray &	operator*= (multi_math::MultiMathOperand< Expression > const &rhs)
MultiArray &	operator+= (const MultiArrayView< N, U, StrideTag > &rhs)
MultiArray &	operator+= (const T &rhs)
MultiArray &	operator+= (multi_math::MultiMathOperand< Expression > const &rhs)
MultiArray &	operator-= (const MultiArrayView< N, U, StrideTag > &rhs)
MultiArray &	operator-= (const T &rhs)
MultiArray &	operator-= (multi_math::MultiMathOperand< Expression > const &rhs)
MultiArray &	operator/= (const MultiArrayView< N, U, StrideTag > &rhs)
MultiArray &	operator/= (const T &rhs)
MultiArray &	operator/= (multi_math::MultiMathOperand< Expression > const &rhs)
MultiArray &	operator= (const MultiArray &rhs)
MultiArray &	operator= (const MultiArrayView< N, U, StrideTag > &rhs)
MultiArray &	operator= (value_type const &v)
MultiArray &	operator= (multi_math::MultiMathOperand< Expression > const &rhs)
void	reshape (const difference_type &shape)
void	reshape (const difference_type &shape, const_reference init)
void	swap (MultiArray &other)
	~MultiArray ()

Additional Inherited Members
Public Types inherited from MultiArray< 2, T, ALLOC >
typedef ALLOC	allocator_type
typedef view_type::const_iterator	const_iterator
typedef view_type::const_pointer	const_pointer
typedef view_type::const_reference	const_reference
typedef view_type::const_traverser	const_traverser
typedef view_type::difference_type	difference_type
typedef view_type::difference_type_1	difference_type_1
typedef view_type::iterator	iterator
typedef MultiArray< N, T, ALLOC >	matrix_type
typedef view_type::pointer	pointer
typedef view_type::reference	reference
typedef view_type::size_type	size_type
typedef view_type::traverser	traverser
typedef view_type::value_type	value_type
typedef MultiArrayView< N, typename vigra::detail::ResolveMultiband < T >::type, typename vigra::detail::ResolveMultiband < T >::Stride >	view_type
Protected Member Functions inherited from MultiArray< 2, T, ALLOC >
void	allocate (pointer &ptr, difference_type_1 s, const_reference init)
void	allocate (pointer &ptr, difference_type_1 s, U const *init)
void	allocate (pointer &ptr, MultiArrayView< N, U, StrideTag > const &init)
void	deallocate (pointer &ptr, difference_type_1 s)
Protected Attributes inherited from MultiArray< 2, T, ALLOC >
allocator_type	m_alloc

Detailed Description

template<class T, class ALLOC = std::allocator<T>>
class vigra::linalg::Matrix< T, ALLOC >

Matrix class.

This is the basic class for all linear algebra computations. Matrices are stored in a column-major format, i.e. the row index is varying fastest. This is the same format as in the lapack and gmm++ libraries, so it will be easy to interface these libraries. In fact, if you need optimized high performance code, you should use them. The VIGRA linear algebra functionality is provided for smaller problems and rapid prototyping (no one wants to spend half the day installing a new library just to discover that the new algorithm idea didn't work anyway).

See also:

• Matrix Functions

#include <vigra/matrix.hxx> or
#include <vigra/linear_algebra.hxx>
Namespaces: vigra and vigra::linalg

Examples:

nnlsq.cxx.

Constructor & Destructor Documentation

Matrix

(

)

default constructor

Matrix ( ALLOC const &  alloc )

explicit

construct with given allocator

Matrix ( const difference_type &  aShape, ALLOC const &  alloc = allocator_type()  )

explicit

construct with given shape and init all elements with zero. Note that the order of the axes is difference_type(rows, columns) which is the opposite of the usual VIGRA convention.

Matrix	(	difference_type_1	rows,
		difference_type_1	columns,
		ALLOC const &	alloc = allocator_type()
	)

construct with given shape and init all elements with zero. Note that the order of the axes is (rows, columns) which is the opposite of the usual VIGRA convention.

Matrix	(	const difference_type &	aShape,
		const_reference	init,
		allocator_type const &	alloc = allocator_type()
	)

construct with given shape and init all elements with the constant init. Note that the order of the axes is difference_type(rows, columns) which is the opposite of the usual VIGRA convention.

Matrix	(	difference_type_1	rows,
		difference_type_1	columns,
		const_reference	init,
		allocator_type const &	alloc = allocator_type()
	)

construct with given shape and init all elements with the constant init. Note that the order of the axes is (rows, columns) which is the opposite of the usual VIGRA convention.

Matrix	(	const difference_type &	shape,
		const_pointer	init,
		RawArrayMemoryLayout	layout = RowMajor,
		allocator_type const &	alloc = allocator_type()
	)

construct with given shape and copy data from C-style array init. Unless layout is ColumnMajor, the elements in this array are assumed to be given in row-major order (the C standard order) and will automatically be converted to the required column-major format. Note that the order of the axes is difference_type(rows, columns) which is the opposite of the usual VIGRA convention.

Matrix	(	difference_type_1	rows,
		difference_type_1	columns,
		const_pointer	init,
		RawArrayMemoryLayout	layout = RowMajor,
		allocator_type const &	alloc = allocator_type()
	)

construct with given shape and copy data from C-style array init. Unless layout is ColumnMajor, the elements in this array are assumed to be given in row-major order (the C standard order) and will automatically be converted to the required column-major format. Note that the order of the axes is (rows, columns) which is the opposite of the usual VIGRA convention.

Matrix

(

const Matrix< T, ALLOC > &

rhs

)

copy constructor. Allocates new memory and copies tha data.

Matrix

(

const TemporaryMatrix< T, ALLOC > &

rhs

)

construct from temporary matrix, which looses its data.

This operation is equivalent to

TemporaryMatrix<T> temp = ...;

Matrix<T> m;
m.swap(temp);

Matrix

(

const MultiArrayView< 2, U, C > &

rhs

)

construct from a MultiArrayView. Allocates new memory and copies tha data. rhs is assumed to be in column-major order already.

Member Function Documentation

Matrix& operator=

(

const Matrix< T, ALLOC > &

rhs

)

assignment. If the size of rhs is the same as the matrix's old size, only the data are copied. Otherwise, new storage is allocated, which invalidates all objects (array views, iterators) depending on the matrix.

Matrix& operator=

(

const TemporaryMatrix< T, ALLOC > &

rhs

)

assign a temporary matrix. If the shapes of the two matrices match, only the data are copied (in order to not invalidate views and iterators depending on this matrix). Otherwise, the memory is swapped between the two matrices, so that all depending objects (array views, iterators) ar invalidated.

Matrix& operator=

(

const MultiArrayView< 2, U, C > &

rhs

)

assignment from arbitrary 2-dimensional MultiArrayView.
If the size of rhs is the same as the matrix's old size, only the data are copied. Otherwise, new storage is allocated, which invalidates all objects (array views, iterators) depending on the matrix. rhs is assumed to be in column-major order already.

Matrix& operator=

(

value_type const &

v

)

assignment from scalar.
Equivalent to Matrix::init(v).

Matrix& init

(

const U &

init

)

init elements with a constant

void reshape	(	difference_type_1	rows,
		difference_type_1	columns
	)

reshape to the given shape and initialize with zero.

void reshape	(	difference_type_1	rows,
		difference_type_1	columns,
		const_reference	init
	)

reshape to the given shape and initialize with init.

void reshape

(

difference_type const &

newShape

)

reshape to the given shape and initialize with zero.

void reshape	(	difference_type const &	newShape,
		const_reference	init
	)

reshape to the given shape and initialize with init.

view_type rowVector

(

difference_type_1

d

)

const

Create a matrix view that represents the row vector of row d.

view_type columnVector

(

difference_type_1

d

)

const

Create a matrix view that represents the column vector of column d.

difference_type_1 rowCount

(

)

const

number of rows (height) of the matrix.

difference_type_1 columnCount

(

)

const

number of columns (width) of the matrix.

difference_type_1 elementCount

(

)

const

number of elements (width*height) of the matrix.

bool isSymmetric

(

)

const

check whether the matrix is symmetric.

TemporaryMatrix<T> sum

(

)

const

sums over the matrix.

TemporaryMatrix<T> sum

(

difference_type_1

d

)

const

sums over dimension d of the matrix.

TemporaryMatrix<T> mean

(

)

const

sums over the matrix.

TemporaryMatrix<T> mean

(

difference_type_1

d

)

const

calculates mean over dimension d of the matrix.

value_type& operator()	(	difference_type_1	row,
		difference_type_1	column
	)

read/write access to matrix element (row, column). Note that the order of the argument is the opposite of the usual VIGRA convention due to column-major matrix order.

value_type operator()	(	difference_type_1	row,
		difference_type_1	column
	)		const

read access to matrix element (row, column). Note that the order of the argument is the opposite of the usual VIGRA convention due to column-major matrix order.

NormTraits<Matrix>::SquaredNormType squaredNorm

(

)

const

squared Frobenius norm. Sum of squares of the matrix elements.

NormTraits<Matrix>::NormType norm

(

)

const

Frobenius norm. Root of sum of squares of the matrix elements.

MultiArrayView<2, vluae_type, StridedArrayTag> transpose

(

)

const

create a transposed view of this matrix. No data are copied. If you want to transpose this matrix permanently, you have to assign the transposed view:

a = a.transpose();

Matrix& operator+=

(

MultiArrayView< 2, U, C > const &

other

)

add other to this (sizes must match).

Matrix& operator-=

(

MultiArrayView< 2, U, C > const &

other

)

subtract other from this (sizes must match).

Matrix& operator*=

(

MultiArrayView< 2, U, C > const &

other

)

multiply other element-wise with this matrix (sizes must match).

Matrix& operator/=

(

MultiArrayView< 2, U, C > const &

other

)

divide this matrix element-wise by other (sizes must match).

Matrix& operator+=

(

T

other

)

add other to each element of this matrix

Matrix& operator-=

(

T

other

)

subtract other from each element of this matrix

Matrix& operator*=

(

T

other

)

scalar multiply this with other

Matrix& operator/=

(

T

other

)

scalar divide this by other

---

The documentation for this class was generated from the following file:

• vigra/matrix.hxx