Concurrency::extent< _Rank > Class Template Reference

The extent<N> type represents an N-dimensional vector of int which specifies the bounds of an N-dimensional space with an origin of 0. The values in the coordinate vector are ordered from most-significant to least-significant. Thus, in 2-dimensional space, the extent vector (5,3) represents a space with 5 rows and 3 columns. More...

#include <amp.h>

Public Types
typedef int	value_type

Public Member Functions
	_CPP_AMP_VERIFY_RANK (_Rank, extent)
	extent () __GPU
	Default constructor. The value at each dimension is initialized to zero. More...
	extent (const extent< _Rank > &_Other) __GPU
	Copy constructor. Constructs a new extent from the supplied argument _Other. More...
	extent (int _I) __GPU
	Constructor for extent<1>. More...
	extent (int _I0, int _I1) __GPU
	Constructor for extent<2> More...
	extent (int _I0, int _I1, int _I2) __GPU
	Constructor for extent<3> More...
	extent (const int _Array[_Rank]) __GPU
	Constructs an extent with the coordinate values provided the array of int component values. If the coordinate array length is not N, the behavior is undefined. More...
extent< _Rank > &	operator= (const extent< _Rank > &_Other) __GPU
	copy-assignment operator More...
int	operator[] (unsigned int _Index) const __GPU
	Index operator. More...
int &	operator[] (unsigned int _Index) __GPU
	Index operators. More...
unsigned int	size () const __GPU
	Returns the total linear size of this extent (in units of elements). More...
bool	contains (const index< rank > &_Index) const __GPU
	Tests whether the index "_Index" is properly contained within this extent. More...
template<int _Dim0>
tiled_extent< _Dim0 >	tile () const __GPU
	Produces a tiled_extent object with the tile extents given by _Dim0. More...
template<int _Dim0, int _Dim1>
tiled_extent< _Dim0, _Dim1 >	tile () const __GPU
	Produces a tiled_extent object with the tile extents given by _Dim0, _Dim1 More...
template<int _Dim0, int _Dim1, int _Dim2>
tiled_extent< _Dim0, _Dim1, _Dim2 >	tile () const __GPU
	Produces a tiled_extent object with the tile extents given by _Dim0, _Dim1, _Dim2. More...
extent< _Rank >	operator+ (const index< _Rank > &_Rhs) const __GPU
	Element-wise addition of this extent with an index. More...
extent< _Rank >	operator- (const index< _Rank > &_Rhs) const __GPU
	Element-wise subtraction of this extent with an index. More...
extent< _Rank > &	operator+= (const extent< _Rank > &_Rhs) __GPU
	Element-wise addition of this extent with another extent. More...
extent< _Rank > &	operator-= (const extent< _Rank > &_Rhs) __GPU
	Element-wise subtraction of this extent with another extent. More...
extent< _Rank > &	operator+= (const index< _Rank > &_Rhs) __GPU
	Element-wise addition of this extent with an index. More...
extent< _Rank > &	operator-= (const index< _Rank > &_Rhs) __GPU
	Element-wise subtraction of this extent with an index. More...
extent< _Rank > &	operator+= (int _Rhs) __GPU
	Adds an integer value to each element of this extent. More...
extent< _Rank > &	operator-= (int _Rhs) __GPU
	Subtracts an integer value from each element of this extent. More...
extent< _Rank > &	operator*= (int _Rhs) __GPU
	Multiplies an integer value to each element of this extent. More...
extent< _Rank > &	operator/= (int _Rhs) __GPU
	Divides an integer value into each element of this extent. More...
extent< _Rank > &	operator%= (int _Rhs) __GPU
	Modulus an integer value from each element of this extent. More...
extent< _Rank > &	operator++ () __GPU
	Pre-increments each element of this extent. More...
extent< _Rank >	operator++ (int) __GPU
	Post-increments each element of this extent. More...
extent< _Rank > &	operator-- () __GPU
	Pre-decrements each element of this extent. More...
extent< _Rank >	operator-- (int) __GPU
	Post-decrements each element of this extent. More...
index< _Rank >	_map_index (const index< _Rank > &_Index) const __GPU

Static Public Attributes
static const int	rank = _Rank

Private Member Functions
	extent (details::_eInitializeState) __GPU
	Constructor. More...

Private Attributes
int	_M_base [_Rank]

Friends
template<typename _Value_type , int _Rank>
class	array
template<int _Rank, int _Element_size>
class	details::_Array_view_shape
template<int _Rank, int _Element_size>
class	details::_Array_view_base
template<class _Tuple_type >
_Tuple_type	details::_Create_uninitialized_tuple () __GPU

Detailed Description

template<int _Rank>
class Concurrency::extent< _Rank >

The extent<N> type represents an N-dimensional vector of int which specifies the bounds of an N-dimensional space with an origin of 0. The values in the coordinate vector are ordered from most-significant to least-significant. Thus, in 2-dimensional space, the extent vector (5,3) represents a space with 5 rows and 3 columns.

All components of an extent must be non-negative. E.g. extent<3> domain(2, 3, 4); represents all points index<3> _Index; such that 0 <= _Index[0] < 2; 0 <= _Index[1] < 3; 0 <= _Index[2] < 4;

Parameters

_Rank

The _Rank or the dimensionality of the index space.

Member Typedef Documentation

template<int _Rank>

typedef int Concurrency::extent< _Rank >::value_type

Constructor & Destructor Documentation

template<int _Rank>

Concurrency::extent< _Rank >::extent ( )

inline

Default constructor. The value at each dimension is initialized to zero.

    {
        details::_compound_assign_op_loop_helper<extent<_Rank>, details::opAssign>::func(*this, 0);
    }

template<int _Rank>

Concurrency::extent< _Rank >::extent ( const extent< _Rank > &  _Other )

inline

Copy constructor. Constructs a new extent from the supplied argument _Other.

Parameters

_Other

The extent instance to be copied from .

    {
        details::_compound_assign_op_loop_helper<extent<_Rank>, details::opAssign>::func(*this, _Other);
    }

template<int _Rank>

Concurrency::extent< _Rank >::extent ( int  _I )

inlineexplicit

Constructor for extent<1>.

Parameters

_I	The value for initialization

    {
        static_assert(_Rank == 1, "This constructor can only be used to construct an extent<1> object.");
        _M_base[0] = _I;
    }

template<int _Rank>

Concurrency::extent< _Rank >::extent ( int  _I0, int  _I1  )

inline

Constructor for extent<2>

Parameters

_I0	The extent value for dimension 0
_I1	The extent value for dimension 1

    {
        static_assert(_Rank == 2, "This constructor can only be used to construct an extent<2> object.");
        _M_base[0] = _I0;
        _M_base[1] = _I1;
    }

template<int _Rank>

Concurrency::extent< _Rank >::extent ( int  _I0, int  _I1, int  _I2  )

inline

Constructor for extent<3>

Parameters

_I0	The extent value for dimension 0
_I1	The extent value for dimension 1
_I2	The extent value for dimension 2

    {
        static_assert(_Rank == 3, "This constructor can only be used to construct an extent<3> object.");
        _M_base[0] = _I0;
        _M_base[1] = _I1;
        _M_base[2] = _I2;
    }

template<int _Rank>

Concurrency::extent< _Rank >::extent ( const int  _Array[_Rank] )

inlineexplicit

Constructs an extent with the coordinate values provided the array of int component values. If the coordinate array length is not N, the behavior is undefined.

Parameters

_Array

A single-dimensional array with _Rank elements.

    {
        details::_compound_assign_op_loop_helper<extent<_Rank>, details::opAssign>::func(*this, _Array);
    }

template<int _Rank>

Concurrency::extent< _Rank >::extent ( details::_eInitializeState  )

inlineprivate

Constructor.

Indicates that no initialization is necessary.

{}

Member Function Documentation

template<int _Rank>

Concurrency::extent< _Rank >::_CPP_AMP_VERIFY_RANK	(	_Rank	,
		extent< _Rank >
	)

template<int _Rank>

index<_Rank> Concurrency::extent< _Rank >::_map_index ( const index< _Rank > &  _Index ) const

inline

                                                                    {
        return _Index;
    }

template<int _Rank>

bool Concurrency::extent< _Rank >::contains ( const index< rank > &  _Index ) const

inline

Tests whether the index "_Index" is properly contained within this extent.

    {
        return details::_contains<extent<rank>, index<rank>, rank>::func(*this, _Index);
    }

template<int _Rank>

extent<_Rank>& Concurrency::extent< _Rank >::operator%= ( int  _Rhs )

inline

Modulus an integer value from each element of this extent.

Parameters

_Rhs	The integer value to modulo this extent

Returns

A reference to this extent.

    {
        details::_compound_assign_op_loop_helper<extent<_Rank>, details::opModEq>::func(*this, _Rhs);
        return *this;
    }

template<int _Rank>

extent<_Rank>& Concurrency::extent< _Rank >::operator*= ( int  _Rhs )

inline

Multiplies an integer value to each element of this extent.

Parameters

_Rhs	The integer value to multiply into this extent

Returns

A reference to this extent.

    {
        details::_compound_assign_op_loop_helper<extent<_Rank>, details::opMulEq>::func(*this, _Rhs);
        return *this;
    }

template<int _Rank>

extent<_Rank> Concurrency::extent< _Rank >::operator+ ( const index< _Rank > &  _Rhs ) const

inline

Element-wise addition of this extent with an index.

Parameters

_Rhs	The index to add to this extent

Returns

A new extent with the result of the computation.

    {
        extent<_Rank> new_extent(details::_do_not_initialize);
        details::_arithmetic_op_loop_helper<extent<_Rank>, details::opAdd>::func(new_extent, *this, _Rhs);
        return new_extent;
    }

template<int _Rank>

extent<_Rank>& Concurrency::extent< _Rank >::operator++ ( )

inline

Pre-increments each element of this extent.

Returns

A reference to this extent.

    {
        details::_compound_assign_op_loop_helper<extent<_Rank>, details::opAddEq>::func(*this, 1);
        return *this;
    }

template<int _Rank>

extent<_Rank> Concurrency::extent< _Rank >::operator++ ( int  )

inline

Post-increments each element of this extent.

Returns

The value of the unincremented extent.

    {
        extent<_Rank> old_extent(*this);
        details::_compound_assign_op_loop_helper<extent<_Rank>, details::opAddEq>::func(*this, 1);
        return old_extent;
    }

template<int _Rank>

extent<_Rank>& Concurrency::extent< _Rank >::operator+= ( const extent< _Rank > &  _Rhs )

inline

Element-wise addition of this extent with another extent.

Parameters

_Rhs	The extent to add

Returns

A reference to this extent.

    {
        details::_compound_assign_op_loop_helper<extent<_Rank>, details::opAddEq>::func(*this, _Rhs);
        return *this;
    }

template<int _Rank>

extent<_Rank>& Concurrency::extent< _Rank >::operator+= ( const index< _Rank > &  _Rhs )

inline

Element-wise addition of this extent with an index.

Parameters

_Rhs	The index to add

Returns

A reference to this extent.

    {
        details::_compound_assign_op_loop_helper<extent<_Rank>, details::opAddEq>::func(*this, _Rhs);
        return *this;
    }

template<int _Rank>

extent<_Rank>& Concurrency::extent< _Rank >::operator+= ( int  _Rhs )

inline

Adds an integer value to each element of this extent.

Parameters

_Rhs	The integer value to add to this extent

Returns

A reference to this extent.

    {
        details::_compound_assign_op_loop_helper<extent<_Rank>, details::opAddEq>::func(*this, _Rhs);
        return *this;
    }

template<int _Rank>

extent<_Rank> Concurrency::extent< _Rank >::operator- ( const index< _Rank > &  _Rhs ) const

inline

Element-wise subtraction of this extent with an index.

Parameters

_Rhs	The index to subtract from this extent

Returns

A new extent with the result of the computation.

    {
        extent<_Rank> new_extent(details::_do_not_initialize);
        details::_arithmetic_op_loop_helper<extent<_Rank>, details::opSub>::func(new_extent, *this, _Rhs);
        return new_extent;
    }

template<int _Rank>

extent<_Rank>& Concurrency::extent< _Rank >::operator-- ( )

inline

Pre-decrements each element of this extent.

Returns

A reference to this extent.

    {
        details::_compound_assign_op_loop_helper<extent<_Rank>, details::opSubEq>::func(*this, 1);
        return *this;
    }

template<int _Rank>

extent<_Rank> Concurrency::extent< _Rank >::operator-- ( int  )

inline

Post-decrements each element of this extent.

Returns

The value of the undecremented extent.

    {
        extent<_Rank> old_extent(*this);
        details::_compound_assign_op_loop_helper<extent<_Rank>, details::opSubEq>::func(*this, 1);
        return old_extent;
    }

template<int _Rank>

extent<_Rank>& Concurrency::extent< _Rank >::operator-= ( const extent< _Rank > &  _Rhs )

inline

Element-wise subtraction of this extent with another extent.

Parameters

_Rhs	The extent to subtract

Returns

A reference to this extent.

    {
        details::_compound_assign_op_loop_helper<extent<_Rank>, details::opSubEq>::func(*this, _Rhs);
        return *this;
    }

template<int _Rank>

extent<_Rank>& Concurrency::extent< _Rank >::operator-= ( const index< _Rank > &  _Rhs )

inline

Element-wise subtraction of this extent with an index.

Parameters

_Rhs	The index to subtract

Returns

A reference to this extent.

    {
        details::_compound_assign_op_loop_helper<extent<_Rank>, details::opSubEq>::func(*this, _Rhs);
        return *this;
    }

template<int _Rank>

extent<_Rank>& Concurrency::extent< _Rank >::operator-= ( int  _Rhs )

inline

Subtracts an integer value from each element of this extent.

Parameters

_Rhs	The integer value to subtract from this extent

Returns

A reference to this extent.

    {
        details::_compound_assign_op_loop_helper<extent<_Rank>, details::opSubEq>::func(*this, _Rhs);
        return *this;
    }

template<int _Rank>

extent<_Rank>& Concurrency::extent< _Rank >::operator/= ( int  _Rhs )

inline

Divides an integer value into each element of this extent.

Parameters

_Rhs	The integer value to divide into this extent

Returns

A reference to this extent.

    {
        details::_compound_assign_op_loop_helper<extent<_Rank>, details::opDivEq>::func(*this, _Rhs);
        return *this;
    }

template<int _Rank>

extent<_Rank>& Concurrency::extent< _Rank >::operator= ( const extent< _Rank > &  _Other )

inline

copy-assignment operator

    {
        details::_compound_assign_op_loop_helper<extent<_Rank>, details::opAssign>::func(*this, _Other);
        return *this;
    }

template<int _Rank>

int Concurrency::extent< _Rank >::operator[] ( unsigned int  _Index ) const

inline

Index operator.

Parameters

_Index

An integral value between 0 and _Rank-1.

Returns

The corresponding value stored at _Index.

    {
        return _M_base[_Index];
    }

template<int _Rank>

int& Concurrency::extent< _Rank >::operator[] ( unsigned int  _Index )

inline

Index operators.

Parameters

_Index

An integral value between 0 and _Rank-1.

Returns

A reference to the value stored at _Index.

    {
        return _M_base[_Index];
    }

template<int _Rank>

unsigned int Concurrency::extent< _Rank >::size ( ) const

inline

Returns the total linear size of this extent (in units of elements).

    {
        return static_cast<unsigned int>(_product_helper<extent<_Rank>>::func(_M_base));
    }

template<int _Rank>

template<int _Dim0>

tiled_extent<_Dim0> Concurrency::extent< _Rank >::tile ( ) const

inline

Produces a tiled_extent object with the tile extents given by _Dim0.

    {
        static_assert(rank == 1, "One-dimensional tile() method only available on extent<1>");
        static_assert(_Dim0>0, "All tile dimensions must be positive");

        return tiled_extent<_Dim0>(*this);
    }

template<int _Rank>

template<int _Dim0, int _Dim1>

tiled_extent<_Dim0, _Dim1> Concurrency::extent< _Rank >::tile ( ) const

inline

Produces a tiled_extent object with the tile extents given by _Dim0, _Dim1

    {
        static_assert(rank == 2, "Two-dimensional tile() method only available on extent<2>");
        static_assert(_Dim0>0 && _Dim1>0, "All tile dimensions must be positive");

        return tiled_extent<_Dim0, _Dim1>(*this);
    }

template<int _Rank>

template<int _Dim0, int _Dim1, int _Dim2>

tiled_extent<_Dim0, _Dim1, _Dim2> Concurrency::extent< _Rank >::tile ( ) const

inline

Produces a tiled_extent object with the tile extents given by _Dim0, _Dim1, _Dim2.

    {
        static_assert(rank == 3, "Three-dimensional tile() method only available on extent<3>");
        static_assert(_Dim0>0 && _Dim1>0 && _Dim2>0, "All tile dimensions must be positive");

        return tiled_extent<_Dim0, _Dim1, _Dim2>(*this);
    }

Friends And Related Function Documentation

template<int _Rank>

template<typename _Value_type , int _Rank>

friend class array

friend

template<int _Rank>

template<int _Rank, int _Element_size>

friend class details::_Array_view_base

friend

template<int _Rank>

template<int _Rank, int _Element_size>

friend class details::_Array_view_shape

friend

template<int _Rank>

template<class _Tuple_type >

_Tuple_type details::_Create_uninitialized_tuple ( )

friend

Member Data Documentation

template<int _Rank>

int Concurrency::extent< _Rank >::_M_base[_Rank]

private

template<int _Rank>

const int Concurrency::extent< _Rank >::rank = _Rank

static

---

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

• VS2017/inc/amp.h