This set of class templates and associated functions and operators enables data-parallel algorithms and data structures requiring a user-defined number of elements (fixed at compile time, in contrast to std::valarray
where the number of elements is only determined at run time). The main motivation for a user-defined number of elements is the need for type conversion and thus a guaranteed equal number of elements in data-parallel vectors for e.g. float
and int
. A typical pattern looks like this:
The second motivation for a user-defined number of elements is that many vertical vectorizations require a fixed number of elements (i.e. number known at development time and not chosen at compile time). The implementation can then choose how to support this number most efficiently with the available hardware resources. Consider, for example, a need for processing 12 values in parallel. On x86 with AVX, the implementation could build such a type from one AVX and one SSE register.
In contrast to std::array
the types behave like the Vc::Vector types, implementing the same operators and functions. The semantics with regard to implicit conversions differ slightly: The Vc::Vector conversion rules are safer with regard to source compatibility. The Vc::SimdArray conversion rules are less strict and could potentially lead to portability issues. Therefore, it is best to stick to the pattern of type aliases shown above.
Classes | |
class | SimdArray< T, N, V, Wt > |
Data-parallel arithmetic type with user-defined number of elements. More... | |
class | SimdMaskArray< T, N, V, Wt > |
Data-parallel mask type with user-defined number of boolean elements. More... |
Arithmetic and Bitwise Operators | |
Applies the operator component-wise and concurrently on This operator only participates in overload resolution if:
The return type of the operator is a SimdArray type using the more precise EntryType of | |
template<typename L, typename R> | |
result_vector_type< L, R > | operator+ (L &&lhs, R &&rhs) |
Applies + component-wise and concurrently. | |
template<typename L, typename R> | |
result_vector_type< L, R > | operator- (L &&lhs, R &&rhs) |
Applies - component-wise and concurrently. | |
template<typename L, typename R> | |
result_vector_type< L, R > | operator* (L &&lhs, R &&rhs) |
Applies * component-wise and concurrently. | |
template<typename L, typename R> | |
result_vector_type< L, R > | operator/ (L &&lhs, R &&rhs) |
Applies / component-wise and concurrently. | |
template<typename L, typename R> | |
result_vector_type< L, R > | operator% (L &&lhs, R &&rhs) |
Applies % component-wise and concurrently. | |
template<typename L, typename R> | |
result_vector_type< L, R > | operator| (L &&lhs, R &&rhs) |
Applies | component-wise and concurrently. | |
template<typename L, typename R> | |
result_vector_type< L, R > | operator& (L &&lhs, R &&rhs) |
Applies & component-wise and concurrently. | |
template<typename L, typename R> | |
result_vector_type< L, R > | operator^ (L &&lhs, R &&rhs) |
Applies ^ component-wise and concurrently. |
Compare Operators | |
Applies the operator component-wise and concurrently on This operator only participates in overload resolution if (same rules as above):
The return type of the operator is a SimdMaskArray type using the more precise EntryType of | |
template<typename L, typename R> | |
result_vector_type< L, R >::mask_type | operator== (L &&lhs, R &&rhs) |
Applies == component-wise and concurrently. | |
template<typename L, typename R> | |
result_vector_type< L, R >::mask_type | operator!= (L &&lhs, R &&rhs) |
Applies != component-wise and concurrently. | |
template<typename L, typename R> | |
result_vector_type< L, R >::mask_type | operator<= (L &&lhs, R &&rhs) |
Applies <= component-wise and concurrently. | |
template<typename L, typename R> | |
result_vector_type< L, R >::mask_type | operator>= (L &&lhs, R &&rhs) |
Applies >= component-wise and concurrently. | |
template<typename L, typename R> | |
result_vector_type< L, R >::mask_type | operator< (L &&lhs, R &&rhs) |
Applies < component-wise and concurrently. | |
template<typename L, typename R> | |
result_vector_type< L, R >::mask_type | operator> (L &&lhs, R &&rhs) |
Applies > component-wise and concurrently. |
Math functions | |
These functions evaluate the | |
template<typename T, std::size_t N, typename V, std::size_t M> | |
fixed_size_simd< T, N > | abs (const SimdArray< T, N, V, M > &x) |
Applies the std::abs function component-wise and concurrently. | |
template<typename T, std::size_t N, typename V, std::size_t M> | |
fixed_size_simd< T, N > | asin (const SimdArray< T, N, V, M > &x) |
Applies the std::asin function component-wise and concurrently. | |
template<typename T, std::size_t N, typename V, std::size_t M> | |
fixed_size_simd< T, N > | atan (const SimdArray< T, N, V, M > &x) |
Applies the std::atan function component-wise and concurrently. | |
template<typename T, std::size_t N, typename V, std::size_t M> | |
fixed_size_simd< T, N > | atan2 (const SimdArray< T, N, V, M > &x, const SimdArray< T, N, V, M > &y) |
Applies the std::atan2 function component-wise and concurrently. | |
template<typename T, std::size_t N, typename V, std::size_t M> | |
fixed_size_simd< T, N > | ceil (const SimdArray< T, N, V, M > &x) |
Applies the std::ceil function component-wise and concurrently. | |
template<typename T, std::size_t N, typename V, std::size_t M> | |
fixed_size_simd< T, N > | copysign (const SimdArray< T, N, V, M > &x, const SimdArray< T, N, V, M > &y) |
Applies the std::copysign function component-wise and concurrently. | |
template<typename T, std::size_t N, typename V, std::size_t M> | |
fixed_size_simd< T, N > | cos (const SimdArray< T, N, V, M > &x) |
Applies the std::cos function component-wise and concurrently. | |
template<typename T, std::size_t N, typename V, std::size_t M> | |
fixed_size_simd< T, N > | exp (const SimdArray< T, N, V, M > &x) |
Applies the std::exp function component-wise and concurrently. | |
template<typename T, std::size_t N, typename V, std::size_t M> | |
fixed_size_simd< T, N > | exponent (const SimdArray< T, N, V, M > &x) |
Applies the std::exponent function component-wise and concurrently. | |
template<typename T, std::size_t N, typename V, std::size_t M> | |
fixed_size_simd< T, N > | floor (const SimdArray< T, N, V, M > &x) |
Applies the std::floor function component-wise and concurrently. | |
template<typename T, std::size_t N> | |
SimdArray< T, N > | fma (const SimdArray< T, N > &a, const SimdArray< T, N > &b, const SimdArray< T, N > &c) |
Applies the std::fma function component-wise and concurrently. | |
template<typename T, std::size_t N, typename V, std::size_t M> | |
fixed_size_simd_mask< T, N > | isfinite (const SimdArray< T, N, V, M > &x) |
Applies the std::isfinite function component-wise and concurrently. | |
template<typename T, std::size_t N, typename V, std::size_t M> | |
fixed_size_simd_mask< T, N > | isinf (const SimdArray< T, N, V, M > &x) |
Applies the std::isinf function component-wise and concurrently. | |
template<typename T, std::size_t N, typename V, std::size_t M> | |
fixed_size_simd_mask< T, N > | isnan (const SimdArray< T, N, V, M > &x) |
Applies the std::isnan function component-wise and concurrently. | |
template<typename T, std::size_t N, typename V, std::size_t M> | |
fixed_size_simd_mask< T, N > | isnegative (const SimdArray< T, N, V, M > &x) |
Applies the std::isnegative function component-wise and concurrently. | |
template<typename T, std::size_t N> | |
SimdArray< T, N > | frexp (const SimdArray< T, N > &x, SimdArray< int, N > *e) |
Applies the std::frexp function component-wise and concurrently. | |
template<typename T, std::size_t N> | |
SimdArray< T, N > | ldexp (const SimdArray< T, N > &x, const SimdArray< int, N > &e) |
Applies the std::ldexp function component-wise and concurrently. | |
template<typename T, std::size_t N, typename V, std::size_t M> | |
fixed_size_simd< T, N > | log (const SimdArray< T, N, V, M > &x) |
Applies the std::log function component-wise and concurrently. | |
template<typename T, std::size_t N, typename V, std::size_t M> | |
fixed_size_simd< T, N > | log10 (const SimdArray< T, N, V, M > &x) |
Applies the std::log10 function component-wise and concurrently. | |
template<typename T, std::size_t N, typename V, std::size_t M> | |
fixed_size_simd< T, N > | log2 (const SimdArray< T, N, V, M > &x) |
Applies the std::log2 function component-wise and concurrently. | |
template<typename T, std::size_t N, typename V, std::size_t M> | |
fixed_size_simd< T, N > | reciprocal (const SimdArray< T, N, V, M > &x) |
Applies the std::reciprocal function component-wise and concurrently. | |
template<typename T, std::size_t N, typename V, std::size_t M> | |
fixed_size_simd< T, N > | round (const SimdArray< T, N, V, M > &x) |
Applies the std::round function component-wise and concurrently. | |
template<typename T, std::size_t N, typename V, std::size_t M> | |
fixed_size_simd< T, N > | rsqrt (const SimdArray< T, N, V, M > &x) |
Applies the std::rsqrt function component-wise and concurrently. | |
template<typename T, std::size_t N, typename V, std::size_t M> | |
fixed_size_simd< T, N > | sin (const SimdArray< T, N, V, M > &x) |
Applies the std::sin function component-wise and concurrently. | |
template<typename T, std::size_t N> | |
void | sincos (const SimdArray< T, N > &x, SimdArray< T, N > *sin, SimdArray< T, N > *cos) |
Determines sine and cosine concurrently and component-wise on x . | |
template<typename T, std::size_t N, typename V, std::size_t M> | |
fixed_size_simd< T, N > | sqrt (const SimdArray< T, N, V, M > &x) |
Applies the std::sqrt function component-wise and concurrently. | |
template<typename T, std::size_t N, typename V, std::size_t M> | |
fixed_size_simd< T, N > | trunc (const SimdArray< T, N, V, M > &x) |
Applies the std::trunc function component-wise and concurrently. | |
template<typename T, std::size_t N, typename V, std::size_t M> | |
fixed_size_simd< T, N > | min (const SimdArray< T, N, V, M > &x, const SimdArray< T, N, V, M > &y) |
Applies the std::min function component-wise and concurrently. | |
template<typename T, std::size_t N, typename V, std::size_t M> | |
fixed_size_simd< T, N > | max (const SimdArray< T, N, V, M > &x, const SimdArray< T, N, V, M > &y) |
Applies the std::max function component-wise and concurrently. |