Concurrency::index< _Rank > Class Template Reference

Define an N-dimensional index point; which may also be viewed as a vector based at the origin in N-space. More...

#include <amp.h>

Public Types
typedef int	value_type

Public Member Functions
	_CPP_AMP_VERIFY_RANK (_Rank, index)
	index () __GPU
	Default constructor, initializes all elements with 0. More...
	index (const index< _Rank > &_Other) __GPU
	Copy Constructor. More...
	index (int _I) __GPU
	Constructor for index<1> More...
	index (int _I0, int _I1) __GPU
	Constructor for index<2> More...
	index (int _I0, int _I1, int _I2) __GPU
	Constructor for index<3> More...
	index (const int _Array[_Rank]) __GPU
	Constructs an index<N> with the coordinate values provided the array of int component values. If the coordinate array length is not N, the behavior is undefined. More...
index< _Rank > &	operator= (const index< _Rank > &_Other) __GPU
	copy-assignment operators More...
int	operator[] (unsigned _Index) const __GPU
	Index operator. More...
int &	operator[] (unsigned _Index) __GPU
	Index operator. More...
index< _Rank > &	operator+= (const index< _Rank > &_Rhs) __GPU
	Element-wise addition of this index with another index. More...
index< _Rank > &	operator-= (const index< _Rank > &_Rhs) __GPU
	Element-wise subtraction of this index with another index. More...
index< _Rank > &	operator+= (int _Rhs) __GPU
	Adds an integer value to each element of this index. More...
index< _Rank > &	operator-= (int _Rhs) __GPU
	Subtracts an integer value from each element of this index. More...
index< _Rank > &	operator*= (int _Rhs) __GPU
	Multiplies each element of this index with an integer value. More...
index< _Rank > &	operator/= (int _Rhs) __GPU
	Divides each element of this index by an integer value. More...
index< _Rank > &	operator%= (int _Rhs) __GPU
	Modulus an integer value into each element of this index. More...
index< _Rank > &	operator++ () __GPU
	Pre-increments each element of this index. More...
index< _Rank >	operator++ (int) __GPU
	Post-increments each element of this index. More...
index< _Rank > &	operator-- () __GPU
	Pre-decrements each element of this index. More...
index	operator-- (int) __GPU
	Post-decrements each element of this index. More...

Static Public Attributes
static const int	rank = _Rank

Private Member Functions
	index (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::index< _Rank >

Define an N-dimensional index point; which may also be viewed as a vector based at the origin in N-space.

The index<N> type represents an N-dimensional vector of int which specifies a unique position in an N-dimensional space. The values in the coordinate vector are ordered from most-significant to least-significant. Thus, in 2-dimensional space, the index vector (5,3) represents the position at row 5, column 3.

The position is relative to the origin in the N-dimensional space, and can contain negative component values.

Parameters

_Rank

The dimensionality space into which this index applies, can be any integer greater than 0.

Member Typedef Documentation

template<int _Rank>

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

Constructor & Destructor Documentation

template<int _Rank>

Concurrency::index< _Rank >::index ( )

inline

Default constructor, initializes all elements with 0.

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

template<int _Rank>

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

inline

Copy Constructor.

Parameters

_Other

The object to copy from

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

template<int _Rank>

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

inlineexplicit

Constructor for index<1>

Parameters

_I	The value for initialization

    {
        static_assert(_Rank == 1, "This constructor can only be used to construct an index<1> object.");
        details::_compound_assign_op_loop_helper<index<_Rank>, details::opAssign>::func(*this, _I);
    }

template<int _Rank>

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

inline

Constructor for index<2>

Parameters

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

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

template<int _Rank>

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

inline

Constructor for index<3>

Parameters

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

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

template<int _Rank>

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

inlineexplicit

Constructs an index<N> 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<index<_Rank>, details::opAssign>::func(*this, _Array);
    }

template<int _Rank>

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

inlineprivate

Constructor.

Indicates that no initialization is necessary.

{}

Member Function Documentation

template<int _Rank>

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

template<int _Rank>

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

inline

Modulus an integer value into each element of this index.

Parameters

_Rhs	The integer value to modulus.

Returns

A reference to this index.

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

template<int _Rank>

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

inline

Multiplies each element of this index with an integer value.

Parameters

_Rhs	The integer value to multiply.

Returns

A reference to this index.

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

template<int _Rank>

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

inline

Pre-increments each element of this index.

Returns

A reference to this index.

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

template<int _Rank>

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

inline

Post-increments each element of this index.

Returns

The value of the unincremented index.

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

template<int _Rank>

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

inline

Element-wise addition of this index with another index.

Parameters

_Rhs	The index to add

Returns

A reference to this index.

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

template<int _Rank>

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

inline

Adds an integer value to each element of this index.

Parameters

_Rhs	The integer value to add

Returns

A reference to this index.

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

template<int _Rank>

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

inline

Pre-decrements each element of this index.

Returns

A reference to this index.

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

template<int _Rank>

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

inline

Post-decrements each element of this index.

Returns

The value of the undecremented index.

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

template<int _Rank>

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

inline

Element-wise subtraction of this index with another index.

Parameters

_Rhs	The index to subtract

Returns

A reference to this index.

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

template<int _Rank>

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

inline

Subtracts an integer value from each element of this index.

Parameters

_Rhs	The integer value to subtract.

Returns

A reference to this index.

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

template<int _Rank>

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

inline

Divides each element of this index by an integer value.

Parameters

_Rhs	The integer value to divide by.

Returns

A reference to this index.

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

template<int _Rank>

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

inline

copy-assignment operators

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

template<int _Rank>

int Concurrency::index< _Rank >::operator[] ( unsigned  _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::index< _Rank >::operator[] ( unsigned  _Index )

inline

Index operator.

Parameters

_Index

An integral value between 0 and _Rank-1.

Returns

A reference to the corresponding value stored at _Index.

    {
        return _M_base[_Index];
    }

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::index< _Rank >::_M_base[_Rank]

private

template<int _Rank>

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

static

---

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

• VS2013/inc/amp.h