Detailed Description

SIMD Vector of single precision floats.

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

#include <Vc/float_v>

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

Public Member Functions

float_v ()

Construct an uninitialized vector.

float_v (Vc::Zero)

Construct a vector with the entries initialized to zero.

float_v (Vc::One)

Construct a vector with the entries initialized to one.

float_v (float *alignedMemory)

Construct a vector loading its entries from alignedMemory.

template<typename OtherVector >

float_v (const OtherVector &)

Convert from another vector type.

float_v (float x)

Broadcast Constructor.

void load (const float *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 float_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.

float & operator[] (int index)

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

float operator[] (int index) const

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

MaskedVector operator() (const float_m &mask)

Writemask the vector before an assignment.

float_v sorted () const

Return a sorted copy of the vector.

float_v copySign (float_v reference) const

Copies the sign of reference.

float_v exponent () const

Extracts the exponent.

float_m isNegative () const

Check the sign bit of each vector entry.

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 >

float_v (const float *array, const IndexT indexes)

gather constructor

template<typename IndexT >

float_v (const float *array, const IndexT indexes, const float_m &mask)

masked gather constructor, initialized to zero

template<typename IndexT >

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

gather

template<typename IndexT >

void gather (const float *array, const IndexT indexes, const float_m &mask)

masked gather

template<typename IndexT >

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

scatter

template<typename IndexT >

void scatter (float *array, const IndexT indexes, const float_m &mask) const

masked scatter