MultiArray< N, T, A > Class Template Reference

Multi-dimensional Shapes and Array Iterators

Main MultiArray class containing the memory management. More...

#include <vigra/multi_array.hxx>

Inheritance diagram for MultiArray< N, T, A >:

Public Types
typedef A	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, A >	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

Public Member Functions
allocator_type const &	allocator () const

template<class U >
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)

template<class Expression >
	MultiArray (multi_math::MultiMathOperand< Expression > const &rhs, allocator_type const &alloc=allocator_type())

template<class U , class StrideTag >
	MultiArray (const MultiArrayView< N, U, StrideTag > &rhs, allocator_type const &alloc=allocator_type())

template<class U , class StrideTag >
MultiArray &	operator*= (const MultiArrayView< N, U, StrideTag > &rhs)

MultiArray &	operator*= (const T &rhs)

template<class Expression >
MultiArray &	operator*= (multi_math::MultiMathOperand< Expression > const &rhs)

template<class U , class StrideTag >
MultiArray &	operator+= (const MultiArrayView< N, U, StrideTag > &rhs)

MultiArray &	operator+= (const T &rhs)

template<class Expression >
MultiArray &	operator+= (multi_math::MultiMathOperand< Expression > const &rhs)

template<class U , class StrideTag >
MultiArray &	operator-= (const MultiArrayView< N, U, StrideTag > &rhs)

MultiArray &	operator-= (const T &rhs)

template<class Expression >
MultiArray &	operator-= (multi_math::MultiMathOperand< Expression > const &rhs)

template<class U , class StrideTag >
MultiArray &	operator/= (const MultiArrayView< N, U, StrideTag > &rhs)

MultiArray &	operator/= (const T &rhs)

template<class Expression >
MultiArray &	operator/= (multi_math::MultiMathOperand< Expression > const &rhs)

MultiArray &	operator= (const MultiArray &rhs)

template<class U , class StrideTag >
MultiArray &	operator= (const MultiArrayView< N, U, StrideTag > &rhs)

MultiArray &	operator= (value_type const &v)

template<class Expression >
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 ()

Protected Member Functions
void	allocate (pointer &ptr, difference_type_1 s, const_reference init)

template<class U >
void	allocate (pointer &ptr, difference_type_1 s, U const *init)

template<class U , class StrideTag >
void	allocate (pointer &ptr, MultiArrayView< N, U, StrideTag > const &init)

void	deallocate (pointer &ptr, difference_type_1 s)

Protected Attributes
allocator_type	m_alloc

Detailed Description

template<unsigned int N, class T, class A>
class vigra::MultiArray< N, T, A >

Main MultiArray class containing the memory management.

This class inherits the interface of MultiArrayView, and implements the memory ownership. MultiArray's are always unstrided, striding them creates a MultiArrayView.

The template parameters are as follows

N: the array dimension
T: the type of the array elements
A: the allocator used for internal storage management
   (default: std::allocator<T>)

#include <vigra/multi_array.hxx>
Namespace: vigra

Examples:: boundarytensor.cxx, composite.cxx, convert.cxx, dissolve.cxx, edge.cxx, graph_agglomerative_clustering.cxx, imageExportInfo_tutorial.cxx, imageIO_tutorial.cxx, invert.cxx, invert_tutorial.cxx, mirror_tutorial.cxx, palette.cxx, resize.cxx, smooth.cxx, smooth_convolve.cxx, smooth_explicitly.cxx, subimage.cxx, subimage_tutorial.cxx, total_variation.cxx, transpose.cxx, transpose_image_tutorial.cxx, voronoi.cxx, and watershed.cxx.

Member Typedef Documentation

typedef MultiArrayView<N, typename vigra::detail::ResolveMultiband<T>::type, typename vigra::detail::ResolveMultiband<T>::Stride> view_type

the view type associated with this array.

typedef A allocator_type

the allocator type used to allocate the memory

typedef MultiArray<N, T, A> matrix_type

the matrix type associated with this array.

typedef view_type::value_type value_type

the array's value type

typedef view_type::pointer pointer

pointer type

typedef view_type::const_pointer const_pointer

const pointer type

typedef view_type::reference reference

reference type (result of operator[])

typedef view_type::const_reference const_reference

const reference type (result of operator[] const)

typedef view_type::size_type size_type

size type

typedef view_type::difference_type difference_type

difference type (used for multi-dimensional offsets and indices)

typedef view_type::difference_type_1 difference_type_1

difference and index type for a single dimension

typedef view_type::traverser traverser

traverser type

typedef view_type::const_traverser const_traverser

traverser type to const data

typedef view_type::iterator iterator

sequential (random access) iterator typesequential (random access) const iterator typesequential (random access) iterator type

typedef view_type::const_iterator const_iterator

sequential (random access) const iterator type

Constructor & Destructor Documentation

MultiArray ( )

default constructor

MultiArray ( allocator_type const & alloc )

construct with given allocator

MultiArray	(	difference_type_1	length,
		allocator_type const &	alloc = `allocator_type()`
	)

explicit

construct with given length

Use only for 1-dimensional arrays (N==1).

MultiArray	(	difference_type_1	width,
		difference_type_1	height,
		allocator_type const &	alloc = `allocator_type()`
	)

construct with given width and height

Use only for 2-dimensional arrays (N==2).

MultiArray	(	const difference_type &	shape,
		allocator_type const &	alloc = `allocator_type()`
	)

explicit

construct with given shape

MultiArray	(	const difference_type &	shape,
		const_reference	init,
		allocator_type const &	alloc = `allocator_type()`
	)

construct from shape with an initial value

MultiArray	(	const difference_type &	shape,
		MultiArrayInitializationTag	init,
		allocator_type const &	alloc = `allocator_type()`
	)

construct from shape and initialize with a linear sequence in scan order (i.e. first pixel gets value 0, second on gets value 1 and so on).

MultiArray	(	const difference_type &	shape,
		const_pointer	init,
		allocator_type const &	alloc = `allocator_type()`
	)

construct from shape and copy values from the given array

MultiArray ( const MultiArray< N, T, A > & rhs )

copy constructor

MultiArray	(	multi_math::MultiMathOperand< Expression > const &	rhs,
		allocator_type const &	alloc = `allocator_type()`
	)

constructor from an array expression

MultiArray	(	const MultiArrayView< N, U, StrideTag > &	rhs,
		allocator_type const &	alloc = `allocator_type()`
	)

construct by copying from a MultiArrayView

~MultiArray ( )

destructor

Member Function Documentation

void allocate	(	pointer &	ptr,
		difference_type_1	s,
		const_reference	init
	)

protected

allocate memory for s pixels, write its address into the given pointer and initialize the pixels with init.

void allocate	(	pointer &	ptr,
		difference_type_1	s,
		U const *	init
	)

protected

allocate memory for s pixels, write its address into the given pointer and initialize the linearized pixels to the values of init.

void allocate	(	pointer &	ptr,
		MultiArrayView< N, U, StrideTag > const &	init
	)

protected

allocate memory, write its address into the given pointer and initialize it by copying the data from the given MultiArrayView.

void deallocate	(	pointer &	ptr,
		difference_type_1	s
	)

protected

deallocate the memory (of length s) starting at the given address.

MultiArray& operator= ( const MultiArray< N, T, A > & rhs )

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

MultiArray& operator= ( const MultiArrayView< N, U, StrideTag > & rhs )

assignment from arbitrary MultiArrayView.
If the size of rhs is the same as the left-hand side arrays's old size, only the data are copied. Otherwise, new storage is allocated, which invalidates all objects (array views, iterators) depending on the lhs array.

MultiArray& operator= ( value_type const & v )

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

MultiArray& operator+= ( const MultiArrayView< N, U, StrideTag > & rhs )

Add-assignment from arbitrary MultiArrayView. Fails with PreconditionViolation exception when the shapes do not match. If the left array has no data (hasData() is false), this function is equivalent to a normal assignment (i.e. an empty array is interpreted as a zero-array of appropriate size).

MultiArray& operator-= ( const MultiArrayView< N, U, StrideTag > & rhs )

Subtract-assignment from arbitrary MultiArrayView. Fails with PreconditionViolation exception when the shapes do not match. If the left array has no data (hasData() is false), this function is equivalent to an assignment of the negated rhs (i.e. an empty array is interpreted as a zero-array of appropriate size).

MultiArray& operator*= ( const MultiArrayView< N, U, StrideTag > & rhs )

Multiply-assignment from arbitrary MultiArrayView. Fails with PreconditionViolation exception when the shapes do not match. If the left array has no data (hasData() is false), this function is equivalent to reshape(rhs.shape()) with zero initialisation (i.e. an empty array is interpreted as a zero-array of appropriate size).

MultiArray& operator/= ( const MultiArrayView< N, U, StrideTag > & rhs )

Divide-assignment from arbitrary MultiArrayView. Fails with PreconditionViolation exception when the shapes do not match. If the left array has no data (hasData() is false), this function is equivalent to reshape(rhs.shape()) with zero initialisation (i.e. an empty array is interpreted as a zero-array of appropriate size).

MultiArray& operator+= ( const T & rhs )

Add-assignment of a scalar.

MultiArray& operator-= ( const T & rhs )

Subtract-assignment of a scalar.

MultiArray& operator*= ( const T & rhs )

Multiply-assignment of a scalar.

MultiArray& operator/= ( const T & rhs )

Divide-assignment of a scalar.

MultiArray& operator= ( multi_math::MultiMathOperand< Expression > const & rhs )

Assignment of an array expression. Fails with PreconditionViolation exception when the shapes do not match.

MultiArray& operator+= ( multi_math::MultiMathOperand< Expression > const & rhs )

Add-assignment of an array expression. Fails with PreconditionViolation exception when the shapes do not match.

MultiArray& operator-= ( multi_math::MultiMathOperand< Expression > const & rhs )

Subtract-assignment of an array expression. Fails with PreconditionViolation exception when the shapes do not match.

MultiArray& operator*= ( multi_math::MultiMathOperand< Expression > const & rhs )

Multiply-assignment of an array expression. Fails with PreconditionViolation exception when the shapes do not match.

MultiArray& operator/= ( multi_math::MultiMathOperand< Expression > const & rhs )

Divide-assignment of an array expression. Fails with PreconditionViolation exception when the shapes do not match.

MultiArray& init ( const U & init )

init elements with a constant

void reshape ( const difference_type & shape )

Allocate new memory with the given shape and initialize with zeros.
Note: this operation invalidates all dependent objects (array views and iterators)

void reshape	(	const difference_type &	shape,
		const_reference	init
	)

Allocate new memory with the given shape and initialize it with the given value.
Note: this operation invalidates all dependent objects (array views and iterators)

void swap ( MultiArray< N, T, A > & other )

Swap the contents with another MultiArray. This is fast, because no data are copied, but only pointers and shapes swapped. Note: this operation invalidates all dependent objects (array views and iterators)

allocator_type const& allocator ( ) const

sequential iterator pointing to the first array element.sequential iterator pointing beyond the last array element.sequential const iterator pointing to the first array element.sequential const iterator pointing beyond the last array element.get the allocator.

Member Data Documentation

allocator_type m_alloc

protected

the allocator used to allocate the memory

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

vigra/multi_array.hxx

Public Types

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

template<unsigned int N, class T, class A> class vigra::MultiArray< N, T, A >

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

template<unsigned int N, class T, class A>
class vigra::MultiArray< N, T, A >