Detailed Description

SIMD Vector of 32 bit unsigned integers.

Note: This is the same type as Vc::Vector<unsigned int>.

#include <Vc/uint_v>

Public Types
enum	{ Size }
typedef uint_v	IndexType
	The type of the vector used for indexes in gather and scatter operations.
typedef unsigned int	EntryType
	The type of the entries in the vector.
typedef uint_m	Mask
	The type of the mask used for masked operations and returned from comparisons.

Public Member Functions

uint_v ()

Construct an uninitialized vector.

uint_v (Vc::Zero)

Construct a vector with the entries initialized to zero.

uint_v (Vc::One)

Construct a vector with the entries initialized to one.

uint_v (Vc::IndexesFromZero)

Construct a vector with the entries initialized to 0, 1, 2, 3, 4, 5, ...

uint_v (unsigned int *alignedMemory)

Construct a vector loading its entries from alignedMemory.

template<typename OtherVector >

uint_v (const OtherVector &)

Convert from another vector type.

uint_v (unsigned int x)

Broadcast Constructor.

void load (const unsigned int *memory, LoadStoreFlags align=Aligned)

Construct a vector from an array of vectors with different Size.

void setZero ()

Set all entries to zero.

void setZero (const uint_m &mask)

Set all entries to zero where the mask is set.

void store (EntryType *memory, LoadStoreFlags align=Aligned) const

Store the vector data to memory.

unsigned int & operator[] (int index)

This operator can be used to modify scalar entries of the vector.

unsigned int operator[] (int index) const

This operator can be used to read scalar entries of the vector.

MaskedVector operator() (const uint_m &mask)

Writemask the vector before an assignment.

uint_v sorted () const

Return a sorted copy of the vector.

Gather and Scatter Functions

The gather and scatter functions allow you to easily use vectors with structured data and random accesses.

There are several variants:

random access in arrays (a[i])
random access of members of structs in an array (a[i].member)
random access of members of members of structs in an array (a[i].member1.member2)

All gather and scatter functions optionally take a mask as last argument. In that case only the entries that are selected in the mask are read in memory and copied to the vector. This allows you to have invalid indexes in the indexes vector if those are masked off in mask.

Note: If you use a constructor for a masked gather then the unmodified entries of the vector are initilized to 0 before the gather. If you really want them uninitialized you can create a uninitialized vector object first and then call the masked gather function on it.

The index type (IndexT) can either be a pointer to integers (array) or a vector of integers.

Accessing values of a struct works like this:

struct MyData {
  float a;
  int b;
};
void foo(MyData *data, uint_v indexes) {
  const float_v v1(data, &MyData::a, indexes);
  const int_v   v2(data, &MyData::b, indexes);
  v1.scatter(data, &MyData::a, indexes - float_v::Size);
  v2.scatter(data, &MyData::b, indexes - 1);
}

Parameters

array	A pointer into memory (without alignment restrictions).
member1	If `array` points to a struct, `member1` determines the member in the struct to be read. Thus the offsets in `indexes` are relative to the `array` and not to the size of the gathered type (i.e. array[i].member1 is accessed instead of (&(array->member1))[i])
member2	If `member1` is a struct then `member2` selects the member to be read from that struct (i.e. array[i].member1.member2 is read).
indexes	Determines the offsets into `array` where the values are gathered from/scattered to. The type of indexes can either be an integer vector or a type that supports operator[] access.
mask	If a mask is given only the active entries will be gathered/scattered.

template<typename IndexT >

uint_v (const unsigned int *array, const IndexT indexes)

gather constructor

template<typename IndexT >

uint_v (const unsigned int *array, const IndexT indexes, const uint_m &mask)

masked gather constructor, initialized to zero

template<typename IndexT >

void gather (const unsigned int *array, const IndexT indexes)

gather

template<typename IndexT >

void gather (const unsigned int *array, const IndexT indexes, const uint_m &mask)

masked gather

template<typename IndexT >

void scatter (unsigned int *array, const IndexT indexes) const

scatter

template<typename IndexT >

void scatter (unsigned int *array, const IndexT indexes, const uint_m &mask) const

masked scatter