Detailed Description

template<typename T, typename Abi = VectorAbi::Best<T>>
class Vc::Vector< T, Abi >

The main vector class for expressing data parallelism.

are specializations of this class. For most cases there are no API differences for the specializations. Make use of Vector<T> for generic programming, otherwise you might prefer to use the *_v aliases.

See also: Vc::float_v, Vc::double_v, Vc::int_v, Vc::uint_v, Vc::short_v, Vc::ushort_v; Mask

Definition at line 45 of file types.h.

#include <Vc/vector.h>

Public Types
using	abi = Abi
	The ABI tag type of the current template instantiation.

using	EntryType = typename VectorTraits< T, Abi >::EntryType
	The type of the entries in the vector.

using	value_type = EntryType
	The type of the entries in the vector. More...

using	MaskType = Vc::Mask< T, Abi >
	The type of the mask used for masked operations and returned from comparisons.

using	mask_type = MaskType
	The type of the mask used for masked operations and returned from comparisons. More...

using	IndexType = Vc::SimdArray< int, size()>
	The type of the vector used for indexes in gather and scatter operations.

using	index_type = IndexType
	The type of the vector used for indexes in gather and scatter operations. More...

Public Member Functions

void setZero ()

Set all entries to zero.

void setZero (MaskType mask)

Set all entries to zero where the mask is set. More...

void setZeroInverted (MaskType mask)

Set all entries to zero where the mask is not set. More...

void setQnan ()

Set all entries to the bit representation of a QNaN.

void setQnan (MaskType mask)

Set all entries to the bit representation of a QNaN where the mask is set. More...

template<typename V2 >

V2 reinterpretCast () const

reinterpret_cast the vector components to construct a vector of type V2.

Common::WriteMaskedVector< Vector, MaskType > operator() (MaskType mask)

Writemask the vector before an assignment. More...

Vector sorted () const

Return a sorted copy of the vector. More...

Compile-Time Constant Initialization

Vector ()=default

Construct a zero-initialized vector object. More...

Vector (VectorSpecialInitializerZero)

Construct a vector with the entries initialized to zero. More...

Vector (VectorSpecialInitializerOne)

Construct a vector with the entries initialized to one. More...

Vector (VectorSpecialInitializerIndexesFromZero)

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

Conversion/Broadcast Constructors

template<typename U >

Vector (Vector< U, abi > x, enable_if< Traits::is_implicit_cast_allowed< U, T >::value >=nullarg)

Implict conversion from compatible Vector<U, Abi> types.

template<typename U >

Vector (Vector< U, abi > x, enable_if<!Traits::is_implicit_cast_allowed< U, T >::value >=nullarg)

Explicit conversion (i.e. More...

Vector (EntryType a)

Broadcast Constructor. More...

template<typename U >

Vector (U a, enable_if< std::is_same< U, int >::value &&!std::is_same< U, EntryType >::value >=nullarg)

Loads & Stores

Vector (const EntryType *mem)

Construct a vector from loading its entries from the array at mem. More...

template<typename Flags , typename = enable_if<Traits::is_load_store_flag<Flags>::value>>

Vector (const EntryType *mem, Flags flags)

Construct a vector from loading its entries from the array at mem. More...

template<typename U , typename Flags = DefaultLoadTag, typename = enable_if< (!std::is_integral<U>::value || !std::is_integral<EntryType>::value || sizeof(EntryType) >= sizeof(U)>

Vector (const U *x, Flags flags=Flags())

void load (const EntryType *mem)

Load the vector entries from mem, overwriting the previous values. More...

template<typename Flags , typename = enable_if<Traits::is_load_store_flag<Flags>::value>>

void load (const EntryType *mem, Flags flags)

Load the vector entries from mem, overwriting the previous values. More...

template<typename U , typename Flags = DefaultLoadTag, typename = enable_if< (!std::is_integral<U>::value || !std::is_integral<EntryType>::value || sizeof(EntryType) >= sizeof(U)>

void load (const U *mem, Flags=Flags()) 1

template<typename U , typename Flags = DefaultStoreTag, typename = enable_if<std::is_arithmetic<U>::value &&Traits::is_load_store_flag<Flags>::value>>

void store (U *mem, Flags flags=Flags()) const 1

Store the vector data to mem. More...

template<typename U , typename Flags = DefaultStoreTag, typename = enable_if<std::is_arithmetic<U>::value &&Traits::is_load_store_flag<Flags>::value>>

void store (U *mem, MaskType mask, Flags flags=Flags()) const 1

Store the vector data to mem where mask is set. More...

void store (EntryType *mem) const

The following store overloads support classes that have a cast operator to EntryType *.

template<typename Flags , typename = enable_if<Traits::is_load_store_flag<Flags>::value>>

void store (EntryType *mem, Flags flags) const

void store (EntryType *mem, MaskType mask) const

template<typename Flags , typename = enable_if<Traits::is_load_store_flag<Flags>::value>>

void store (EntryType *mem, MaskType mask, Flags flags) const

Gather constructors and member functions

Constructs or loads a vector from the objects at mem[indexes[0]], mem[indexes[1]], mem[indexes[2]], ...

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

Gathers from structured data (AoS: arrays of struct) are possible via a special subscript operator of the container (array). You can use Vc::array and Vc::vector as drop-in replacements for std::array and std::vector. These container classes contain the necessary subscript operator overload. Example:

Vc::vector<float> data(100);
std::iota(data.begin(), data.end(), 0.f);  // fill with values 0, 1, 2, ...
auto indexes = float_v::IndexType::IndexesFromZero();
float_v gathered = data[indexes];  // gathered == [0, 1, 2, ...]

Alternatively, you can use Vc::Common::AdaptSubscriptOperator to extend a given container class with the necessary subscript operator. Example:

template <typename T, typename Allocator = std::allocator<T>>

using my_vector = Vc::Common::AdaptSubscriptOperator<std::vector<T, Allocator>>;

Parameters

mem	A pointer to memory which contains objects of type `MT` at the offsets given by `indexes`.
indexes	A container/vector of offsets into `mem`. The type of `indexes` (`IT`) may either be a pointer to integers (C-array) or a vector of integers (preferrably IndexType).
mask	If a mask is given, only the active entries will be copied from memory.

Note: If you use a masked gather constructor the masked-off entries of the vector are zero-initilized.

template<typename MT , typename IT , typename = enable_if<Traits::has_subscript_operator<IT>::value>>

Vector (const MT *mem, IT &&indexes)

Gather constructor.

template<typename MT , typename IT , typename = enable_if<Vc::Traits::has_subscript_operator<IT>::value>>

Vector (const MT *mem, IT &&indexes, MaskArgument mask)

Masked gather constructor.

template<typename MT , typename IT , typename = enable_if<Vc::Traits::has_subscript_operator<IT>::value>>

void gather (const MT *mem, IT &&indexes)

Gather function.

template<typename MT , typename IT , typename = enable_if<Vc::Traits::has_subscript_operator<IT>::value>>

void gather (const MT *mem, IT &&indexes, MaskArgument mask)

Masked gather function.

template<typename S1 , typename IT >

Vector (const S1 *array, const EntryType S1::*member1, const IT indexes)

template<typename S1 , typename IT >

Vector (const S1 *array, const EntryType S1::*member1, const IT indexes, MaskArgument mask)

template<typename S1 , typename S2 , typename IT >

Vector (const S1 *array, const S2 S1::*member1, const EntryType S2::*member2, const IT indexes)

template<typename S1 , typename S2 , typename IT >

Vector (const S1 *array, const S2 S1::*member1, const EntryType S2::*member2, const IT indexes, MaskArgument mask)

template<typename S1 , typename IT1 , typename IT2 >

Vector (const S1 *array, const EntryType *const S1::*ptrMember1, const IT1 outerIndexes, const IT2 innerIndexes)

template<typename S1 , typename IT1 , typename IT2 >

Vector (const S1 *array, const EntryType *const S1::*ptrMember1, const IT1 outerIndexes, const IT2 innerIndexes, MaskArgument mask)

template<typename S1 , typename IT >

void gather (const S1 *array, const EntryType S1::*member1, const IT indexes)

template<typename S1 , typename IT >

void gather (const S1 *array, const EntryType S1::*member1, const IT indexes, MaskArgument mask)

template<typename S1 , typename S2 , typename IT >

void gather (const S1 *array, const S2 S1::*member1, const EntryType S2::*member2, const IT indexes)

template<typename S1 , typename S2 , typename IT >

void gather (const S1 *array, const S2 S1::*member1, const EntryType S2::*member2, const IT indexes, MaskArgument mask)

template<typename S1 , typename IT1 , typename IT2 >

void gather (const S1 *array, const EntryType *const S1::*ptrMember1, const IT1 outerIndexes, const IT2 innerIndexes)

template<typename S1 , typename IT1 , typename IT2 >

void gather (const S1 *array, const EntryType *const S1::*ptrMember1, const IT1 outerIndexes, const IT2 innerIndexes, MaskArgument mask)

Scatter functions

Stores a vector to the objects at mem[indexes[0]], mem[indexes[1]], mem[indexes[2]], ...

Parameters

mem	A pointer to memory which contains objects of type `MT` at the offsets given by `indexes`.
indexes
mask

template<typename MT , typename IT , typename = enable_if<Vc::Traits::has_subscript_operator<IT>::value>>

void scatter (MT *mem, IT &&indexes) const

Scatter function.

template<typename MT , typename IT , typename = enable_if<Vc::Traits::has_subscript_operator<IT>::value>>

void scatter (MT *mem, IT &&indexes, MaskArgument mask) const

Masked scatter function.

template<typename S1 , typename IT >

void scatter (S1 *array, EntryType S1::*member1, const IT indexes) const

template<typename S1 , typename IT >

void scatter (S1 *array, EntryType S1::*member1, const IT indexes, MaskArgument mask) const

template<typename S1 , typename S2 , typename IT >

void scatter (S1 *array, S2 S1::*member1, EntryType S2::*member2, const IT indexes) const

template<typename S1 , typename S2 , typename IT >

void scatter (S1 *array, S2 S1::*member1, EntryType S2::*member2, const IT indexes, MaskArgument mask) const

template<typename S1 , typename IT1 , typename IT2 >

void scatter (S1 *array, EntryType *S1::*ptrMember1, const IT1 outerIndexes, const IT2 innerIndexes) const

template<typename S1 , typename IT1 , typename IT2 >

void scatter (S1 *array, EntryType *S1::*ptrMember1, const IT1 outerIndexes, const IT2 innerIndexes, MaskArgument mask) const

Scalar Subscript Operators

EntryType & operator[] (size_t index)

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

EntryType operator[] (size_t index) const

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

Unary Operators

MaskType operator! () const

Determine where the vector is null. More...

Vector operator~ () const

Inverts all bits. More...

Vector operator- () const

Returns a new vector object with all entries negated.

Vector operator+ () const

Returns a copy of the vector object.

Increment and Decrement Operators

The increment and decrement operators apply the increment/decrement operation per component.

The semantics are equal to the semantics of the fundamental arithmetics type T.

Note: Over-/Underflow of signed integral types is undefined behavior and may actually break your code.

Vector & operator++ ()

Vector operator++ (int)

Vector & operator-- ()

Vector operator-- (int)

Arithmetic Operations

The arithmetic operations are implemented as component-wise application of the operator on the two vector objects.

Example:

void foo(float_v a, float_v b) {
  const float_v product    = a * b;
  const float_v difference = a - b;
  a += b;
  auto quotient = a / b;
  auto modulo = static_cast<int_v>(a) % static_cast<int_v>(b);
}

Parameters

x	The vector to add, subtract, multiply, or divide by.

Returns: A vector object of the same type with the components filled according to a component-wise application of the operator.

Note: If a signed integral vector operation overflows the result is undefined. (which is in agreement to the behavior of the fundamental signed integral types in C++)

Vector & operator+= (const Vector &x)

Vector operator+ (const Vector &x) const

Vector & operator-= (const Vector &x)

Vector operator- (const Vector &x) const

Vector & operator*= (const Vector &x)

Vector operator* (const Vector &x) const

Vector & operator/= (const Vector &x)

Vector operator/ (const Vector &x) const

Vector & operator%= (const Vector &x)

Vector operator% (const Vector &x) const

Binary Operations

The binary operations are implemented as component-wise application of the operator on the two vector objects.

Example:

void foo(int_v a, int_v b) {
  const int_v combined_bits = a | b;
  const int_v masked_bits = a & b;
  a ^= b;  // flipped bits
}

Returns: A vector object of the same type with the components filled according to a component-wise application of the operator.

Vector & operator|= (const Vector &x)

Vector operator| (const Vector &x) const

Vector & operator&= (const Vector &x)

Vector operator& (const Vector &x) const

Vector & operator^= (const Vector &x)

Vector operator^ (const Vector &x) const

Shift Operations

The shift operations are implemented as component-wise application of the operator on the two vector objects.

Example:

void foo(int_v a, int_v b) {
  const int_v right = a >> b;
  a <<= b;
}

Returns: A vector object of the same type with the components filled according to a component-wise application of the operator.

Vector & operator<<= (const Vector &x)

Vector operator<< (const Vector &x) const

Vector & operator>>= (const Vector &x)

Vector operator>> (const Vector &x) const

Comparisons

All comparison operators return a mask object.

Example:

void foo(const float_v &a, const float_v &b) {
  const float_m mask = a < b;
  ...
}

Parameters

x	The vector to compare against.

Returns: A mask object. Its components contain the boolean results of the component-wise compare operation.

MaskType operator== (const Vector &x) const

MaskType operator!= (const Vector &x) const

MaskType operator<= (const Vector &x) const

MaskType operator>= (const Vector &x) const

MaskType operator< (const Vector &x) const

MaskType operator> (const Vector &x) const

Horizontal Reduction Operations

Horizontal operations can be used to reduce the values of a vector to a scalar value.

Example:

void foo(const float_v &v) {
  float min = v.min(); // smallest value in v
  float sum = v.sum(); // sum of all values in v
}

EntryType min () const

Returns the smallest entry in the vector.

EntryType max () const

Returns the largest entry in the vector.

EntryType product () const

Returns the product of all entries in the vector.

EntryType sum () const

Returns the sum of all entries in the vector.

Vector partialSum () const

Returns a vector containing the sum of all entries with smaller index.

EntryType min (MaskType mask) const

Returns the smallest entry of the vector components selected by mask.

EntryType max (MaskType mask) const

Returns the largest entry of the vector components selected by mask.

EntryType product (MaskType mask) const

Returns the product of the vector components selected by mask.

EntryType sum (MaskType mask) const

Returns the sum of the vector components selected by mask.

Shift and Rotate

These functions allow to shift or rotate the entries in a vector.

All functions with an amount parameter support positive and negative numbers for the shift/rotate value.

Example:

using namespace Vc;
int_v foo = int_v::IndexesFromZero() + 1; // e.g. [1, 2, 3, 4] with SSE
int_v x;
x = foo.shifted( 1); // [2, 3, 4, 0]
x = foo.shifted( 2); // [3, 4, 0, 0]
x = foo.shifted( 3); // [4, 0, 0, 0]
x = foo.shifted( 4); // [0, 0, 0, 0]
x = foo.shifted(-1); // [0, 1, 2, 3]
x = foo.shifted(-2); // [0, 0, 1, 2]
x = foo.shifted(-3); // [0, 0, 0, 1]
x = foo.shifted(-4); // [0, 0, 0, 0]
x = foo.rotated( 1); // [2, 3, 4, 1]
x = foo.rotated( 2); // [3, 4, 1, 2]
x = foo.rotated( 3); // [4, 1, 2, 3]
x = foo.rotated( 4); // [1, 2, 3, 4]
x = foo.rotated(-1); // [4, 1, 2, 3]
x = foo.rotated(-2); // [3, 4, 1, 2]
x = foo.rotated(-3); // [2, 3, 4, 1]
x = foo.rotated(-4); // [1, 2, 3, 4]

These functions are slightly related to the above swizzles. In any case, they are often useful for communication between SIMD lanes or binary decoding operations.

Warning: Use of these functions leads to less portable code. Consider the scalar implementation where every vector has only one entry. The shift and rotate functions have no useful task to fulfil there and you will almost certainly not get any useful results. It is recommended to add a static_assert for the assumed minimum vector size.

Vector shifted (int amount) const

Shift vector entries to the left by amount; shifting in zeros.

Vector shifted (int amount, Vector shiftIn) const

Shift vector entries to the left by amount; shifting in values from shiftIn (instead of zeros). More...

Vector rotated (int amount) const

Rotate vector entries to the left by amount.

Vector reversed () const

Returns a vector with all components reversed.

Apply/Call/Fill Functions

There are still many situations where the code needs to switch from SIMD operations to scalar execution. In this case you can, of course rely on operator[]. But there are also a number of functions that can help with common patterns.

The apply functions expect a function that returns a scalar value, i.e. a function of the form "T f(T)". The call functions do not return a value and thus the function passed does not need a return value. The fill functions are used to serially set the entries of the vector from the return values of a function.

Example:

void foo(float_v v) {
  float_v logarithm = v.apply(std::log);
  float_v exponential = v.apply(std::exp);
}

Of course, you can also use lambdas here:

float_v power = v.apply([](float f) { return std::pow(f, 0.6f); })

Parameters

f	A functor: this can either be a function or an object that implements operator().

template<typename F >

void callWithValuesSorted (F &&f)

Call f sequentially, starting with the minimum up to the maximum value.

template<typename F >

void call (F &&f) const

Call f with the scalar entries of the vector.

template<typename F >

void call (F &&f, MaskType mask) const

As above, but skip the entries where mask is not set.

template<typename F >

Vector apply (F &&f) const

Call f on every entry of the vector and return the results as a new vector.

template<typename F >

Vector apply (F &&f, MaskType mask) const

As above, but skip the entries where mask is not set.

template<typename IndexT >

void fill (EntryType(&f)(IndexT))

Fill the vector with the values [f(0), f(1), f(2), ...].

void fill (EntryType(&f)())

Fill the vector with the values [f(), f(), f(), ...].

Static Public Member Functions
static constexpr size_t	size ()
	Returns the number of scalar components ( \(\mathcal{W}_\mathtt{T}\)) in a vector of this type. More...

Generators
static Vector	Zero ()
	Returns a vector with the entries initialized to zero.

static Vector	One ()
	Returns a vector with the entries initialized to one.

static Vector	IndexesFromZero ()
	Returns a vector with the entries initialized to 0, 1, 2, 3, 4, 5, ...

static Vector	Random ()
	Returns a vector with pseudo-random entries. More...

template<typename G >
static Vector	generate (G gen)
	Generate a vector object from return values of `gen` (static variant of fill).

Static Public Attributes
static constexpr size_t	MemoryAlignment = VectorTraits<T, Abi>::memoryAlignment()
	Specifies the alignment requirement for aligned load and store calls for objects of this vector type.

Deprecated Members
static constexpr size_t	Size = VectorTraits<T, Abi>::size()
	Returns the number of scalar components ( \(\mathcal{W}_\mathtt{T}\)) in a vector of this type. More...

Vector	exponent () const
	Returns the exponents of the floating-point values in the vector.

MaskType	isNegative () const

template<typename V2 >
V2	staticCast () const
	Casts the current object to `V2`. More...

Vector	copySign (Vector reference) const
	Copies the signs of the components of `reference` to the components of the current vector, returning the result. More...

Member Typedef Documentation

using value_type = EntryType

The type of the entries in the vector.

Definition at line 155 of file vector.h.

using mask_type = MaskType

The type of the mask used for masked operations and returned from comparisons.

Definition at line 170 of file vector.h.

using index_type = IndexType

The type of the vector used for indexes in gather and scatter operations.

Definition at line 178 of file vector.h.

Constructor & Destructor Documentation

Vector ( )

inlinedefault

Construct a zero-initialized vector object.

This constructor follows the behavior of the underlying arithmetic type T in that the expression T() zero-initializes the object. On the other hand the variable x in T x; is uninitialized. Since, for class types, both expressions call the default constructor Vector<T> x must zero-initialize x as well.

Vector ( VectorSpecialInitializerZero )

inlineexplicit

Construct a vector with the entries initialized to zero.

See also: Vc::Zero, Zero()

Vector ( VectorSpecialInitializerOne )

inlineexplicit

Construct a vector with the entries initialized to one.

See also: Vc::One, One()

Vector ( VectorSpecialInitializerIndexesFromZero )

inlineexplicit

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

See also: Vc::IndexesFromZero, IndexesFromZero()

Vector	(	Vector< U, abi >	x,
		enable_if<!Traits::is_implicit_cast_allowed< U, T >::value >	= `nullarg`
	)

inlineexplicit

Explicit conversion (i.e.

static_cast) from the remaining Vector<U, Abi> types.

Parameters

x A vector object to use for initialization of the new vector object. If x contains more entries than the new object the high components will be ignored. If x contains fewer entries than the new object the high components of the new object will be zero-initialized. Type conversion is done according to the standard conversion rules for the underlying fundamental arithmetic types.

Vector ( EntryType a )

inline

Broadcast Constructor.

Constructs a vector with all entries of the vector filled with the given value.

Parameters

a	The scalar value to broadcast to all entries of the constructed vector.

Note: If you want to set it to 0 or 1 use the special initializer constructors above. Calling this constructor with 0 will cause a compilation error because the compiler cannot know which constructor you meant.

Vector ( const EntryType * mem )

inlineexplicit

Construct a vector from loading its entries from the array at mem.

Parameters

mem	A pointer to data. The pointer must not be aligned on a MemoryAlignment boundary unless you add the Vc::Aligned flag as a second argument.

Definition at line 38 of file vector.h.

Vector	(	const EntryType *	mem,
		Flags	flags
	)

inlineexplicit

Construct a vector from loading its entries from the array at mem.

Parameters

mem	A pointer to data. If `flags` contains the Vc::Aligned flag, the pointer must be aligned on a MemoryAlignment boundary.
flags	A (combination of) flag object(s), such as Vc::Aligned, Vc::Streaming, Vc::Unaligned, and/or Vc::PrefetchDefault.

Definition at line 51 of file vector.h.

Vector	(	const S1 *	array,
		const EntryType S1::*	member1,
		const IT	indexes
	)

inline

Deprecated:: Use Vc::array or Vc::vector subscripting instead.

Definition at line 222 of file vector.h.

Vector	(	const S1 *	array,
		const EntryType S1::*	member1,
		const IT	indexes,
		MaskArgument	mask
	)

inline

Deprecated:: Use Vc::array or Vc::vector subscripting instead.

Definition at line 232 of file vector.h.

Vector	(	const S1 *	array,
		const S2 S1::*	member1,
		const EntryType S2::*	member2,
		const IT	indexes
	)

inline

Deprecated:: Use Vc::array or Vc::vector subscripting instead.

Definition at line 243 of file vector.h.

Vector	(	const S1 *	array,
		const S2 S1::*	member1,
		const EntryType S2::*	member2,
		const IT	indexes,
		MaskArgument	mask
	)

inline

Deprecated:: Use Vc::array or Vc::vector subscripting instead.

Definition at line 254 of file vector.h.

Vector	(	const S1 *	array,
		const EntryType const S1::	ptrMember1,
		const IT1	outerIndexes,
		const IT2	innerIndexes
	)

inline

Deprecated:: Use Vc::array or Vc::vector subscripting instead.

Definition at line 266 of file vector.h.

Vector	(	const S1 *	array,
		const EntryType const S1::	ptrMember1,
		const IT1	outerIndexes,
		const IT2	innerIndexes,
		MaskArgument	mask
	)

inline

Deprecated:: Use Vc::array or Vc::vector subscripting instead.

Definition at line 277 of file vector.h.

Member Function Documentation

static constexpr size_t size ( )

inlinestatic

Returns the number of scalar components ( \(\mathcal{W}_\mathtt{T}\)) in a vector of this type.

The size of the vector. I.e. the number of scalar entries in the vector. Do not make any assumptions about the size of vectors. If you need a vector of float vs. integer of the same size make use of IndexType instead. Note that this still does not guarantee the same size (e.g. double_v on SSE has two entries but there exists no 64 bit integer vector type in Vc - which would have two entries; thus double_v::IndexType is uint_v).

In addition, you can easily use if clauses that compare sizes. The compiler can statically evaluate and fully optimize dead code away (very much like #ifdef, but with syntax checking).

Returns: The number of components (i.e. \(\mathcal{W}_\mathtt{T}\)) objects of this vector type store and manipulate.

Definition at line 141 of file vector.h.

static Vector Random ( )

inlinestatic

Returns a vector with pseudo-random entries.

Currently the state of the random number generator cannot be modified and starts off with the same state. Thus you will get the same sequence of numbers for the same sequence of calls.

Returns: a new random vector. Floating-point values will be in the 0-1 range. Integers will use the full range the integer representation allows.

Note: This function may use a very small amount of state and thus will be a weak random number generator.

void load ( const EntryType * mem )

inline

Load the vector entries from mem, overwriting the previous values.

Parameters

mem	A pointer to data. The pointer must not be aligned on a MemoryAlignment boundary unless you add the Vc::Aligned flag as a second argument.

Definition at line 74 of file vector.h.

void load	(	const EntryType *	mem,
		Flags	flags
	)

inline

Load the vector entries from mem, overwriting the previous values.

Parameters

mem	A pointer to data. If `flags` contains the Vc::Aligned flag, the pointer must be aligned on a MemoryAlignment boundary.
flags	A (combination of) flag object(s), such as Vc::Aligned, Vc::Streaming, Vc::Unaligned, and/or Vc::PrefetchDefault.

Definition at line 89 of file vector.h.

void store	(	U *	mem,
		Flags	flags = `Flags()`
	)		const

inline

Store the vector data to mem.

Parameters

mem	A pointer to memory, where \(\mathcal{W}_\mathtt{T}\) consecutive values will be stored.
flags	The flags parameter can be used to select e.g. the Vc::Aligned, Vc::Unaligned, Vc::Streaming, and/or Vc::PrefetchDefault flags.

void store	(	U *	mem,
		MaskType	mask,
		Flags	flags = `Flags()`
	)		const

inline

Store the vector data to mem where mask is set.

Parameters

mem	A pointer to memory, where \(\mathcal{W}_\mathtt{T}\) consecutive values will be stored.
mask	A mask object that determines which entries of the vector should be stored to `mem`.
flags	The flags parameter can be used to select e.g. the Vc::Aligned, Vc::Unaligned, Vc::Streaming, and/or Vc::PrefetchDefault flags.

Note: The masked store does not pack the values into memory. I.e. the value at offset i will be stored to mem[i], independent of whether mask[j] for any j < i is false.

void setZero ( MaskType mask )

inline

Set all entries to zero where the mask is set.

A 4-vector with a mask of [0111] therefore would set the last three entries to 0.

Parameters

mask	Selects the entries to be set to zero.

void setZeroInverted ( MaskType mask )

inline

Set all entries to zero where the mask is not set.

A 4-vector with a mask of [0111] therefore would set only the first entry to 0.

Parameters

mask	Selects the entries to not be set to zero.

void setQnan ( MaskType mask )

inline

Set all entries to the bit representation of a QNaN where the mask is set.

Parameters

mask	Selects the entries to be set to QNaN.

void gather	(	const S1 *	array,
		const EntryType S1::*	member1,
		const IT	indexes
	)

inline

Deprecated:: Use Vc::array or Vc::vector subscripting instead.

Definition at line 289 of file vector.h.

void gather	(	const S1 *	array,
		const EntryType S1::*	member1,
		const IT	indexes,
		MaskArgument	mask
	)

inline

Deprecated:: Use Vc::array or Vc::vector subscripting instead.

Definition at line 300 of file vector.h.

void gather	(	const S1 *	array,
		const S2 S1::*	member1,
		const EntryType S2::*	member2,
		const IT	indexes
	)

inline

Deprecated:: Use Vc::array or Vc::vector subscripting instead.

Definition at line 313 of file vector.h.

void gather	(	const S1 *	array,
		const S2 S1::*	member1,
		const EntryType S2::*	member2,
		const IT	indexes,
		MaskArgument	mask
	)

inline

Deprecated:: Use Vc::array or Vc::vector subscripting instead.

Definition at line 324 of file vector.h.

void gather	(	const S1 *	array,
		const EntryType const S1::	ptrMember1,
		const IT1	outerIndexes,
		const IT2	innerIndexes
	)

inline

Deprecated:: Use Vc::array or Vc::vector subscripting instead.

Definition at line 337 of file vector.h.

void gather	(	const S1 *	array,
		const EntryType const S1::	ptrMember1,
		const IT1	outerIndexes,
		const IT2	innerIndexes,
		MaskArgument	mask
	)

inline

Deprecated:: Use Vc::array or Vc::vector subscripting instead.

Definition at line 349 of file vector.h.

void scatter	(	S1 *	array,
		EntryType S1::*	member1,
		const IT	indexes
	)		const

inline

Deprecated:: Use Vc::array or Vc::vector subscripting instead.

Definition at line 119 of file vector.h.

void scatter	(	S1 *	array,
		EntryType S1::*	member1,
		const IT	indexes,
		MaskArgument	mask
	)		const

inline

Deprecated:: Use Vc::array or Vc::vector subscripting instead.

Definition at line 129 of file vector.h.

void scatter	(	S1 *	array,
		S2 S1::*	member1,
		EntryType S2::*	member2,
		const IT	indexes
	)		const

inline

Deprecated:: Use Vc::array or Vc::vector subscripting instead.

Definition at line 141 of file vector.h.

void scatter	(	S1 *	array,
		S2 S1::*	member1,
		EntryType S2::*	member2,
		const IT	indexes,
		MaskArgument	mask
	)		const

inline

Deprecated:: Use Vc::array or Vc::vector subscripting instead.

Definition at line 152 of file vector.h.

void scatter	(	S1 *	array,
		EntryType S1::	ptrMember1,
		const IT1	outerIndexes,
		const IT2	innerIndexes
	)		const

inline

Deprecated:: Use Vc::array or Vc::vector subscripting instead.

Definition at line 165 of file vector.h.

void scatter	(	S1 *	array,
		EntryType S1::	ptrMember1,
		const IT1	outerIndexes,
		const IT2	innerIndexes,
		MaskArgument	mask
	)		const

inline

Deprecated:: Use Vc::array or Vc::vector subscripting instead.

Definition at line 177 of file vector.h.

EntryType& operator[] ( size_t index )

inline

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

Parameters

index A value between 0 and Size. This value is not checked internally so you must make/be sure it is in range.

Returns: a reference to the vector entry at the given index.

Warning: The use of this function may result in suboptimal performance. Please check whether you can find a more vector-friendly way to do what you intended.

EntryType operator[] ( size_t index ) const

inline

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

Parameters

index A value between 0 and Size. This value is not checked internally so you must make/be sure it is in range.

Returns: a copy of the vector entry at the given index.

MaskType operator! ( ) const

inline

Determine where the vector is null.

Returns: a mask which denotes the zero entries of this vector object.

Vector operator~ ( ) const

inline

Inverts all bits.

Returns: a new vector which has all bits inverted. I.e. v & ~v == 0.

Note: This operator is only defined for integral types T.

Common::WriteMaskedVector<Vector, MaskType> operator() ( MaskType mask )

inline

Writemask the vector before an assignment.

Parameters

mask	The writemask to be used.

Returns: an object that can be used for any kind of masked assignment.

The returned object is only to be used for assignments and should not be assigned to a variable.

Examples:

float_v v = float_v::Zero();         // v  = [0, 0, 0, 0]
int_v v2 = int_v::IndexesFromZero(); // v2 = [0, 1, 2, 3]
v(v2 < 2) = 1.f;                     // v  = [1, 1, 0, 0]
v(v2 < 3) += 1.f;                    // v  = [2, 2, 1, 0]
++v2(v < 1.f);                       // v2 = [0, 1, 2, 4]

Vector shifted	(	int	amount,
		Vector< T, Abi >	shiftIn
	)		const

inline

Shift vector entries to the left by amount; shifting in values from shiftIn (instead of zeros).

This function can be used to create vectors from unaligned memory locations.

Example:

Vc::Memory<int_v, 256> mem;
for (int i = 0; i < 256; ++i) { mem[i] = i + 1; }
int_v a = mem.vectorAt(0);
int_v b = mem.vectorAt(int_v::Size);
int_v x = a.shifted(1, b);
// now x == mem.vectorAt(1, Vc::Unaligned)

Parameters

amount	The number of entries to shift by. `amount` must be between `-Size` and `Size`, otherwise the result is undefined.
shiftIn	The vector of values to shift in.

Returns: A new vector with values from this and shiftIn concatenated and then shifted by amount.

Vector sorted ( ) const

inline

Return a sorted copy of the vector.

Returns

a sorted vector. The returned values are in ascending order:

v[0] <= v[1] <= v[2] <= v[3] ...

Note: If the vector contains NaNs the result is undefined.

Example:

int_v v = int_v::Random();
int_v s = v.sorted();
std::cout << v << '\n' << s << '\n';

With SSE the output would be:

[1513634383, -963914658, 1763536262, -1285037745]
[-1285037745, -963914658, 1513634383, 1763536262]

With the Scalar implementation:

[1513634383]
[1513634383]

MaskType isNegative ( ) const

inline

Deprecated:: use Vc::isnegative instead

V2 staticCast ( ) const

inline

Casts the current object to V2.

Returns: a converted object of type Vc.

Deprecated:: Use Vc::simd_cast instead.

Vector copySign ( Vector< T, Abi > reference ) const

inline

Copies the signs of the components of reference to the components of the current vector, returning the result.

Parameters

reference A vector object that determines the sign of the the result.

Returns: A new vector with sign taken from reference and absolute value taken from the current vector object.

Deprecated:: Use Vc::copysign instead.

Member Data Documentation

constexpr size_t Size = VectorTraits<T, Abi>::size()

static

Returns the number of scalar components ( \(\mathcal{W}_\mathtt{T}\)) in a vector of this type.

The size of the vector. I.e. the number of scalar entries in the vector. Do not make any assumptions about the size of vectors. If you need a vector of float vs. integer of the same size make use of IndexType instead. Note that this still does not guarantee the same size (e.g. double_v on SSE has two entries but there exists no 64 bit integer vector type in Vc - which would have two entries; thus double_v::IndexType is uint_v).

In addition, you can easily use if clauses that compare sizes. The compiler can statically evaluate and fully optimize dead code away (very much like #ifdef, but with syntax checking).

Returns: The number of components (i.e. \(\mathcal{W}_\mathtt{T}\)) objects of this vector type store and manipulate.

Deprecated:: Use Vc::Vector::size instead.

Definition at line 754 of file vector.h.

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

/u/mkretz/src/Vc/common/types.h
/u/mkretz/src/Vc/common/vector.h

Detailed Description

template<typename T, typename Abi = VectorAbi::Best<T>> class Vc::Vector< T, Abi >

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Deprecated Members

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

template<typename T, typename Abi = VectorAbi::Best<T>>
class Vc::Vector< T, Abi >