Detailed Description

SIMD Vector of 16 bit signed integers.

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

Warning: Vectors of this type are not supported on all platforms. In that case the vector class will silently fall back to a Vc::int_v.

#include <Vc/short_v>

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

Public Member Functions

short_v ()

Construct an uninitialized vector.

short_v (Vc::Zero)

Construct a vector with the entries initialized to zero.

short_v (Vc::One)

Construct a vector with the entries initialized to one.

short_v (Vc::IndexesFromZero)

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

short_v (short *alignedMemory)

Construct a vector loading its entries from alignedMemory.

template<typename OtherVector >

short_v (const OtherVector &)

Convert from another vector type.

short_v (short x)

Broadcast Constructor.

void load (const short *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 short_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.

short & operator[] (int index)

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

short operator[] (int index) const

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

MaskedVector operator() (const short_m &mask)

Writemask the vector before an assignment.

short_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 >

short_v (const short *array, const IndexT indexes)

gather constructor

template<typename IndexT >

short_v (const short *array, const IndexT indexes, const short_m &mask)

masked gather constructor, initialized to zero

template<typename IndexT >

void gather (const short *array, const IndexT indexes)

gather

template<typename IndexT >

void gather (const short *array, const IndexT indexes, const short_m &mask)

masked gather

template<typename IndexT >

void scatter (short *array, const IndexT indexes) const

scatter

template<typename IndexT >

void scatter (short *array, const IndexT indexes, const short_m &mask) const

masked scatter