29 Numerics library [numerics]

29.10 Data-parallel types [simd]

29.10.2 Exposition-only types, variables, and concepts [simd.expos]

29.10.2.1 Exposition-only helpers [simd.expos.defn]

using simd-size-type = see below;

simd-size-type is an alias for a signed integer type.

🔗

template<size_t Bytes> using integer-from = see below;

integer-from<Bytes> is an alias for a signed integer type T such that sizeof(T) equals Bytes.

🔗

template<class T, class Abi>
  constexpr simd-size-type simd-size-v = see below;

simd-size-v<T, Abi> denotes the width of basic_simd<T, Abi> if the specialization basic_simd<T, Abi> is enabled, or 0 otherwise.

🔗

template<class T> constexpr size_t mask-element-size = see below;

mask-element-size<basic_simd_mask<Bytes, Abi>> has the value Bytes.

🔗

template<class T> using deduced-simd-t = see below;

Let x denote an lvalue of type const T.

deduced-simd-t<T> is an alias for

(6.1)
decltype(x + x), if the type of x + x is an enabled specialization of basic_simd; otherwise
(6.2)
void.

🔗

template<class V, class T> using make-compatible-simd-t = see below;

Let x denote an lvalue of type const T.

make-compatible-simd-t<V, T> is an alias for

(8.1)
deduced-simd-t<T>, if that type is not void, otherwise
(8.2)
simd<decltype(x + x), V::size()>.

🔗

template<class... Ts>
  requires math-floating-point<Ts...>
    using math-common-simd-t = see below;

Let T0 denote Ts...[0].

Let T1 denote Ts...[1].

Let TRest denote a pack such that T0, T1, TRest... is equivalent to Ts....

Let math-common-simd-t<Ts...> be an alias for

(10.1)
deduced-simd-t<T0>, if sizeof...(Ts) equals 1; otherwise
(10.2)
common_type_t<deduced-simd-t<T0>, deduced-simd-t<T1>>, if sizeof...(Ts) equals 2 and math-floating-point<T0> && math-floating-point<T1> is true; otherwise
(10.3)
common_type_t<deduced-simd-t<T0>, T1>, if sizeof...(Ts) equals 2 and math-floating-point<T0> is true; otherwise
(10.4)
common_type_t<T0, deduced-simd-t<T1>>, if sizeof...(Ts) equals 2; otherwise
(10.5)
common_type_t<math-common-simd-t<T0, T1>, TRest...>, if math-common-simd-t<T0, T1> is valid and denotes a type; otherwise
(10.6)
common_type_t<math-common-simd-t<TRest...>, T0, T1>.

🔗

template<class BinaryOperation, class T>
  concept reduction-binary-operation =
    requires (const BinaryOperation binary_op, const simd<T, 1> v) {
      { binary_op(v, v) } -> same_as<simd<T, 1>>;
    };

Types BinaryOperation and T model reduction-binary-operation<BinaryOperation, T> only if:

(11.1)
BinaryOperation is a binary element-wise operation and the operation is commutative.
(11.2)
An object of type BinaryOperation can be invoked with two arguments of type basic_simd<T, Abi>, with unspecified ABI tag Abi, returning a basic_simd<T, Abi>.