#
Subclause [simd] defines data-parallel types and operations on these types.
[Note 1: 
The intent is to support acceleration through data-parallel execution resources where available, such as SIMD registers and instructions or execution units driven by a common instruction decoder.
SIMD stands for “Single Instruction Stream – Multiple Data Stream”; it is defined in Flynn 1966[bib].
— end note]
2
#
The set of vectorizable types comprises
  • (2.1)
    all standard integer types, character types, and the types float and double ([basic.fundamental]);
  • (2.2)
    std​::​float16_t, std​::​float32_t, and std​::​float64_t if defined ([basic.extended.fp]); and
  • (2.3)
    complex<T> where T is a vectorizable floating-point type.
3
#
The term data-parallel type refers to all enabled specializations of the basic_vec and basic_mask class templates.
A data-parallel object is an object of data-parallel type.
4
#
Each specialization of basic_vec or basic_mask is either enabled or disabled, as described in [simd.overview] and [simd.mask.overview].
5
#
A data-parallel type consists of one or more elements of an underlying vectorizable type, called the element type.
The number of elements is a constant for each data-parallel type and called the width of that type.
The elements in a data-parallel type are indexed from 0 to
6
#
An element-wise operation applies a specified operation to the elements of one or more data-parallel objects.
Each such application is unsequenced with respect to the others.
A unary element-wise operation is an element-wise operation that applies a unary operation to each element of a data-parallel object.
A binary element-wise operation is an element-wise operation that applies a binary operation to corresponding elements of two data-parallel objects.
7
#
Given a basic_mask<Bytes, Abi> object mask, the selected indices signify the integers i in the range [0, mask.size()) for which mask[i] is true.
Given a data-parallel object data, the selected elements signify the elements data[i] for all selected indices i.
8
#
The conversion from an arithmetic type U to a vectorizable type T is value-preserving if all possible values of U can be represented with type T.

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

using simd-size-type = see below; / exposition only template<size_t Bytes> using integer-from = see below; / exposition only template<class T, class Abi> constexpr simd-size-type simd-size-v = see below; / exposition only template<class T> constexpr size_t mask-element-size = see below; / exposition only template<class T> concept constexpr-wrapper-like = / exposition only convertible_to<T, decltype(T::value)> && equality_comparable_with<T, decltype(T::value)> && bool_constant<T() == T::value>::value && bool_constant<static_cast<decltype(T::value)>(T() == T::value>::value; template<class From, class To> concept explicitly-convertible-to = / exposition only requires { static_cast<To>(declval<From>(); }; template<class T> using deduced-vec-t = see below; / exposition only template<class V, class T> using make-compatible-simd-t = see below; / exposition only template<class V> concept simd-vec-type = / exposition only same_as<V, basic_vec<typename V::value_type, typename V::abi_type>> && is_default_constructible_v<V>; template<class V> concept simd-mask-type = / exposition only same_as<V, basic_mask<mask-element-size<V>, typename V::abi_type>> && is_default_constructible_v<V>; template<class V> concept simd-floating-point = / exposition only simd-vec-type<V> && floating_point<typename V::value_type>; template<class V> concept simd-integral = / exposition only simd-vec-type<V> && integral<typename V::value_type>; template<class V> using simd-complex-value-type = V::value_type::value_type; / exposition only template<class V> concept simd-complex = / exposition only simd-vec-type<V> && same_as<typename V::value_type, complex<simd-complex-value-type<V>>; template<class. Ts> concept math-floating-point = / exposition only (simd-floating-point<deduced-vec-t<Ts>> || ..); template<class. Ts> requires math-floating-point<Ts..> using math-common-simd-t = see below; / exposition only template<class BinaryOperation, class T> concept reduction-binary-operation = see below; / exposition only / [simd.expos.abi], simd ABI tags template<class T> using native-abi = see below; / exposition only template<class T, simd-size-type N> using deduce-abi-t = see below; / exposition only / [simd.flags], load and store flags struct convert-flag; / exposition only struct aligned-flag; / exposition only template<size_t N> struct overaligned-flag; / exposition only

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

🔗
using simd-size-type = see below;
1
#
simd-size-type is an alias for a signed integer type.
🔗
template<size_t Bytes> using integer-from = see below;
2
#
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;
3
#
simd-size-v<T, Abi> denotes the width of basic_vec<T, Abi> if the specialization basic_vec<T, Abi> is enabled, or 0 otherwise.
🔗
template<class T> constexpr size_t mask-element-size = see below;
4
#
mask-element-size<basic_mask<Bytes, Abi>> has the value Bytes.
🔗
template<class T> using deduced-vec-t = see below;
5
#
deduced-vec-t<T> is an alias for
  • (6.1)
    decltype(x + x), if the type of x + x is an enabled specialization of basic_vec; otherwise
  • (6.2)
    void.
🔗
template<class V, class T> using make-compatible-simd-t = see below;
7
#
make-compatible-simd-t<V, T> is an alias for
  • (8.1)
    deduced-vec-t<T>, if that type is not void, otherwise
  • (8.2)
    vec<decltype(x + x), V​::​size()>.
🔗
template<class. Ts> requires math-floating-point<Ts..> using math-common-simd-t = see below;
9
#
Let T0 denote Ts..[0].
Let T1 denote Ts..[1].
Let TRest denote a pack such that T0, T1, TRest.. is equivalent to Ts...
10
#
Let math-common-simd-t<Ts..> be an alias for
  • (10.1)
    deduced-vec-t<T0>, if sizeof.(Ts) equals 1; otherwise
  • (10.2)
    common_type_t<deduced-vec-t<T0>, deduced-vec-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-vec-t<T0>, T1>, if sizeof.(Ts) equals 2 and math-floating-​point<​T0> is true; otherwise
  • (10.4)
    common_type_t<T0, deduced-vec-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 vec<T, 1> v) { { binary_op(v, v) } -> same_as<vec<T, 1>; };
11
#
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_vec<T, Abi>, with unspecified ABI tag Abi, returning a basic_vec<T, Abi>.
🔗
template<class T> using native-abi = see below; template<class T, simd-size-type N> using deduce-abi-t = see below;
1
#
An ABI tag is a type that indicates a choice of size and binary representation for objects of data-parallel type.
[Note 1: 
The intent is for the size and binary representation to depend on the target architecture and compiler flags.
The ABI tag, together with a given element type, implies the width.
— end note]
2
#
[Note 2: 
The ABI tag is orthogonal to selecting the machine instruction set.
The selected machine instruction set limits the usable ABI tag types, though (see [simd.overview]).
The ABI tags enable users to safely pass objects of data-parallel type between translation unit boundaries (e.g., function calls or I/O).
— end note]
3
#
deduce-abi-t<T, N> is defined if
  • (4.1)
    T is a vectorizable type,
  • (4.2)
    N is greater than zero, and
  • (4.3)
    N is not larger than an implementation-defined maximum.
The implementation-defined maximum for N is not smaller than 64 and can differ depending on T.
5
#
Where present, deduce-abi-t<T, N> names an ABI tag type such that
  • (5.1)
    simd-size-v<T, deduce-abi-t<T, N>> equals N,
  • (5.2)
    basic_vec<T, deduce-abi-t<T, N>> is enabled ([simd.overview]), and
  • (5.3)
    basic_mask<sizeof(T), deduce-abi-t<integer-from<sizeof(T)>, N>> is enabled.
6
#
native-abi<T> is an implementation-defined alias for an ABI tag.
basic_vec<T, native-abi<T>> is an enabled specialization.
[Note 3: 
The intent is to use the ABI tag producing the most efficient data-parallel execution for the element type T on the currently targeted system.
For target architectures with ISA extensions, compiler flags can change the type of the native-abi<T> alias.
— end note]
[Example 1: 
Consider a target architecture supporting the ABI tags __simd128 and __simd256, where hardware support for __simd256 exists only for floating-point types.
The implementation therefore defines native-abi<T> as an alias for
  • (6.1)
    __simd256 if T is a floating-point type, and
  • (6.2)
    __simd128 otherwise.
— end example]

29.10.3 Header <simd> synopsis [simd.syn]

🔗
namespace std::simd { / [simd.traits], type traits template<class T, class U = typename T::value_type> struct alignment; template<class T, class U = typename T::value_type> constexpr size_t alignment_v = alignment<T, U>::value; template<class T, class V> struct rebind { using type = see below; }; template<class T, class V> using rebind_t = rebind<T, V>::type; template<simd-size-type N, class V> struct resize { using type = see below; }; template<simd-size-type N, class V> using resize_t = resize<N, V>::type; / [simd.flags], load and store flags template<class. Flags> struct flags; inline constexpr flags<> flag_default{}; inline constexpr flags<convert-flag> flag_convert{}; inline constexpr flags<aligned-flag> flag_aligned{}; template<size_t N> requires (has_single_bit(N)) constexpr flags<overaligned-flag<N>> flag_overaligned{}; / [simd.iterator], class template simd-iterator template<class V> class simd-iterator; / exposition only / [simd.class], class template basic_vec template<class T, class Abi = native-abi<T>> class basic_vec; template<class T, simd-size-type N = simd-size-v<T, native-abi<T>> using vec = basic_vec<T, deduce-abi-t<T, N>>; / [simd.reductions], reductions template<class T, class Abi, class BinaryOperation = plus<> constexpr T reduce(const basic_vec<T, Abi>&, BinaryOperation = {}); template<class T, class Abi, class BinaryOperation = plus<> constexpr T reduce( const basic_vec<T, Abi>& x, const typename basic_vec<T, Abi>::mask_type& mask, BinaryOperation binary_op = {}, type_identity_t<T> identity_element = see below); template<class T, class Abi> constexpr T reduce_min(const basic_vec<T, Abi>&) noexcept; template<class T, class Abi> constexpr T reduce_min(const basic_vec<T, Abi>&, const typename basic_vec<T, Abi>::mask_type&) noexcept; template<class T, class Abi> constexpr T reduce_max(const basic_vec<T, Abi>&) noexcept; template<class T, class Abi> constexpr T reduce_max(const basic_vec<T, Abi>&, const typename basic_vec<T, Abi>::mask_type&) noexcept; / [simd.loadstore], load and store functions template<class V = see below, ranges::contiguous_range R, class. Flags> requires ranges::sized_range<R> constexpr V unchecked_load(R&& r, flags<Flags..> f = {}); template<class V = see below, ranges::contiguous_range R, class. Flags> requires ranges::sized_range<R> constexpr V unchecked_load(R&& r, const typename V::mask_type& k, flags<Flags..> f = {}); template<class V = see below, contiguous_iterator I, class. Flags> constexpr V unchecked_load(I first, iter_difference_t<I> n, flags<Flags..> f = {}); template<class V = see below, contiguous_iterator I, class. Flags> constexpr V unchecked_load(I first, iter_difference_t<I> n, const typename V::mask_type& k, flags<Flags..> f = {}); template<class V = see below, contiguous_iterator I, sized_sentinel_for<I> S, class. Flags> constexpr V unchecked_load(I first, S last, flags<Flags..> f = {}); template<class V = see below, contiguous_iterator I, sized_sentinel_for<I> S, class. Flags> constexpr V unchecked_load(I first, S last, const typename V::mask_type& k, flags<Flags..> f = {}); template<class V = see below, ranges::contiguous_range R, class. Flags> requires ranges::sized_range<R> constexpr V partial_load(R&& r, flags<Flags..> f = {}); template<class V = see below, ranges::contiguous_range R, class. Flags> requires ranges::sized_range<R> constexpr V partial_load(R&& r, const typename V::mask_type& k, flags<Flags..> f = {}); template<class V = see below, contiguous_iterator I, class. Flags> constexpr V partial_load(I first, iter_difference_t<I> n, flags<Flags..> f = {}); template<class V = see below, contiguous_iterator I, class. Flags> constexpr V partial_load(I first, iter_difference_t<I> n, const typename V::mask_type& k, flags<Flags..> f = {}); template<class V = see below, contiguous_iterator I, sized_sentinel_for<I> S, class. Flags> constexpr V partial_load(I first, S last, flags<Flags..> f = {}); template<class V = see below, contiguous_iterator I, sized_sentinel_for<I> S, class. Flags> constexpr V partial_load(I first, S last, const typename V::mask_type& k, flags<Flags..> f = {}); template<class T, class Abi, ranges::contiguous_range R, class. Flags> requires ranges::sized_range<R> constexpr void unchecked_store(const basic_vec<T, Abi>& v, R&& r, flags<Flags..> f = {}); template<class T, class Abi, ranges::contiguous_range R, class. Flags> requires ranges::sized_range<R> constexpr void unchecked_store(const basic_vec<T, Abi>& v, R&& r, const typename basic_vec<T, Abi>::mask_type& mask, flags<Flags..> f = {}); template<class T, class Abi, contiguous_iterator I, class. Flags> constexpr void unchecked_store(const basic_vec<T, Abi>& v, I first, iter_difference_t<I> n, flags<Flags..> f = {}); template<class T, class Abi, contiguous_iterator I, class. Flags> constexpr void unchecked_store(const basic_vec<T, Abi>& v, I first, iter_difference_t<I> n, const typename basic_vec<T, Abi>::mask_type& mask, flags<Flags..> f = {}); template<class T, class Abi, contiguous_iterator I, sized_sentinel_for<I> S, class. Flags> constexpr void unchecked_store(const basic_vec<T, Abi>& v, I first, S last, flags<Flags..> f = {}); template<class T, class Abi, contiguous_iterator I, sized_sentinel_for<I> S, class. Flags> constexpr void unchecked_store(const basic_vec<T, Abi>& v, I first, S last, const typename basic_vec<T, Abi>::mask_type& mask, flags<Flags..> f = {}); template<class T, class Abi, ranges::contiguous_range R, class. Flags> requires ranges::sized_range<R> constexpr void partial_store(const basic_vec<T, Abi>& v, R&& r, flags<Flags..> f = {}); template<class T, class Abi, ranges::contiguous_range R, class. Flags> requires ranges::sized_range<R> constexpr void partial_store(const basic_vec<T, Abi>& v, R&& r, const typename basic_vec<T, Abi>::mask_type& mask, flags<Flags..> f = {}); template<class T, class Abi, contiguous_iterator I, class. Flags> constexpr void partial_store( const basic_vec<T, Abi>& v, I first, iter_difference_t<I> n, flags<Flags..> f = {}); template<class T, class Abi, contiguous_iterator I, class. Flags> constexpr void partial_store( const basic_vec<T, Abi>& v, I first, iter_difference_t<I> n, const typename basic_vec<T, Abi>::mask_type& mask, flags<Flags..> f = {}); template<class T, class Abi, contiguous_iterator I, sized_sentinel_for<I> S, class. Flags> constexpr void partial_store(const basic_vec<T, Abi>& v, I first, S last, flags<Flags..> f = {}); template<class T, class Abi, contiguous_iterator I, sized_sentinel_for<I> S, class. Flags> constexpr void partial_store(const basic_vec<T, Abi>& v, I first, S last, const typename basic_vec<T, Abi>::mask_type& mask, flags<Flags..> f = {}); / [simd.permute.static], static permute inline constexpr simd-size-type zero_element = implementation-defined; inline constexpr simd-size-type uninit_element = implementation-defined; template<simd-size-type N = see below, simd-vec-type V, class IdxMap> constexpr resize_t<N, V> permute(const V& v, IdxMap&& idxmap); template<simd-size-type N = see below, simd-mask-type M, class IdxMap> constexpr resize_t<N, M> permute(const M& v, IdxMap&& idxmap); / [simd.permute.dynamic], dynamic permute template<simd-vec-type V, simd-integral I> constexpr resize_t<I::size(), V> permute(const V& v, const I& indices); template<simd-mask-type M, simd-integral I> constexpr resize_t<I::size(), M> permute(const M& v, const I& indices); / [simd.permute.mask], mask permute template<simd-vec-type V> constexpr V compress(const V& v, const typename V::mask_type& selector); template<simd-mask-type M> constexpr M compress(const M& v, const type_identity_t<M>& selector); template<simd-vec-type V> constexpr V compress(const V& v, const typename V::mask_type& selector, const typename V::value_type& fill_value); template<simd-mask-type M> constexpr M compress(const M& v, const type_identity_t<M>& selector, const typename M::value_type& fill_value); template<simd-vec-type V> constexpr V expand(const V& v, const typename V::mask_type& selector, const V& original = {}); template<simd-mask-type M> constexpr M expand(const M& v, const type_identity_t<M>& selector, const M& original = {}); / [simd.permute.memory], memory permute template<class V = see below, ranges::contiguous_range R, simd-integral I, class. Flags> requires ranges::sized_range<R> constexpr V unchecked_gather_from(R&& in, const I& indices, flags<Flags..> f = {}); template<class V = see below, ranges::contiguous_range R, simd-integral I, class. Flags> requires ranges::sized_range<R> constexpr V unchecked_gather_from(R&& in, const typename I::mask_type& mask, const I& indices, flags<Flags..> f = {}); template<class V = see below, ranges::contiguous_range R, simd-integral I, class. Flags> requires ranges::sized_range<R> constexpr V partial_gather_from(R&& in, const I& indices, flags<Flags..> f = {}); template<class V = see below, ranges::contiguous_range R, simd-integral I, class. Flags> requires ranges::sized_range<R> constexpr V partial_gather_from(R&& in, const typename I::mask_type& mask, const I& indices, flags<Flags..> f = {}); template<simd-vec-type V, ranges::contiguous_range R, simd-integral I, class. Flags> requires ranges::sized_range<R> constexpr void unchecked_scatter_to(const V& v, R&& out, const I& indices, flags<Flags..> f = {}); template<simd-vec-type V, ranges::contiguous_range R, simd-integral I, class. Flags> requires ranges::sized_range<R> constexpr void unchecked_scatter_to(const V& v, R&& out, const typename I::mask_type& mask, const I& indices, flags<Flags..> f = {}); template<simd-vec-type V, ranges::contiguous_range R, simd-integral I, class. Flags> requires ranges::sized_range<R> constexpr void partial_scatter_to(const V& v, R&& out, const I& indices, flags<Flags..> f = {}); template<simd-vec-type V, ranges::contiguous_range R, simd-integral I, class. Flags> requires ranges::sized_range<R> constexpr void partial_scatter_to(const V& v, R&& out, const typename I::mask_type& mask, const I& indices, flags<Flags..> f = {}); / [simd.creation], creation template<class T, class Abi> constexpr auto chunk(const basic_vec<typename T::value_type, Abi>& x) noexcept; template<class T, class Abi> constexpr auto chunk(const basic_mask<mask-element-size<T>, Abi>& x) noexcept; template<simd-size-type N, class T, class Abi> constexpr auto chunk(const basic_vec<T, Abi>& x) noexcept; template<simd-size-type N, size_t Bytes, class Abi> constexpr auto chunk(const basic_mask<Bytes, Abi>& x) noexcept; template<class T, class. Abis> constexpr basic_vec<T, deduce-abi-t<T, (basic_vec<T, Abis>::size() + ..)> cat(const basic_vec<T, Abis>&.) noexcept; template<size_t Bytes, class. Abis> constexpr basic_mask<Bytes, deduce-abi-t<integer-from<Bytes>, (basic_mask<Bytes, Abis>::size() + ..)> cat(const basic_mask<Bytes, Abis>&.) noexcept; / [simd.alg], algorithms template<class T, class Abi> constexpr basic_vec<T, Abi> min(const basic_vec<T, Abi>& a, const basic_vec<T, Abi>& b) noexcept; template<class T, class Abi> constexpr basic_vec<T, Abi> max(const basic_vec<T, Abi>& a, const basic_vec<T, Abi>& b) noexcept; template<class T, class Abi> constexpr pair<basic_vec<T, Abi>, basic_vec<T, Abi>> minmax(const basic_vec<T, Abi>& a, const basic_vec<T, Abi>& b) noexcept; template<class T, class Abi> constexpr basic_vec<T, Abi> clamp(const basic_vec<T, Abi>& v, const basic_vec<T, Abi>& lo, const basic_vec<T, Abi>& hi); template<class T, class U> constexpr auto select(bool c, const T& a, const U& b) -> remove_cvref_t<decltype(c ? a : b)>; template<size_t Bytes, class Abi, class T, class U> constexpr auto select(const basic_mask<Bytes, Abi>& c, const T& a, const U& b) noexcept -> decltype(simd-select-impl(c, a, b)); / [simd.math], mathematical functions template<math-floating-point V> constexpr deduced-vec-t<V> acos(const V& x); template<math-floating-point V> constexpr deduced-vec-t<V> asin(const V& x); template<math-floating-point V> constexpr deduced-vec-t<V> atan(const V& x); template<class V0, class V1> constexpr math-common-simd-t<V0, V1> atan2(const V0& y, const V1& x); template<math-floating-point V> constexpr deduced-vec-t<V> cos(const V& x); template<math-floating-point V> constexpr deduced-vec-t<V> sin(const V& x); template<math-floating-point V> constexpr deduced-vec-t<V> tan(const V& x); template<math-floating-point V> constexpr deduced-vec-t<V> acosh(const V& x); template<math-floating-point V> constexpr deduced-vec-t<V> asinh(const V& x); template<math-floating-point V> constexpr deduced-vec-t<V> atanh(const V& x); template<math-floating-point V> constexpr deduced-vec-t<V> cosh(const V& x); template<math-floating-point V> constexpr deduced-vec-t<V> sinh(const V& x); template<math-floating-point V> constexpr deduced-vec-t<V> tanh(const V& x); template<math-floating-point V> constexpr deduced-vec-t<V> exp(const V& x); template<math-floating-point V> constexpr deduced-vec-t<V> exp2(const V& x); template<math-floating-point V> constexpr deduced-vec-t<V> expm1(const V& x); template<math-floating-point V> constexpr deduced-vec-t<V> frexp(const V& value, rebind_t<int, deduced-vec-t<V>>* exp); template<math-floating-point V> constexpr rebind_t<int, deduced-vec-t<V>> ilogb(const V& x); template<math-floating-point V> constexpr deduced-vec-t<V> ldexp(const V& x, const rebind_t<int, deduced-vec-t<V>>& exp); template<math-floating-point V> constexpr deduced-vec-t<V> log(const V& x); template<math-floating-point V> constexpr deduced-vec-t<V> log10(const V& x); template<math-floating-point V> constexpr deduced-vec-t<V> log1p(const V& x); template<math-floating-point V> constexpr deduced-vec-t<V> log2(const V& x); template<math-floating-point V> constexpr deduced-vec-t<V> logb(const V& x); template<class T, class Abi> constexpr basic_vec<T, Abi> modf(const type_identity_t<basic_vec<T, Abi>>& value, basic_vec<T, Abi>* iptr); template<math-floating-point V> constexpr deduced-vec-t<V> scalbn(const V& x, const rebind_t<int, deduced-vec-t<V>>& n); template<math-floating-point V> constexpr deduced-vec-t<V> scalbln( const V& x, const rebind_t<long int, deduced-vec-t<V>>& n); template<math-floating-point V> constexpr deduced-vec-t<V> cbrt(const V& x); template<signed_integral T, class Abi> constexpr basic_vec<T, Abi> abs(const basic_vec<T, Abi>& j); template<math-floating-point V> constexpr deduced-vec-t<V> abs(const V& j); template<math-floating-point V> constexpr deduced-vec-t<V> fabs(const V& x); template<class V0, class V1> constexpr math-common-simd-t<V0, V1> hypot(const V0& x, const V1& y); template<class V0, class V1, class V2> constexpr math-common-simd-t<V0, V1, V2> hypot(const V0& x, const V1& y, const V2& z); template<class V0, class V1> constexpr math-common-simd-t<V0, V1> pow(const V0& x, const V1& y); template<math-floating-point V> constexpr deduced-vec-t<V> sqrt(const V& x); template<math-floating-point V> constexpr deduced-vec-t<V> erf(const V& x); template<math-floating-point V> constexpr deduced-vec-t<V> erfc(const V& x); template<math-floating-point V> constexpr deduced-vec-t<V> lgamma(const V& x); template<math-floating-point V> constexpr deduced-vec-t<V> tgamma(const V& x); template<math-floating-point V> constexpr deduced-vec-t<V> ceil(const V& x); template<math-floating-point V> constexpr deduced-vec-t<V> floor(const V& x); template<math-floating-point V> deduced-vec-t<V> nearbyint(const V& x); template<math-floating-point V> deduced-vec-t<V> rint(const V& x); template<math-floating-point V> rebind_t<long int, deduced-vec-t<V>> lrint(const V& x); template<math-floating-point V> rebind_t<long long int, V> llrint(const deduced-vec-t<V>& x); template<math-floating-point V> constexpr deduced-vec-t<V> round(const V& x); template<math-floating-point V> constexpr rebind_t<long int, deduced-vec-t<V>> lround(const V& x); template<math-floating-point V> constexpr rebind_t<long long int, deduced-vec-t<V>> llround(const V& x); template<math-floating-point V> constexpr deduced-vec-t<V> trunc(const V& x); template<class V0, class V1> constexpr math-common-simd-t<V0, V1> fmod(const V0& x, const V1& y); template<class V0, class V1> constexpr math-common-simd-t<V0, V1> remainder(const V0& x, const V1& y); template<class V0, class V1> constexpr math-common-simd-t<V0, V1> remquo(const V0& x, const V1& y, rebind_t<int, math-common-simd-t<V0, V1>>* quo); template<class V0, class V1> constexpr math-common-simd-t<V0, V1> copysign(const V0& x, const V1& y); template<class V0, class V1> constexpr math-common-simd-t<V0, V1> nextafter(const V0& x, const V1& y); template<class V0, class V1> constexpr math-common-simd-t<V0, V1> fdim(const V0& x, const V1& y); template<class V0, class V1> constexpr math-common-simd-t<V0, V1> fmax(const V0& x, const V1& y); template<class V0, class V1> constexpr math-common-simd-t<V0, V1> fmin(const V0& x, const V1& y); template<class V0, class V1, class V2> constexpr math-common-simd-t<V0, V1, V2> fma(const V0& x, const V1& y, const V2& z); template<class V0, class V1, class V2> constexpr math-common-simd-t<V0, V1, V2> lerp(const V0& a, const V1& b, const V2& t) noexcept; template<math-floating-point V> constexpr rebind_t<int, deduced-vec-t<V>> fpclassify(const V& x); template<math-floating-point V> constexpr typename deduced-vec-t<V>::mask_type isfinite(const V& x); template<math-floating-point V> constexpr typename deduced-vec-t<V>::mask_type isinf(const V& x); template<math-floating-point V> constexpr typename deduced-vec-t<V>::mask_type isnan(const V& x); template<math-floating-point V> constexpr typename deduced-vec-t<V>::mask_type isnormal(const V& x); template<math-floating-point V> constexpr typename deduced-vec-t<V>::mask_type signbit(const V& x); template<class V0, class V1> constexpr typename math-common-simd-t<V0, V1>::mask_type isgreater(const V0& x, const V1& y); template<class V0, class V1> constexpr typename math-common-simd-t<V0, V1>::mask_type isgreaterequal(const V0& x, const V1& y); template<class V0, class V1> constexpr typename math-common-simd-t<V0, V1>::mask_type isless(const V0& x, const V1& y); template<class V0, class V1> constexpr typename math-common-simd-t<V0, V1>::mask_type islessequal(const V0& x, const V1& y); template<class V0, class V1> constexpr typename math-common-simd-t<V0, V1>::mask_type islessgreater(const V0& x, const V1& y); template<class V0, class V1> constexpr typename math-common-simd-t<V0, V1>::mask_type isunordered(const V0& x, const V1& y); template<math-floating-point V> deduced-vec-t<V> assoc_laguerre(const rebind_t<unsigned, deduced-vec-t<V>>& n, const rebind_t<unsigned, deduced-vec-t<V>>& m, const V& x); template<math-floating-point V> deduced-vec-t<V> assoc_legendre(const rebind_t<unsigned, deduced-vec-t<V>>& l, const rebind_t<unsigned, deduced-vec-t<V>>& m, const V& x); template<class V0, class V1> math-common-simd-t<V0, V1> beta(const V0& x, const V1& y); template<math-floating-point V> deduced-vec-t<V> comp_ellint_1(const V& k); template<math-floating-point V> deduced-vec-t<V> comp_ellint_2(const V& k); template<class V0, class V1> math-common-simd-t<V0, V1> comp_ellint_3(const V0& k, const V1& nu); template<class V0, class V1> math-common-simd-t<V0, V1> cyl_bessel_i(const V0& nu, const V1& x); template<class V0, class V1> math-common-simd-t<V0, V1> cyl_bessel_j(const V0& nu, const V1& x); template<class V0, class V1> math-common-simd-t<V0, V1> cyl_bessel_k(const V0& nu, const V1& x); template<class V0, class V1> math-common-simd-t<V0, V1> cyl_neumann(const V0& nu, const V1& x); template<class V0, class V1> math-common-simd-t<V0, V1> ellint_1(const V0& k, const V1& phi); template<class V0, class V1> math-common-simd-t<V0, V1> ellint_2(const V0& k, const V1& phi); template<class V0, class V1, class V2> math-common-simd-t<V0, V1, V2> ellint_3(const V0& k, const V1& nu, const V2& phi); template<math-floating-point V> deduced-vec-t<V> expint(const V& x); template<math-floating-point V> deduced-vec-t<V> hermite(const rebind_t<unsigned, deduced-vec-t<V>>& n, const V& x); template<math-floating-point V> deduced-vec-t<V> laguerre(const rebind_t<unsigned, deduced-vec-t<V>>& n, const V& x); template<math-floating-point V> deduced-vec-t<V> legendre(const rebind_t<unsigned, deduced-vec-t<V>>& l, const V& x); template<math-floating-point V> deduced-vec-t<V> riemann_zeta(const V& x); template<math-floating-point V> deduced-vec-t<V> sph_bessel( const rebind_t<unsigned, deduced-vec-t<V>>& n, const V& x); template<math-floating-point V> deduced-vec-t<V> sph_legendre(const rebind_t<unsigned, deduced-vec-t<V>>& l, const rebind_t<unsigned, deduced-vec-t<V>>& m, const V& theta); template<math-floating-point V> deduced-vec-t<V> sph_neumann(const rebind_t<unsigned, deduced-vec-t<V>>& n, const V& x); / [simd.bit], bit manipulation template<simd-vec-type V> constexpr V byteswap(const V& v) noexcept; template<simd-vec-type V> constexpr V bit_ceil(const V& v); template<simd-vec-type V> constexpr V bit_floor(const V& v) noexcept; template<simd-vec-type V> constexpr typename V::mask_type has_single_bit(const V& v) noexcept; template<simd-vec-type V0, simd-vec-type V1> constexpr V0 rotl(const V0& v, const V1& s) noexcept; template<simd-vec-type V> constexpr V rotl(const V& v, int s) noexcept; template<simd-vec-type V0, simd-vec-type V1> constexpr V0 rotr(const V0& v, const V1& s) noexcept; template<simd-vec-type V> constexpr V rotr(const V& v, int s) noexcept; template<simd-vec-type V> constexpr rebind_t<make_signed_t<typename V::value_type>, V> bit_width(const V& v) noexcept; template<simd-vec-type V> constexpr rebind_t<make_signed_t<typename V::value_type>, V> countl_zero(const V& v) noexcept; template<simd-vec-type V> constexpr rebind_t<make_signed_t<typename V::value_type>, V> countl_one(const V& v) noexcept; template<simd-vec-type V> constexpr rebind_t<make_signed_t<typename V::value_type>, V> countr_zero(const V& v) noexcept; template<simd-vec-type V> constexpr rebind_t<make_signed_t<typename V::value_type>, V> countr_one(const V& v) noexcept; template<simd-vec-type V> constexpr rebind_t<make_signed_t<typename V::value_type>, V> popcount(const V& v) noexcept; / [simd.complex.math], complex math template<simd-complex V> constexpr rebind_t<simd-complex-value-type<V>, V> real(const V&) noexcept; template<simd-complex V> constexpr rebind_t<simd-complex-value-type<V>, V> imag(const V&) noexcept; template<simd-complex V> constexpr rebind_t<simd-complex-value-type<V>, V> abs(const V&); template<simd-complex V> constexpr rebind_t<simd-complex-value-type<V>, V> arg(const V&); template<simd-complex V> constexpr rebind_t<simd-complex-value-type<V>, V> norm(const V&); template<simd-complex V> constexpr V conj(const V&); template<simd-complex V> constexpr V proj(const V&); template<simd-complex V> constexpr V exp(const V& v); template<simd-complex V> constexpr V log(const V& v); template<simd-complex V> constexpr V log10(const V& v); template<simd-complex V> constexpr V sqrt(const V& v); template<simd-complex V> constexpr V sin(const V& v); template<simd-complex V> constexpr V asin(const V& v); template<simd-complex V> constexpr V cos(const V& v); template<simd-complex V> constexpr V acos(const V& v); template<simd-complex V> constexpr V tan(const V& v); template<simd-complex V> constexpr V atan(const V& v); template<simd-complex V> constexpr V sinh(const V& v); template<simd-complex V> constexpr V asinh(const V& v); template<simd-complex V> constexpr V cosh(const V& v); template<simd-complex V> constexpr V acosh(const V& v); template<simd-complex V> constexpr V tanh(const V& v); template<simd-complex V> constexpr V atanh(const V& v); template<simd-floating-point V> rebind_t<complex<typename V::value_type>, V> polar(const V& x, const V& y = {}); template<simd-complex V> constexpr V pow(const V& x, const V& y); / [simd.mask.class], class template basic_mask template<size_t Bytes, class Abi = native-abi<integer-from<Bytes>> class basic_mask; template<class T, simd-size-type N = simd-size-v<T, native-abi<T>> using mask = basic_mask<sizeof(T), deduce-abi-t<T, N>>; / [simd.mask.reductions], reductions template<size_t Bytes, class Abi> constexpr bool all_of(const basic_mask<Bytes, Abi>&) noexcept; template<size_t Bytes, class Abi> constexpr bool any_of(const basic_mask<Bytes, Abi>&) noexcept; template<size_t Bytes, class Abi> constexpr bool none_of(const basic_mask<Bytes, Abi>&) noexcept; template<size_t Bytes, class Abi> constexpr simd-size-type reduce_count(const basic_mask<Bytes, Abi>&) noexcept; template<size_t Bytes, class Abi> constexpr simd-size-type reduce_min_index(const basic_mask<Bytes, Abi>&); template<size_t Bytes, class Abi> constexpr simd-size-type reduce_max_index(const basic_mask<Bytes, Abi>&); constexpr bool all_of(same_as<bool> auto) noexcept; constexpr bool any_of(same_as<bool> auto) noexcept; constexpr bool none_of(same_as<bool> auto) noexcept; constexpr simd-size-type reduce_count(same_as<bool> auto) noexcept; constexpr simd-size-type reduce_min_index(same_as<bool> auto); constexpr simd-size-type reduce_max_index(same_as<bool> auto); } namespace std { / See [simd.alg], algorithms using simd::min; using simd::max; using simd::minmax; using simd::clamp; / See [simd.math], mathematical functions using simd::acos; using simd::asin; using simd::atan; using simd::atan2; using simd::cos; using simd::sin; using simd::tan; using simd::acosh; using simd::asinh; using simd::atanh; using simd::cosh; using simd::sinh; using simd::tanh; using simd::exp; using simd::exp2; using simd::expm1; using simd::frexp; using simd::ilogb; using simd::ldexp; using simd::log; using simd::log10; using simd::log1p; using simd::log2; using simd::logb; using simd::modf; using simd::scalbn; using simd::scalbln; using simd::cbrt; using simd::abs; using simd::fabs; using simd::hypot; using simd::pow; using simd::sqrt; using simd::erf; using simd::erfc; using simd::lgamma; using simd::tgamma; using simd::ceil; using simd::floor; using simd::nearbyint; using simd::rint; using simd::lrint; using simd::llrint; using simd::round; using simd::lround; using simd::llround; using simd::trunc; using simd::fmod; using simd::remainder; using simd::remquo; using simd::copysign; using simd::nextafter; using simd::fdim; using simd::fmax; using simd::fmin; using simd::fma; using simd::lerp; using simd::fpclassify; using simd::isfinite; using simd::isinf; using simd::isnan; using simd::isnormal; using simd::signbit; using simd::isgreater; using simd::isgreaterequal; using simd::isless; using simd::islessequal; using simd::islessgreater; using simd::isunordered; using simd::assoc_laguerre; using simd::assoc_legendre; using simd::beta; using simd::comp_ellint_1; using simd::comp_ellint_2; using simd::comp_ellint_3; using simd::cyl_bessel_i; using simd::cyl_bessel_j; using simd::cyl_bessel_k; using simd::cyl_neumann; using simd::ellint_1; using simd::ellint_2; using simd::ellint_3; using simd::expint; using simd::hermite; using simd::laguerre; using simd::legendre; using simd::riemann_zeta; using simd::sph_bessel; using simd::sph_legendre; using simd::sph_neumann; / See [simd.bit], bit manipulation using simd::byteswap; using simd::bit_ceil; using simd::bit_floor; using simd::has_single_bit; using simd::rotl; using simd::rotr; using simd::bit_width; using simd::countl_zero; using simd::countl_one; using simd::countr_zero; using simd::countr_one; using simd::popcount; / See [simd.complex.math], vec complex math using simd::real; using simd::imag; using simd::arg; using simd::norm; using simd::conj; using simd::proj; using simd::polar; }
🔗
template<class T, class U = typename T::value_type> struct alignment { see below };
1
#
alignment<T, U> has a member value if and only if T is a specialization of basic_vec and U is a vectorizable type.
2
#
If value is present, the type alignment<T, U> is a BinaryTypeTrait with a base characteristic of integral_constant<size_t, N> for some unspecified N ([simd.ctor], [simd.loadstore]).
[Note 1: 
value identifies the alignment restrictions on pointers used for (converting) loads and stores for the given type T on arrays of type U.
— end note]
3
#
The behavior of a program that adds specializations for alignment is undefined.
🔗
template<class T, class V> struct rebind { using type = see below; };
4
#
The member type is present if and only if
  • (4.1)
    V is a data-parallel type,
  • (4.2)
    T is a vectorizable type, and
  • (4.3)
    deduce-abi-t<T, V​::​size()> has a member type type.
5
#
If V is a specialization of basic_vec, let Abi1 denote an ABI tag such that basic_vec<T, Abi1>​::​​size() equals V​::​size().
If V is a specialization of basic_mask, let Abi1 denote an ABI tag such that basic_mask<sizeof(T), Abi1>​::​​size() equals V​::​size().
6
#
Where present, the member typedef type names basic_vec<T, Abi1> if V is a specialization of basic_vec or basic_mask<sizeof(T), Abi1> if V is a specialization of basic_mask.
🔗
template<simd-size-type N, class V> struct resize { using type = see below; };
7
#
Let T denote
  • (7.1)
    typename V​::​value_type if V is a specialization of basic_vec,
  • (7.2)
    otherwise integer-from<mask-element-size<V>> if V is a specialization of basic_mask.
8
#
The member type is present if and only if
  • (8.1)
    V is a data-parallel type, and
  • (8.2)
    deduce-abi-t<T, N> has a member type type.
9
#
If V is a specialization of basic_vec, let Abi1 denote an ABI tag such that basic_vec<T, Abi1>​::​​size() equals N.
If V is a specialization of basic_mask, let Abi1 denote an ABI tag such that basic_mask<sizeof(T), Abi1>​::​size() equals N.
10
#
Where present, the member typedef type names basic_vec<T, Abi1> if V is a specialization of basic_vec or basic_mask<sizeof(T), Abi1> if V is a specialization of basic_mask.

29.10.5 Load and store flags [simd.flags]

29.10.5.1 Class template flags overview [simd.flags.overview]

🔗
namespace std::simd { template<class. Flags> struct flags { / [simd.flags.oper], flags operators template<class. Other> friend consteval auto operator|(flags, flags<Other..>); }; }
1
#
Constraints: Every type in the parameter pack Flags is one of convert-flag, aligned-flag, or overaligned-​flag<N>.
🔗
template<class. Other> friend consteval auto operator|(flags a, flags<Other..> b);
1
#
Returns: A default-initialized object of type flags<Flags2..> for some Flags2 where every type in Flags2 is present either in template parameter pack Flags or in template parameter pack Other, and every type in template parameter packs Flags and Other is present in Flags2.
If the packs Flags and Other contain two different specializations overaligned-flag<N1> and overaligned-flag<N2>, Flags2 is not required to contain the specialization overaligned-flag<std​::​min(N1, N2)>.

29.10.6 Class template simd-iterator [simd.iterator]

🔗
namespace std::simd { template<class V> class simd-iterator { / exposition only V* data_ = nullptr; / exposition only simd-size-type offset_ = 0; / exposition only constexpr simd-iterator(V& d, simd-size-type off) noexcept; / exposition only public: using value_type = V::value_type; using iterator_category = input_iterator_tag; using iterator_concept = random_access_iterator_tag; using difference_type = simd-size-type; constexpr simd-iterator() = default; constexpr simd-iterator(const simd-iterator&) = default; constexpr simd-iterator& operator=(const simd-iterator&) = default; constexpr simd-iterator(const simd-iterator<remove_const_t<V>>&) requires is_const_v<V>; constexpr value_type operator*() const; constexpr simd-iterator& operator+(); constexpr simd-iterator operator+(int); constexpr simd-iterator& operator-(); constexpr simd-iterator operator-(int); constexpr simd-iterator& operator+=(difference_type n); constexpr simd-iterator& operator-=(difference_type n); constexpr value_type operator[](difference_type n) const; friend constexpr bool operator=(simd-iterator a, simd-iterator b) = default; friend constexpr bool operator=(simd-iterator a, default_sentinel_t) noexcept; friend constexpr auto operator<=>(simd-iterator a, simd-iterator b); friend constexpr simd-iterator operator+(simd-iterator i, difference_type n); friend constexpr simd-iterator operator+(difference_type n, simd-iterator i); friend constexpr simd-iterator operator-(simd-iterator i, difference_type n); friend constexpr difference_type operator-(simd-iterator a, simd-iterator b); friend constexpr difference_type operator-(simd-iterator i, default_sentinel_t) noexcept; friend constexpr difference_type operator-(default_sentinel_t, simd-iterator i) noexcept; }; }
🔗
constexpr simd-iterator(V& d, simd-size-type off) noexcept;
1
#
Effects: Initializes data_ with addressof(d) and offset_ with off.
🔗
constexpr simd-iterator(const simd-iterator<remove_const_t<V>>& i) requires is_const_v<V>;
2
#
Effects: Initializes data_ with i.data_ and offset_ with i.offset_.
🔗
constexpr value_type operator*() const;
3
#
Effects: Equivalent to: return (*data_)[offset_];
🔗
constexpr simd-iterator& operator+();
4
#
Effects: Equivalent to: return *this += 1;
🔗
constexpr simd-iterator operator+(int);
5
#
Effects: Equivalent to: simd-iterator tmp = *this; *this += 1; return tmp;
🔗
constexpr simd-iterator& operator-();
6
#
Effects: Equivalent to: return *this -= 1;
🔗
constexpr simd-iterator operator-(int);
7
#
Effects: Equivalent to: simd-iterator tmp = *this; *this -= 1; return tmp;
🔗
constexpr simd-iterator& operator+=(difference_type n);
8
#
Effects: Equivalent to: offset_ += n; return *this;
🔗
constexpr simd-iterator& operator-=(difference_type n);
10
#
Effects: Equivalent to: offset_ -= n; return *this;
🔗
constexpr value_type operator[](difference_type n) const;
12
#
Effects: Equivalent to: return (*data_)[offset_ + n];
🔗
friend constexpr bool operator=(simd-iterator i, default_sentinel_t) noexcept;
13
#
Effects: Equivalent to: return i.offset_ == V​::​size();
🔗
friend constexpr auto operator<=>(simd-iterator a, simd-iterator b);
14
#
Effects: Equivalent to: return a.offset_ <=> b.offset_;
🔗
friend constexpr simd-iterator operator+(simd-iterator i, difference_type n); friend constexpr simd-iterator operator+(difference_type n, simd-iterator i);
16
#
Effects: Equivalent to: return i += n;
🔗
friend constexpr simd-iterator operator-(simd-iterator i, difference_type n);
17
#
Effects: Equivalent to: return i -= n;
🔗
friend constexpr difference_type operator-(simd-iterator a, simd-iterator b);
18
#
Effects: Equivalent to: return a.offset_ - b.offset_;
🔗
friend constexpr difference_type operator-(simd-iterator i, default_sentinel_t) noexcept;
20
#
Effects: Equivalent to: return i.offset_ - V​::​size();
🔗
friend constexpr difference_type operator-(default_sentinel_t, simd-iterator i) noexcept;
21
#
Effects: Equivalent to: return V​::​size() - i.offset_;

29.10.7 Class template basic_vec [simd.class]

🔗
namespace std::simd { template<class T, class Abi> class basic_vec { using real-type = see below; / exposition only public: using value_type = T; using mask_type = basic_mask<sizeof(T), Abi>; using abi_type = Abi; using iterator = simd-iterator<basic_vec>; using const_iterator = simd-iterator<const basic_vec>; constexpr iterator begin() noexcept { return {*this, 0}; } constexpr const_iterator begin() const noexcept { return {*this, 0}; } constexpr const_iterator cbegin() const noexcept { return {*this, 0}; } constexpr default_sentinel_t end() const noexcept { return {}; } constexpr default_sentinel_t cend() const noexcept { return {}; } static constexpr integral_constant<simd-size-type, simd-size-v<T, Abi>> size {}; constexpr basic_vec() noexcept = default; / [simd.ctor], basic_vec constructors template<class U> constexpr explicit(see below) basic_vec(U&& value) noexcept; template<class U, class UAbi> constexpr explicit(see below) basic_vec(const basic_vec<U, UAbi>&) noexcept; template<class G> constexpr explicit basic_vec(G&& gen); template<class R, class. Flags> constexpr basic_vec(R&& range, flags<Flags..> = {}); template<class R, class. Flags> constexpr basic_vec(R&& range, const mask_type& mask, flags<Flags..> = {}); constexpr basic_vec(const real-type& reals, const real-type& imags = {}) noexcept; / [simd.subscr], basic_vec subscript operators constexpr value_type operator[](simd-size-type) const; template<simd-integral I> constexpr resize_t<I::size(), basic_vec> operator[](const I& indices) const; / [simd.complex.access], basic_vec complex accessors constexpr real-type real() const noexcept; constexpr real-type imag() const noexcept; constexpr void real(const real-type& v) noexcept; constexpr void imag(const real-type& v) noexcept; / [simd.unary], basic_vec unary operators constexpr basic_vec& operator+() noexcept; constexpr basic_vec operator+(int) noexcept; constexpr basic_vec& operator-() noexcept; constexpr basic_vec operator-(int) noexcept; constexpr mask_type operator!() const noexcept; constexpr basic_vec operator~() const noexcept; constexpr basic_vec operator+() const noexcept; constexpr basic_vec operator-() const noexcept; / [simd.binary], basic_vec binary operators friend constexpr basic_vec operator+(const basic_vec&, const basic_vec&) noexcept; friend constexpr basic_vec operator-(const basic_vec&, const basic_vec&) noexcept; friend constexpr basic_vec operator*(const basic_vec&, const basic_vec&) noexcept; friend constexpr basic_vec operator/(const basic_vec&, const basic_vec&) noexcept; friend constexpr basic_vec operator%(const basic_vec&, const basic_vec&) noexcept; friend constexpr basic_vec operator&(const basic_vec&, const basic_vec&) noexcept; friend constexpr basic_vec operator|(const basic_vec&, const basic_vec&) noexcept; friend constexpr basic_vec operator^(const basic_vec&, const basic_vec&) noexcept; friend constexpr basic_vec operator<(const basic_vec&, const basic_vec&) noexcept; friend constexpr basic_vec operator>(const basic_vec&, const basic_vec&) noexcept; friend constexpr basic_vec operator<(const basic_vec&, simd-size-type) noexcept; friend constexpr basic_vec operator>(const basic_vec&, simd-size-type) noexcept; / [simd.cassign], basic_vec compound assignment friend constexpr basic_vec& operator+=(basic_vec&, const basic_vec&) noexcept; friend constexpr basic_vec& operator-=(basic_vec&, const basic_vec&) noexcept; friend constexpr basic_vec& operator*=(basic_vec&, const basic_vec&) noexcept; friend constexpr basic_vec& operator/=(basic_vec&, const basic_vec&) noexcept; friend constexpr basic_vec& operator%=(basic_vec&, const basic_vec&) noexcept; friend constexpr basic_vec& operator&=(basic_vec&, const basic_vec&) noexcept; friend constexpr basic_vec& operator|=(basic_vec&, const basic_vec&) noexcept; friend constexpr basic_vec& operator^=(basic_vec&, const basic_vec&) noexcept; friend constexpr basic_vec& operator<=(basic_vec&, const basic_vec&) noexcept; friend constexpr basic_vec& operator>=(basic_vec&, const basic_vec&) noexcept; friend constexpr basic_vec& operator<=(basic_vec&, simd-size-type) noexcept; friend constexpr basic_vec& operator>=(basic_vec&, simd-size-type) noexcept; / [simd.comparison], basic_vec compare operators friend constexpr mask_type operator=(const basic_vec&, const basic_vec&) noexcept; friend constexpr mask_type operator!=(const basic_vec&, const basic_vec&) noexcept; friend constexpr mask_type operator>=(const basic_vec&, const basic_vec&) noexcept; friend constexpr mask_type operator<=(const basic_vec&, const basic_vec&) noexcept; friend constexpr mask_type operator>(const basic_vec&, const basic_vec&) noexcept; friend constexpr mask_type operator<(const basic_vec&, const basic_vec&) noexcept; / [simd.cond], basic_vec exposition only conditional operators friend constexpr basic_vec simd-select-impl( / exposition only const mask_type&, const basic_vec&, const basic_vec&) noexcept; }; template<class R, class. Ts> basic_vec(R&& r, Ts..) -> see below; template<size_t Bytes, class Abi> basic_vec(basic_mask<Bytes, Abi>) -> see below; }
1
#
Every specialization of basic_vec is a complete type.
The specialization of basic_vec<T, Abi> is
  • (1.1)
    enabled, if T is a vectorizable type, and there exists value N in the range [1, 64], such that Abi is deduce-abi-t<T, N>,
  • (1.2)
    otherwise, disabled, if T is not a vectorizable type,
  • (1.3)
    otherwise, it is implementation-defined if such a specialization is enabled.
If basic_vec<T, Abi> is disabled, then the specialization has a deleted default constructor, deleted destructor, deleted copy constructor, and deleted copy assignment.
In addition only the value_type, abi_type, and mask_type members are present.
If basic_vec<T, Abi> is enabled, then basic_vec<T, Abi> is trivially copyable, default-initialization of an object of such a type default-initializes all elements, and value-initialization value-initializes all elements ([dcl.init.general]).
2
#
Recommended practice: Implementations should support implicit conversions between specializations of basic_vec and appropriate implementation-defined types.
[Note 1: 
Appropriate types are non-standard vector types which are available in the implementation.
— end note]
3
#
If T is a specialization of complex, real-type denotes the same type as rebind_t<typename T​::​value_type, basic_vec<T, Abi>>, otherwise an unspecified non-array object type.

29.10.7.2 Constructors [simd.ctor]

🔗
template<class U> constexpr explicit(see below) basic_vec(U&& value) noexcept;
1
#
Effects: Initializes each element to the value of the argument after conversion to value_type.
4
#
Remarks: The expression inside explicit evaluates to false if and only if U satisfies convertible_to<value_type>, and either
🔗
template<class U, class UAbi> constexpr explicit(see below) basic_vec(const basic_vec<U, UAbi>& x) noexcept;
5
#
Effects: Initializes the
7
#
Remarks: The expression inside explicit evaluates to true if either
  • (7.1)
    the conversion from U to value_type is not value-preserving, or
  • (7.2)
    both U and value_type are integral types and the integer conversion rank ([conv.rank]) of U is greater than the integer conversion rank of value_type, or
  • (7.3)
    both U and value_type are floating-point types and the floating-point conversion rank ([conv.rank]) of U is greater than the floating-point conversion rank of value_type.
🔗
template<class G> constexpr explicit basic_vec(G&& gen);
8
#
Let From
9
#
Constraints: From
In addition, for all i in the range of [0, size()), if From
10
#
Effects: Initializes the
11
#
Remarks: gen is invoked exactly once for each i, in increasing order of i.
🔗
template<class R, class. Flags> constexpr basic_vec(R&& r, flags<Flags..> = {}); template<class R, class. Flags> constexpr basic_vec(R&& r, const mask_type& mask, flags<Flags..> = {});
12
#
Let mask be mask_type(true) for the overload with no mask parameter.
13
#
Constraints:
14
#
Mandates: If the template parameter pack Flags does not contain convert-flag, then the conversion from ranges​::​range_value_t<R> to value_type is value-preserving.
15
#
Preconditions:
  • (15.1)
    If the template parameter pack Flags contains aligned-flag, ranges​::​data(r) points to storage aligned by alignment_v<basic_vec, ranges​::​range_value_t<R>>.
  • (15.2)
    If the template parameter pack Flags contains overaligned-flag<N>, ranges​::​data(r) points to storage aligned by N.
16
#
Effects: Initializes the
🔗
template<class R, class. Ts> basic_vec(R&& r, Ts..) -> see below;
17
#
Constraints:
18
#
Remarks: The deduced type is equivalent to vec<ranges::range_value_t<R>, static_cast<simd-size-type>(ranges::size(r))>
🔗
template<size_t Bytes, class Abi> basic_vec(basic_mask<Bytes, Abi> k) -> see below;
19
#
Constraints: basic_mask<Bytes, Abi> is an enabled specialization of basic_mask and decltype(+k) is a valid type.
20
#
Remarks: The deduced type is equivalent to decltype(+k).
🔗
constexpr basic_vec(const real-type& reals, const real-type& imags = {}) noexcept;
21
#
Effects: Initializes the

29.10.7.3 Subscript operator [simd.subscr]

🔗
constexpr value_type operator[](simd-size-type i) const;
1
#
Throws: Nothing.
🔗
template<simd-integral I> constexpr resize_t<I::size(), basic_vec> operator[](const I& indices) const;
4
#
Effects: Equivalent to: return permute(*this, indices);
🔗
constexpr real-type real() const noexcept; constexpr real-type imag() const noexcept;
1
#
Returns: An object of type real-type where the
🔗
constexpr void real(const real-type& v) noexcept; constexpr void imag(const real-type& v) noexcept;
3
#
Effects: Replaces each element of the basic_vec object such that the

29.10.7.5 Unary operators [simd.unary]

1
#
Effects in [simd.unary] are applied as unary element-wise operations.
🔗
constexpr basic_vec& operator+() noexcept;
2
#
Returns: *this.
🔗
constexpr basic_vec operator+(int) noexcept;
5
#
Returns: A copy of *this before incrementing.
🔗
constexpr basic_vec& operator-() noexcept;
8
#
Returns: *this.
🔗
constexpr basic_vec operator-(int) noexcept;
11
#
Returns: A copy of *this before decrementing.
🔗
constexpr mask_type operator!() const noexcept;
14
#
Returns: A basic_mask object with the
🔗
constexpr basic_vec operator~() const noexcept;
16
#
Returns: A basic_vec object with the
🔗
constexpr basic_vec operator+() const noexcept;
18
#
Returns: *this.
🔗
constexpr basic_vec operator-() const noexcept;
20
#
Returns: A basic_vec object where the

29.10.8 basic_vec non-member operations [simd.nonmembers]

29.10.8.1 Binary operators [simd.binary]

🔗
friend constexpr basic_vec operator+(const basic_vec& lhs, const basic_vec& rhs) noexcept; friend constexpr basic_vec operator-(const basic_vec& lhs, const basic_vec& rhs) noexcept; friend constexpr basic_vec operator*(const basic_vec& lhs, const basic_vec& rhs) noexcept; friend constexpr basic_vec operator/(const basic_vec& lhs, const basic_vec& rhs) noexcept; friend constexpr basic_vec operator%(const basic_vec& lhs, const basic_vec& rhs) noexcept; friend constexpr basic_vec operator&(const basic_vec& lhs, const basic_vec& rhs) noexcept; friend constexpr basic_vec operator|(const basic_vec& lhs, const basic_vec& rhs) noexcept; friend constexpr basic_vec operator^(const basic_vec& lhs, const basic_vec& rhs) noexcept; friend constexpr basic_vec operator<(const basic_vec& lhs, const basic_vec& rhs) noexcept; friend constexpr basic_vec operator>(const basic_vec& lhs, const basic_vec& rhs) noexcept;
1
#
Constraints: requires (value_type a, value_type b) { a op b; } is true.
3
#
Returns: A basic_vec object initialized with the results of applying op to lhs and rhs as a binary element-wise operation.
🔗
friend constexpr basic_vec operator<(const basic_vec& v, simd-size-type n) noexcept; friend constexpr basic_vec operator>(const basic_vec& v, simd-size-type n) noexcept;
4
#
Constraints: requires (value_type a, simd-size-type b) { a op b; } is true.
6
#
Returns: A basic_vec object where the

29.10.8.2 Compound assignment [simd.cassign]

🔗
friend constexpr basic_vec& operator+=(basic_vec& lhs, const basic_vec& rhs) noexcept; friend constexpr basic_vec& operator-=(basic_vec& lhs, const basic_vec& rhs) noexcept; friend constexpr basic_vec& operator*=(basic_vec& lhs, const basic_vec& rhs) noexcept; friend constexpr basic_vec& operator/=(basic_vec& lhs, const basic_vec& rhs) noexcept; friend constexpr basic_vec& operator%=(basic_vec& lhs, const basic_vec& rhs) noexcept; friend constexpr basic_vec& operator&=(basic_vec& lhs, const basic_vec& rhs) noexcept; friend constexpr basic_vec& operator|=(basic_vec& lhs, const basic_vec& rhs) noexcept; friend constexpr basic_vec& operator^=(basic_vec& lhs, const basic_vec& rhs) noexcept; friend constexpr basic_vec& operator<=(basic_vec& lhs, const basic_vec& rhs) noexcept; friend constexpr basic_vec& operator>=(basic_vec& lhs, const basic_vec& rhs) noexcept;
1
#
Constraints: requires (value_type a, value_type b) { a op b; } is true.
3
#
Effects: These operators apply the indicated operator to lhs and rhs as an element-wise operation.
4
#
Returns: lhs.
🔗
friend constexpr basic_vec& operator<=(basic_vec& lhs, simd-size-type n) noexcept; friend constexpr basic_vec& operator>=(basic_vec& lhs, simd-size-type n) noexcept;
5
#
Constraints: requires (value_type a, simd-size-type b) { a op b; } is true.
7
#
Effects: Equivalent to: return operator op (lhs, basic_vec(n));

29.10.8.3 Comparison operators [simd.comparison]

🔗
friend constexpr mask_type operator=(const basic_vec& lhs, const basic_vec& rhs) noexcept; friend constexpr mask_type operator!=(const basic_vec& lhs, const basic_vec& rhs) noexcept; friend constexpr mask_type operator>=(const basic_vec& lhs, const basic_vec& rhs) noexcept; friend constexpr mask_type operator<=(const basic_vec& lhs, const basic_vec& rhs) noexcept; friend constexpr mask_type operator>(const basic_vec& lhs, const basic_vec& rhs) noexcept; friend constexpr mask_type operator<(const basic_vec& lhs, const basic_vec& rhs) noexcept;
1
#
Constraints: requires (value_type a, value_type b) { a op b; } is true.
3
#
Returns: A basic_mask object initialized with the results of applying op to lhs and rhs as a binary element-wise operation.

29.10.8.4 Exposition-only conditional operators [simd.cond]

🔗
friend constexpr basic_vec simd-select-impl(const mask_type& mask, const basic_vec& a, const basic_vec& b) noexcept;
1
#
Returns: A basic_vec object where the
🔗
template<class T, class Abi, class BinaryOperation = plus<> constexpr T reduce(const basic_vec<T, Abi>& x, BinaryOperation binary_op = {});
1
#
Constraints: BinaryOperation models reduction-binary-operation<T>.
2
#
Returns: GENERALIZED_SUM(binary_op, vec<T, 1>(x[0]), …, vec<T, 1>(x[x.size() - 1])[​0] ([numerics.defns]).
4
#
Throws: Any exception thrown from binary_op.
🔗
template<class T, class Abi, class BinaryOperation = plus<> constexpr T reduce( const basic_vec<T, Abi>& x, const typename basic_vec<T, Abi>::mask_type& mask, BinaryOperation binary_op = {}, type_identity_t<T> identity_element = see below);
5
#
Constraints:
  • (5.1)
    BinaryOperation models reduction-binary-operation<T>.
  • (5.2)
    An argument for identity_element is provided for the invocation, unless BinaryOperation is one of plus<>, multiplies<>, bit_and<>, bit_or<>, or bit_xor<>.
6
#
Preconditions:
  • (6.1)
    binary_op does not modify x.
  • (6.2)
    For all finite values y representable by T, the results of y == binary_op(vec<T, 1>(identity_element), vec<T, 1>(y))[0] and y == binary_op(vec<T, 1>(y), vec<T, 1>(identity_element))[0] are true.
7
#
Returns: If none_of(mask) is true, returns identity_element.
Otherwise, returns GENERALIZED_SUM(binary_op, vec<T, 1>(x[
8
#
Remarks: The default argument for identity_element is equal to
  • (9.1)
    T() if BinaryOperation is plus<>,
  • (9.2)
    T(1) if BinaryOperation is multiplies<>,
  • (9.3)
    T(~T() if BinaryOperation is bit_and<>,
  • (9.4)
    T() if BinaryOperation is bit_or<>, or
  • (9.5)
    T() if BinaryOperation is bit_xor<>.
🔗
template<class T, class Abi> constexpr T reduce_min(const basic_vec<T, Abi>& x) noexcept;
10
#
Returns: The value of an element x[j] for which x[i] < x[j] is false for all i in the range of [0, basic_vec<T, Abi>​::​size()).
🔗
template<class T, class Abi> constexpr T reduce_min( const basic_vec<T, Abi>&, const typename basic_vec<T, Abi>::mask_type&) noexcept;
12
#
Returns: If none_of(mask) is true, returns numeric_limits<T>​::​max().
Otherwise, returns the value of a selected element x[j] for which x[i] < x[j] is false for all selected indices i of mask.
🔗
template<class T, class Abi> constexpr T reduce_max(const basic_vec<T, Abi>& x) noexcept;
14
#
Returns: The value of an element x[j] for which x[j] < x[i] is false for all i in the range of [0, basic_vec<T, Abi>​::​size()).
🔗
template<class T, class Abi> constexpr T reduce_max( const basic_vec<T, Abi>&, const typename basic_vec<T, Abi>::mask_type&) noexcept;
16
#
Returns: If none_of(mask) is true, returns numeric_limits<V​::​value_type>​::​lowest().
Otherwise, returns the value of a selected element x[j] for which x[j] < x[i] is false for all selected indices i of mask.

29.10.8.6 Load and store functions [simd.loadstore]

🔗
template<class V = see below, ranges::contiguous_range R, class. Flags> requires ranges::sized_range<R> constexpr V unchecked_load(R&& r, flags<Flags..> f = {}); template<class V = see below, ranges::contiguous_range R, class. Flags> requires ranges::sized_range<R> constexpr V unchecked_load(R&& r, const typename V::mask_type& mask, flags<Flags..> f = {}); template<class V = see below, contiguous_iterator I, class. Flags> constexpr V unchecked_load(I first, iter_difference_t<I> n, flags<Flags..> f = {}); template<class V = see below, contiguous_iterator I, class. Flags> constexpr V unchecked_load(I first, iter_difference_t<I> n, const typename V::mask_type& mask, flags<Flags..> f = {}); template<class V = see below, contiguous_iterator I, sized_sentinel_for<I> S, class. Flags> constexpr V unchecked_load(I first, S last, flags<Flags..> f = {}); template<class V = see below, contiguous_iterator I, sized_sentinel_for<I> S, class. Flags> constexpr V unchecked_load(I first, S last, const typename V::mask_type& mask, flags<Flags..> f = {});
1
#
Let
  • (1.1)
    mask be V​::​mask_type(true) for the overloads with no mask parameter;
  • (1.2)
    R be span<const iter_value_t<I>> for the overloads with no template parameter R;
  • (1.3)
    r be R(first, n) for the overloads with an n parameter and R(first, last) for the overloads with a last parameter.
2
#
Mandates: If ranges​::​size(r) is a constant expression then ranges​::​size(r)  ≥  V​::​size().
3
#
Preconditions:
  • (3.1)
    [first, first + n) is a valid range for the overloads with an n parameter.
  • (3.2)
    [first, last) is a valid range for the overloads with a last parameter.
  • (3.3)
    ranges​::​size(r)  ≥  V​::​size()
4
#
Remarks: The default argument for template parameter V is basic_vec<ranges​::​range_value_t<R>>.
🔗
template<class V = see below, ranges::contiguous_range R, class. Flags> requires ranges::sized_range<R> constexpr V partial_load(R&& r, flags<Flags..> f = {}); template<class V = see below, ranges::contiguous_range R, class. Flags> requires ranges::sized_range<R> constexpr V partial_load(R&& r, const typename V::mask_type& mask, flags<Flags..> f = {}); template<class V = see below, contiguous_iterator I, class. Flags> constexpr V partial_load(I first, iter_difference_t<I> n, flags<Flags..> f = {}); template<class V = see below, contiguous_iterator I, class. Flags> constexpr V partial_load(I first, iter_difference_t<I> n, const typename V::mask_type& mask, flags<Flags..> f = {}); template<class V = see below, contiguous_iterator I, sized_sentinel_for<I> S, class. Flags> constexpr V partial_load(I first, S last, flags<Flags..> f = {}); template<class V = see below, contiguous_iterator I, sized_sentinel_for<I> S, class. Flags> constexpr V partial_load(I first, S last, const typename V::mask_type& mask, flags<Flags..> f = {});
6
#
Let
  • (6.1)
    mask be V​::​mask_type(true) for the overloads with no mask parameter;
  • (6.2)
    R be span<const iter_value_t<I>> for the overloads with no template parameter R;
  • (6.3)
    r be R(first, n) for the overloads with an n parameter and R(first, last) for the overloads with a last parameter;
  • (6.4)
    T be typename V​::​value_type.
7
#
Mandates:
  • (7.1)
    ranges​::​range_value_t<R> is a vectorizable type and satisfies explicitly-convertible-to<T>,
  • (7.2)
    same_as<remove_cvref_t<V>, V> is true,
  • (7.3)
    V is an enabled specialization of basic_vec, and
  • (7.4)
    if the template parameter pack Flags does not contain convert-flag, then the conversion from ranges​::​range_value_t<R> to V​::​value_type is value-preserving.
8
#
Preconditions:
  • (8.1)
    [first, first + n) is a valid range for the overloads with an n parameter.
  • (8.2)
    [first, last) is a valid range for the overloads with a last parameter.
  • (8.3)
    If the template parameter pack Flags contains aligned-flag, ranges​::​data(r) points to storage aligned by alignment_v<V, ranges​::​range_value_t<R>>.
  • (8.4)
    If the template parameter pack Flags contains overaligned-flag<N>, ranges​::​data(r) points to storage aligned by N.
9
#
Returns: A basic_vec object whose
10
#
Remarks: The default argument for template parameter V is basic_vec<ranges​::​range_value_t<R>>.
🔗
template<class T, class Abi, ranges::contiguous_range R, class. Flags> requires ranges::sized_range<R> constexpr void unchecked_store(const basic_vec<T, Abi>& v, R&& r, flags<Flags..> f = {}); template<class T, class Abi, ranges::contiguous_range R, class. Flags> requires ranges::sized_range<R> constexpr void unchecked_store(const basic_vec<T, Abi>& v, R&& r, const typename basic_vec<T, Abi>::mask_type& mask, flags<Flags..> f = {}); template<class T, class Abi, contiguous_iterator I, class. Flags> constexpr void unchecked_store(const basic_vec<T, Abi>& v, I first, iter_difference_t<I> n, flags<Flags..> f = {}); template<class T, class Abi, contiguous_iterator I, class. Flags> constexpr void unchecked_store(const basic_vec<T, Abi>& v, I first, iter_difference_t<I> n, const typename basic_vec<T, Abi>::mask_type& mask, flags<Flags..> f = {}); template<class T, class Abi, contiguous_iterator I, sized_sentinel_for<I> S, class. Flags> constexpr void unchecked_store(const basic_vec<T, Abi>& v, I first, S last, flags<Flags..> f = {}); template<class T, class Abi, contiguous_iterator I, sized_sentinel_for<I> S, class. Flags> constexpr void unchecked_store(const basic_vec<T, Abi>& v, I first, S last, const typename basic_vec<T, Abi>::mask_type& mask, flags<Flags..> f = {});
11
#
Let
  • (11.1)
    mask be basic_vec<T, Abi>​::​mask_type(true) for the overloads with no mask parameter;
  • (11.2)
    R be span<iter_value_t<I>> for the overloads with no template parameter R;
  • (11.3)
    r be R(first, n) for the overloads with an n parameter and R(first, last) for the overloads with a last parameter.
12
#
Mandates: If ranges​::​size(r) is a constant expression then ranges​::​size(r)  ≥  simd-size-v<T, Abi>.
13
#
Preconditions:
  • (13.1)
    [first, first + n) is a valid range for the overloads with an n parameter.
  • (13.2)
    [first, last) is a valid range for the overloads with a last parameter.
  • (13.3)
    ranges​::​size(r)  ≥  simd-size-v<T, Abi>
14
#
Effects: Equivalent to: partial_store(v, r, mask, f).
🔗
template<class T, class Abi, ranges::contiguous_range R, class. Flags> requires ranges::sized_range<R> constexpr void partial_store(const basic_vec<T, Abi>& v, R&& r, flags<Flags..> f = {}); template<class T, class Abi, ranges::contiguous_range R, class. Flags> requires ranges::sized_range<R> constexpr void partial_store(const basic_vec<T, Abi>& v, R&& r, const typename basic_vec<T, Abi>::mask_type& mask, flags<Flags..> f = {}); template<class T, class Abi, contiguous_iterator I, class. Flags> constexpr void partial_store(const basic_vec<T, Abi>& v, I first, iter_difference_t<I> n, flags<Flags..> f = {}); template<class T, class Abi, contiguous_iterator I, class. Flags> constexpr void partial_store(const basic_vec<T, Abi>& v, I first, iter_difference_t<I> n, const typename basic_vec<T, Abi>::mask_type& mask, flags<Flags..> f = {}); template<class T, class Abi, contiguous_iterator I, sized_sentinel_for<I> S, class. Flags> constexpr void partial_store(const basic_vec<T, Abi>& v, I first, S last, flags<Flags..> f = {}); template<class T, class Abi, contiguous_iterator I, sized_sentinel_for<I> S, class. Flags> constexpr void partial_store(const basic_vec<T, Abi>& v, I first, S last, const typename basic_vec<T, Abi>::mask_type& mask, flags<Flags..> f = {});
15
#
Let
  • (15.1)
    mask be basic_vec<T, Abi>​::​mask_type(true) for the overloads with no mask parameter;
  • (15.2)
    R be span<iter_value_t<I>> for the overloads with no template parameter R;
  • (15.3)
    r be R(first, n) for the overloads with an n parameter and R(first, last) for the overloads with a last parameter.
16
#
Constraints:
17
#
Mandates:
  • (17.1)
    ranges​::​range_value_t<R> is a vectorizable type, and
  • (17.2)
    if the template parameter pack Flags does not contain convert-flag, then the conversion from T to ranges​::​range_value_t<R> is value-preserving.
18
#
Preconditions:
  • (18.1)
    [first, first + n) is a valid range for the overloads with an n parameter.
  • (18.2)
    [first, last) is a valid range for the overloads with a last parameter.
  • (18.3)
    If the template parameter pack Flags contains aligned-flag, ranges​::​data(r) points to storage aligned by alignment_v<basic_vec<T, Abi>, ranges​::​range_value_t<R>>.
  • (18.4)
    If the template parameter pack Flags contains overaligned-flag<N>, ranges​::​data(r) points to storage aligned by N.
19
#
Effects: For all i in the range of [0, basic_vec<T, Abi>​::​size()), if mask[i] && i < ranges​::​​size(r) is true, evaluates ranges​::​data(r)[i] = static_cast<ranges​::​range_value_t<R>>(v[​i]).
🔗
template<simd-size-type N = see below, simd-vec-type V, class IdxMap> constexpr resize_t<N, V> permute(const V& v, IdxMap&& idxmap); template<simd-size-type N = see below, simd-mask-type M, class IdxMap> constexpr resize_t<N, M> permute(const M& v, IdxMap&& idxmap);
1
#
Let:
  • (1.1)
    gen-fn(i) be idxmap(i, V​::​size() if that expression is well-formed, and idxmap(i) otherwise.
  • (1.2)
    perm-fn be the following exposition-only function template: template<simd-size-type I> typename V::value_type perm-fn() { constexpr auto src_index = gen-fn(I); if constexpr (src_index == zero_element) { return typename V::value_type(); } else if constexpr (src_index == uninit_element) { return unspecified-value; } else { return v[src_index]; } }
2
#
Constraints: At least one of invoke_result_t<IdxMap&, simd-size-type> and invoke_result_t<IdxMap&, simd-size-type, simd-size-type> satisfies integral.
3
#
Mandates: gen-fn(i) is a constant expression whose value is zero_element, uninit_element, or in the range [0, V​::​size()), for all i in the range [0, N).
4
#
Returns: A data-parallel object where the
5
#
Remarks: The default argument for template parameter N is V​::​size().
🔗
template<simd-vec-type V, simd-integral I> constexpr resize_t<I::size(), V> permute(const V& v, const I& indices); template<simd-mask-type M, simd-integral I> constexpr resize_t<I::size(), M> permute(const M& v, const I& indices);
1
#
Returns: A data-parallel object where the
🔗
template<simd-vec-type V> constexpr V compress(const V& v, const typename V::mask_type& selector); template<simd-mask-type M> constexpr M compress(const M& v, const type_identity_t<M>& selector);
1
#
Let:
  • (1.1)
    bit-index(i) be a function which returns the index of the
  • (1.2)
    select-value(i) be a function which returns v[bit-index(i)] for i in the range [0, reduce_count(selector)) and a valid but unspecified value otherwise.
    [Note 1: 
    Different calls to select-value can return different unspecified values.
    — end note]
2
#
Returns: A data-parallel object where the
🔗
template<simd-vec-type V> constexpr V compress(const V& v, const typename V::mask_type& selector, const typename V::value_type& fill_value); template<simd-mask-type M> constexpr M compress(const M& v, const type_identity_t<M>& selector, const typename M::value_type& fill_value);
3
#
Let:
  • (3.1)
    bit-index(i) be a function which returns the index of the
  • (3.2)
    select-value(i) be a function which returns v[bit-index(i)] for i in the range [0, reduce_count(selector)) and fill_value otherwise.
4
#
Returns: A data-parallel object where the
🔗
template<simd-vec-type V> constexpr V expand(const V& v, const typename V::mask_type& selector, const V& original = {}); template<simd-mask-type M> constexpr M expand(const M& v, const type_identity_t<M>& selector, const M& original = {});
5
#
Let:
  • (5.1)
    set-indices be a list of the index positions of true elements in selector, in ascending order.
  • (5.2)
    bit-lookup(b) be a function which returns the index where b appears in set-indices.
  • (5.3)
    select-value(i) be a function which returns v[bit-lookup(i)] if selector[i] is true, otherwise returns original[i].
6
#
Returns: A data-parallel object where the
🔗
template<class V = see below, ranges::contiguous_range R, simd-integral I, class. Flags> requires ranges::sized_range<R> constexpr V unchecked_gather_from(R&& in, const I& indices, flags<Flags..> f = {}); template<class V = see below, ranges::contiguous_range R, simd-integral I, class. Flags> requires ranges::sized_range<R> constexpr V unchecked_gather_from(R&& in, const typename I::mask_type& mask, const I& indices, flags<Flags..> f = {});
1
#
Let mask be typename I​::​mask_type(true) for the overload with no mask parameter.
2
#
Preconditions: All values in select(mask, indices, typename I​::​value_type() are in the range [0, ranges​::​size(in)).
3
#
Remarks: The default argument for template parameter V is vec<ranges​::​range_value_t<R>, I​::​​size()>.
🔗
template<class V = see below, ranges::contiguous_range R, simd-integral I, class. Flags> requires ranges::sized_range<R> constexpr V partial_gather_from(R&& in, const I& indices, flags<Flags..> f = {}); template<class V = see below, ranges::contiguous_range R, simd-integral I, class. Flags> requires ranges::sized_range<R> constexpr V partial_gather_from(R&& in, const typename I::mask_type& mask, const I& indices, flags<Flags..> f = {});
5
#
Let:
  • (5.1)
    mask be typename I​::​mask_type(true) for the overload with no mask parameter;
  • (5.2)
    T be typename V​::​value_type.
6
#
Constraints: ranges​::​range_value_t<R> is a vectorizable type and satisfies explicitly-convertible-to<T>.
7
#
Mandates:
  • (7.1)
    ranges​::​range_value_t<R> is a vectorizable type,
  • (7.2)
    same_as<remove_cvref_t<V>, V> is true,
  • (7.3)
    V is an enabled specialization of basic_vec,
  • (7.4)
    V​::​size() == I​::​size() is true, and
  • (7.5)
    if the template parameter pack Flags does not contain convert-flag, then the conversion from ranges​::​range_value_t<R> to T is value-preserving.
8
#
Preconditions:
  • (8.1)
    If the template parameter pack Flags contains aligned-flag, ranges​::​data(in) points to storage aligned by alignment_v<V, ranges​::​range_value_t<R>>.
  • (8.2)
    If the template parameter pack Flags contains overaligned-flag<N>, ranges​::​data(in) points to storage aligned by N.
9
#
Returns: A basic_vec object where the
10
#
Remarks: The default argument for template parameter V is vec<ranges​::​range_value_t<R>, I​::​​size()>.
🔗
template<simd-vec-type V, ranges::contiguous_range R, simd-integral I, class. Flags> requires ranges::sized_range<R> constexpr void unchecked_scatter_to(const V& v, R&& out, const I& indices, flags<Flags..> f = {}); template<simd-vec-type V, ranges::contiguous_range R, simd-integral I, class. Flags> requires ranges::sized_range<R> constexpr void unchecked_scatter_to(const V& v, R&& out, const typename I::mask_type& mask, const I& indices, flags<Flags..> f = {});
11
#
Let mask be typename I​::​mask_type(true) for the overload with no mask parameter.
12
#
Preconditions: All values in select(mask, indices, typename I​::​value_type() are in the range [0, ranges​::​size(out)).
13
#
Effects: Equivalent to: partial_scatter_to(v, out, mask, indices, f);
🔗
template<simd-vec-type V, ranges::contiguous_range R, simd-integral I, class. Flags> requires ranges::sized_range<R> constexpr void partial_scatter_to(const V& v, R&& out, const I& indices, flags<Flags..> f = {}); template<simd-vec-type V, ranges::contiguous_range R, simd-integral I, class. Flags> requires ranges::sized_range<R> constexpr void partial_scatter_to(const V& v, R&& out, const typename I::mask_type& mask, const I& indices, flags<Flags..> f = {});
14
#
Let mask be typename I​::​mask_type(true) for the overload with no mask parameter.
15
#
Constraints:
16
#
Mandates:
  • (16.1)
    ranges​::​range_value_t<R> is a vectorizable type, and
  • (16.2)
    if the template parameter pack Flags does not contain convert-flag, then the conversion from typename V​::​value_type to ranges​::​range_value_t<R> is value-preserving.
17
#
Preconditions:
  • (17.1)
    For all selected indices i the values indices[i] are unique.
  • (17.2)
    If the template parameter pack Flags contains aligned-flag, ranges​::​data(out) points to storage aligned by alignment_v<V, ranges​::​range_value_t<R>>.
  • (17.3)
    If the template parameter pack Flags contains overaligned-flag<N>, ranges​::​data(out) points to storage aligned by N.
18
#
Effects: For all i in the range [0, I​::​size()), if mask[i] && (indices[i] < ranges​::​size(out)) is true, evaluates ranges​::​data(out)[indices[i] = static_cast<ranges​::​range_value_t<R>>(v[​i]).
🔗
template<class T, class Abi> constexpr auto chunk(const basic_vec<typename T::value_type, Abi>& x) noexcept; template<class T, class Abi> constexpr auto chunk(const basic_mask<mask-element-size<T>, Abi>& x) noexcept;
1
#
Constraints:
  • (1.1)
    For the first overload, T is an enabled specialization of basic_vec.
    If basic_vec<​typename T​::​​value_type, Abi>​::​size() % T​::​size() is not 0, then resize_t<basic_vec<​typename T​::​​value_type, Abi>​::​size() % T​::​size(), T> is valid and denotes a type.
  • (1.2)
    For the second overload, T is an enabled specialization of basic_mask.
    If basic_mask<mask-element-size<T>, Abi>​::​size() % T​::​size() is not 0, then resize_t<​basic_mask<​mask-element-size<T>, Abi>​::​size() % T​::​size(), T> is valid and denotes a type.
2
#
Returns:
  • (3.1)
    If x.size() % T​::​size() == 0 is true, an array<T, N> with the
  • (3.2)
    Otherwise, a tuple of N objects of type T and one object of type resize_t<x.size() % T​::​size(), T>.
    The
    The
🔗
template<simd-size-type N, class T, class Abi> constexpr auto chunk(const basic_vec<T, Abi>& x) noexcept;
4
#
Effects: Equivalent to: return chunk<resize_t<N, basic_vec<T, Abi>>(x);
🔗
template<simd-size-type N, size_t Bytes, class Abi> constexpr auto chunk(const basic_mask<Bytes, Abi>& x) noexcept;
5
#
Effects: Equivalent to: return chunk<resize_t<N, basic_mask<Bytes, Abi>>(x);
🔗
template<class T, class. Abis> constexpr vec<T, (basic_vec<T, Abis>::size() + ..)> cat(const basic_vec<T, Abis>&. xs) noexcept; template<size_t Bytes, class. Abis> constexpr basic_mask<Bytes, deduce-abi-t<integer-from<Bytes>, (basic_mask<Bytes, Abis>::size() + ..)> cat(const basic_mask<Bytes, Abis>&. xs) noexcept;
6
#
Constraints:
  • (6.1)
    For the first overload vec<T, (basic_vec<T, Abis>​::​size() + ..)> is enabled.
  • (6.2)
    For the second overload basic_mask<Bytes, deduce-abi-t<integer-from<Bytes>, (basic_mask<Bytes, Abis>​::​size() + ..)> is enabled.
7
#
Returns: A data-parallel object initialized with the concatenated values in the xs pack of data-parallel objects: The
🔗
template<class T, class Abi> constexpr basic_vec<T, Abi> min(const basic_vec<T, Abi>& a, const basic_vec<T, Abi>& b) noexcept;
1
#
Returns: The result of the element-wise application of min(a[i], b[i]) for all i in the range of [0, basic_vec<T, Abi>​::​size()).
🔗
template<class T, class Abi> constexpr basic_vec<T, Abi> max(const basic_vec<T, Abi>& a, const basic_vec<T, Abi>& b) noexcept;
3
#
Returns: The result of the element-wise application of max(a[i], b[i]) for all i in the range of [0, basic_vec<T, Abi>​::​size()).
🔗
template<class T, class Abi> constexpr pair<basic_vec<T, Abi>, basic_vec<T, Abi>> minmax(const basic_vec<T, Abi>& a, const basic_vec<T, Abi>& b) noexcept;
5
#
Effects: Equivalent to: return pair{min(a, b), max(a, b)};
🔗
template<class T, class Abi> constexpr basic_vec<T, Abi> clamp( const basic_vec<T, Abi>& v, const basic_vec<T, Abi>& lo, const basic_vec<T, Abi>& hi);
6
#
Preconditions: No element in lo is greater than the corresponding element in hi.
8
#
Returns: The result of element-wise application of clamp(v[i], lo[i], hi[i]) for all i in the range of [0, basic_vec<T, Abi>​::​size()).
🔗
template<class T, class U> constexpr auto select(bool c, const T& a, const U& b) -> remove_cvref_t<decltype(c ? a : b)>;
9
#
Effects: Equivalent to: return c ? a : b;
🔗
template<size_t Bytes, class Abi, class T, class U> constexpr auto select(const basic_mask<Bytes, Abi>& c, const T& a, const U& b) noexcept -> decltype(simd-select-impl(c, a, b));
10
#
Effects: Equivalent to: return simd-select-impl(c, a, b); where simd-select-impl is found by argument-dependent lookup ([basic.lookup.argdep]) contrary to [contents].

29.10.8.13 Mathematical functions [simd.math]

🔗
template<math-floating-point V> constexpr rebind_t<int, deduced-vec-t<V>> ilogb(const V& x); template<math-floating-point V> constexpr deduced-vec-t<V> ldexp(const V& x, const rebind_t<int, deduced-vec-t<V>>& exp); template<math-floating-point V> constexpr deduced-vec-t<V> scalbn(const V& x, const rebind_t<int, deduced-vec-t<V>>& n); template<math-floating-point V> constexpr deduced-vec-t<V> scalbln(const V& x, const rebind_t<long int, deduced-vec-t<V>>& n); template<signed_integral T, class Abi> constexpr basic_vec<T, Abi> abs(const basic_vec<T, Abi>& j); template<math-floating-point V> constexpr deduced-vec-t<V> abs(const V& j); template<math-floating-point V> constexpr deduced-vec-t<V> fabs(const V& x); template<math-floating-point V> constexpr deduced-vec-t<V> ceil(const V& x); template<math-floating-point V> constexpr deduced-vec-t<V> floor(const V& x); template<math-floating-point V> deduced-vec-t<V> nearbyint(const V& x); template<math-floating-point V> deduced-vec-t<V> rint(const V& x); template<math-floating-point V> rebind_t<long int, deduced-vec-t<V>> lrint(const V& x); template<math-floating-point V> rebind_t<long long int, deduced-vec-t<V>> llrint(const V& x); template<math-floating-point V> constexpr deduced-vec-t<V> round(const V& x); template<math-floating-point V> constexpr rebind_t<long int, deduced-vec-t<V>> lround(const V& x); template<math-floating-point V> constexpr rebind_t<long long int, deduced-vec-t<V>> llround(const V& x); template<class V0, class V1> constexpr math-common-simd-t<V0, V1> fmod(const V0& x, const V1& y); template<math-floating-point V> constexpr deduced-vec-t<V> trunc(const V& x); template<class V0, class V1> constexpr math-common-simd-t<V0, V1> remainder(const V0& x, const V1& y); template<class V0, class V1> constexpr math-common-simd-t<V0, V1> copysign(const V0& x, const V1& y); template<class V0, class V1> constexpr math-common-simd-t<V0, V1> nextafter(const V0& x, const V1& y); template<class V0, class V1> constexpr math-common-simd-t<V0, V1> fdim(const V0& x, const V1& y); template<class V0, class V1> constexpr math-common-simd-t<V0, V1> fmax(const V0& x, const V1& y); template<class V0, class V1> constexpr math-common-simd-t<V0, V1> fmin(const V0& x, const V1& y); template<class V0, class V1, class V2> constexpr math-common-simd-t<V0, V1, V2> fma(const V0& x, const V1& y, const V2& z); template<math-floating-point V> constexpr rebind_t<int, deduced-vec-t<V>> fpclassify(const V& x); template<math-floating-point V> constexpr typename deduced-vec-t<V>::mask_type isfinite(const V& x); template<math-floating-point V> constexpr typename deduced-vec-t<V>::mask_type isinf(const V& x); template<math-floating-point V> constexpr typename deduced-vec-t<V>::mask_type isnan(const V& x); template<math-floating-point V> constexpr typename deduced-vec-t<V>::mask_type isnormal(const V& x); template<math-floating-point V> constexpr typename deduced-vec-t<V>::mask_type signbit(const V& x); template<class V0, class V1> constexpr typename math-common-simd-t<V0, V1>::mask_type isgreater(const V0& x, const V1& y); template<class V0, class V1> constexpr typename math-common-simd-t<V0, V1>::mask_type isgreaterequal(const V0& x, const V1& y); template<class V0, class V1> constexpr typename math-common-simd-t<V0, V1>::mask_type isless(const V0& x, const V1& y); template<class V0, class V1> constexpr typename math-common-simd-t<V0, V1>::mask_type islessequal(const V0& x, const V1& y); template<class V0, class V1> constexpr typename math-common-simd-t<V0, V1>::mask_type islessgreater(const V0& x, const V1& y); template<class V0, class V1> constexpr typename math-common-simd-t<V0, V1>::mask_type isunordered(const V0& x, const V1& y);
1
#
Let Ret denote the return type of the specialization of a function template with the name math-func.
Let math-func-vec denote: template<class. Args> Ret math-func-vec(Args.. args) { return Ret([&](simd-size-type i) { return math-func(make-compatible-simd-t<Ret, Args>(args)[i].); }); }
2
#
Returns: A value ret of type Ret, that is element-wise equal to the result of calling math-func-vec with the arguments of the above functions.
If in an invocation of a scalar overload of math-func for index i in math-func-vec a domain, pole, or range error would occur, the value of ret[i] is unspecified.
3
#
Remarks: It is unspecified whether errno ([errno]) is accessed.
🔗
template<math-floating-point V> constexpr deduced-vec-t<V> acos(const V& x); template<math-floating-point V> constexpr deduced-vec-t<V> asin(const V& x); template<math-floating-point V> constexpr deduced-vec-t<V> atan(const V& x); template<class V0, class V1> constexpr math-common-simd-t<V0, V1> atan2(const V0& y, const V1& x); template<math-floating-point V> constexpr deduced-vec-t<V> cos(const V& x); template<math-floating-point V> constexpr deduced-vec-t<V> sin(const V& x); template<math-floating-point V> constexpr deduced-vec-t<V> tan(const V& x); template<math-floating-point V> constexpr deduced-vec-t<V> acosh(const V& x); template<math-floating-point V> constexpr deduced-vec-t<V> asinh(const V& x); template<math-floating-point V> constexpr deduced-vec-t<V> atanh(const V& x); template<math-floating-point V> constexpr deduced-vec-t<V> cosh(const V& x); template<math-floating-point V> constexpr deduced-vec-t<V> sinh(const V& x); template<math-floating-point V> constexpr deduced-vec-t<V> tanh(const V& x); template<math-floating-point V> constexpr deduced-vec-t<V> exp(const V& x); template<math-floating-point V> constexpr deduced-vec-t<V> exp2(const V& x); template<math-floating-point V> constexpr deduced-vec-t<V> expm1(const V& x); template<math-floating-point V> constexpr deduced-vec-t<V> log(const V& x); template<math-floating-point V> constexpr deduced-vec-t<V> log10(const V& x); template<math-floating-point V> constexpr deduced-vec-t<V> log1p(const V& x); template<math-floating-point V> constexpr deduced-vec-t<V> log2(const V& x); template<math-floating-point V> constexpr deduced-vec-t<V> logb(const V& x); template<math-floating-point V> constexpr deduced-vec-t<V> cbrt(const V& x); template<class V0, class V1> constexpr math-common-simd-t<V0, V1> hypot(const V0& x, const V1& y); template<class V0, class V1, class V2> constexpr math-common-simd-t<V0, V1, V2> hypot(const V0& x, const V1& y, const V2& z); template<class V0, class V1> constexpr math-common-simd-t<V0, V1> pow(const V0& x, const V1& y); template<math-floating-point V> constexpr deduced-vec-t<V> sqrt(const V& x); template<math-floating-point V> constexpr deduced-vec-t<V> erf(const V& x); template<math-floating-point V> constexpr deduced-vec-t<V> erfc(const V& x); template<math-floating-point V> constexpr deduced-vec-t<V> lgamma(const V& x); template<math-floating-point V> constexpr deduced-vec-t<V> tgamma(const V& x); template<class V0, class V1, class V2> constexpr math-common-simd-t<V0, V1, V2> lerp(const V0& a, const V1& b, const V2& t) noexcept; template<math-floating-point V> deduced-vec-t<V> assoc_laguerre(const rebind_t<unsigned, deduced-vec-t<V>>& n, const rebind_t<unsigned, deduced-vec-t<V>>& m, const V& x); template<math-floating-point V> deduced-vec-t<V> assoc_legendre(const rebind_t<unsigned, deduced-vec-t<V>>& l, const rebind_t<unsigned, deduced-vec-t<V>>& m, const V& x); template<class V0, class V1> math-common-simd-t<V0, V1> beta(const V0& x, const V1& y); template<math-floating-point V> deduced-vec-t<V> comp_ellint_1(const V& k); template<math-floating-point V> deduced-vec-t<V> comp_ellint_2(const V& k); template<class V0, class V1> math-common-simd-t<V0, V1> comp_ellint_3(const V0& k, const V1& nu); template<class V0, class V1> math-common-simd-t<V0, V1> cyl_bessel_i(const V0& nu, const V1& x); template<class V0, class V1> math-common-simd-t<V0, V1> cyl_bessel_j(const V0& nu, const V1& x); template<class V0, class V1> math-common-simd-t<V0, V1> cyl_bessel_k(const V0& nu, const V1& x); template<class V0, class V1> math-common-simd-t<V0, V1> cyl_neumann(const V0& nu, const V1& x); template<class V0, class V1> math-common-simd-t<V0, V1> ellint_1(const V0& k, const V1& phi); template<class V0, class V1> math-common-simd-t<V0, V1> ellint_2(const V0& k, const V1& phi); template<class V0, class V1, class V2> math-common-simd-t<V0, V1, V2> ellint_3(const V0& k, const V1& nu, const V2& phi); template<math-floating-point V> deduced-vec-t<V> expint(const V& x); template<math-floating-point V> deduced-vec-t<V> hermite(const rebind_t<unsigned, deduced-vec-t<V>>& n, const V& x); template<math-floating-point V> deduced-vec-t<V> laguerre(const rebind_t<unsigned, deduced-vec-t<V>>& n, const V& x); template<math-floating-point V> deduced-vec-t<V> legendre(const rebind_t<unsigned, deduced-vec-t<V>>& l, const V& x); template<math-floating-point V> deduced-vec-t<V> riemann_zeta(const V& x); template<math-floating-point V> deduced-vec-t<V> sph_bessel(const rebind_t<unsigned, deduced-vec-t<V>>& n, const V& x); template<math-floating-point V> deduced-vec-t<V> sph_legendre(const rebind_t<unsigned, deduced-vec-t<V>>& l, const rebind_t<unsigned, deduced-vec-t<V>>& m, const V& theta); template<math-floating-point V> deduced-vec-t<V> sph_neumann(const rebind_t<unsigned, deduced-vec-t<V>>& n, const V& x);
4
#
Let Ret denote the return type of the specialization of a function template with the name math-func.
Let math-func-vec denote: template<class. Args> Ret math-func-vec(Args.. args) { return Ret([&](simd-size-type i) { return math-func(make-compatible-simd-t<Ret, Args>(args)[i].); }); }
5
#
Returns: A value ret of type Ret, that is element-wise approximately equal to the result of calling math-func-vec with the arguments of the above functions.
If in an invocation of a scalar overload of math-func for index i in math-func-vec a domain, pole, or range error would occur, the value of ret[i] is unspecified.
6
#
Remarks: It is unspecified whether errno ([errno]) is accessed.
🔗
template<math-floating-point V> constexpr deduced-vec-t<V> frexp(const V& value, rebind_t<int, deduced-vec-t<V>>* exp);
7
#
Let Ret be deduced-vec-t<V>.
Let frexp-vec denote: template<class V> pair<Ret, rebind_t<int, Ret>> frexp-vec(const V& x) { int r1[Ret::size()]; Ret r0([&](simd-size-type i) { return frexp(make-compatible-simd-t<Ret, V>(x)[i], &r1[i]); }); return {r0, rebind_t<int, Ret>(r1)}; }
Let ret be a value of type pair<Ret, rebind_t<int, Ret>> that is the same value as the result of calling frexp-vec(x).
8
#
Returns: ret.first.
🔗
template<class V0, class V1> constexpr math-common-simd-t<V0, V1> remquo(const V0& x, const V1& y, rebind_t<int, math-common-simd-t<V0, V1>>* quo);
10
#
Let Ret be math-common-simd-t<V0, V1>.
Let remquo-vec denote: template<class V0, class V1> pair<Ret, rebind_t<int, Ret>> remquo-vec(const V0& x, const V1& y) { int r1[Ret::size()]; Ret r0([&](simd-size-type i) { return remquo(make-compatible-simd-t<Ret, V0>(x)[i], make-compatible-simd-t<Ret, V1>(y)[i], &r1[i]); }); return {r0, rebind_t<int, Ret>(r1)}; }
Let ret be a value of type pair<Ret, rebind_t<int, Ret>> that is the same value as the result of calling remquo-vec(x, y).
If in an invocation of a scalar overload of remquo for index i in remquo-vec a domain, pole, or range error would occur, the value of ret[i] is unspecified.
11
#
Remarks: It is unspecified whether errno ([errno]) is accessed.
🔗
template<class T, class Abi> constexpr basic_vec<T, Abi> modf(const type_identity_t<basic_vec<T, Abi>>& value, basic_vec<T, Abi>* iptr);
14
#
Let V be basic_vec<T, Abi>.
Let modf-vec denote: pair<V, V> modf-vec(const V& x) { T r1[Ret::size()]; V r0([&](simd-size-type i) { return modf(V(x)[i], &r1[i]); }); return {r0, V(r1)}; }
Let ret be a value of type pair<V, V> that is the same value as the result of calling modf-vec(value).
15
#
Returns: ret.first.

29.10.8.14 Bit manipulation [simd.bit]

🔗
template<simd-vec-type V> constexpr V byteswap(const V& v) noexcept;
1
#
Returns: A basic_vec object where the
🔗
template<simd-vec-type V> constexpr V bit_ceil(const V& v);
3
#
Preconditions: For every i in the range [0, V​::​size()), the smallest power of 2 greater than or equal to v[i] is representable as a value of type V​::​value_type.
5
#
Returns: A basic_vec object where the
6
#
Remarks: A function call expression that violates the precondition in the Preconditions: element is not a core constant expression ([expr.const]).
🔗
template<simd-vec-type V> constexpr V bit_floor(const V& v) noexcept;
7
#
Returns: A basic_vec object where the
🔗
template<simd-vec-type V> constexpr typename V::mask_type has_single_bit(const V& v) noexcept;
9
#
Returns: A basic_mask object where the
🔗
template<simd-vec-type V0, simd-vec-type V1> constexpr V0 rotl(const V0& v0, const V1& v1) noexcept; template<simd-vec-type V0, simd-vec-type V1> constexpr V0 rotr(const V0& v0, const V1& v1) noexcept;
11
#
Returns: A basic_vec object where the
🔗
template<simd-vec-type V> constexpr V rotl(const V& v, int s) noexcept; template<simd-vec-type V> constexpr V rotr(const V& v, int s) noexcept;
13
#
Returns: A basic_vec object where the
🔗
template<simd-vec-type V> constexpr rebind_t<make_signed_t<typename V::value_type>, V> bit_width(const V& v) noexcept; template<simd-vec-type V> constexpr rebind_t<make_signed_t<typename V::value_type>, V> countl_zero(const V& v) noexcept; template<simd-vec-type V> constexpr rebind_t<make_signed_t<typename V::value_type>, V> countl_one(const V& v) noexcept; template<simd-vec-type V> constexpr rebind_t<make_signed_t<typename V::value_type>, V> countr_zero(const V& v) noexcept; template<simd-vec-type V> constexpr rebind_t<make_signed_t<typename V::value_type>, V> countr_one(const V& v) noexcept; template<simd-vec-type V> constexpr rebind_t<make_signed_t<typename V::value_type>, V> popcount(const V& v) noexcept;
15
#
Returns: A basic_vec object where the
🔗
template<simd-complex V> constexpr rebind_t<simd-complex-value-type<V>, V> real(const V&) noexcept; template<simd-complex V> constexpr rebind_t<simd-complex-value-type<V>, V> imag(const V&) noexcept; template<simd-complex V> constexpr rebind_t<simd-complex-value-type<V>, V> abs(const V&); template<simd-complex V> constexpr rebind_t<simd-complex-value-type<V>, V> arg(const V&); template<simd-complex V> constexpr rebind_t<simd-complex-value-type<V>, V> norm(const V&); template<simd-complex V> constexpr V conj(const V&); template<simd-complex V> constexpr V proj(const V&); template<simd-complex V> constexpr V exp(const V& v); template<simd-complex V> constexpr V log(const V& v); template<simd-complex V> constexpr V log10(const V& v); template<simd-complex V> constexpr V sqrt(const V& v); template<simd-complex V> constexpr V sin(const V& v); template<simd-complex V> constexpr V asin(const V& v); template<simd-complex V> constexpr V cos(const V& v); template<simd-complex V> constexpr V acos(const V& v); template<simd-complex V> constexpr V tan(const V& v); template<simd-complex V> constexpr V atan(const V& v); template<simd-complex V> constexpr V sinh(const V& v); template<simd-complex V> constexpr V asinh(const V& v); template<simd-complex V> constexpr V cosh(const V& v); template<simd-complex V> constexpr V acosh(const V& v); template<simd-complex V> constexpr V tanh(const V& v); template<simd-complex V> constexpr V atanh(const V& v);
1
#
Returns: A basic_vec object ret where the
If in an invocation of cmplx-func for index i a domain, pole, or range error would occur, the value of ret[i] is unspecified.
2
#
Remarks: It is unspecified whether errno ([errno]) is accessed.
🔗
template<simd-floating-point V> rebind_t<complex<typename V::value_type>, V> polar(const V& x, const V& y = {}); template<simd-complex V> constexpr V pow(const V& x, const V& y);
3
#
Returns: A basic_vec object ret where the
If in an invocation of cmplx-func for index i a domain, pole, or range error would occur, the value of ret[i] is unspecified.
4
#
Remarks: It is unspecified whether errno ([errno]) is accessed.

29.10.9 Class template basic_mask [simd.mask.class]

namespace std::simd { template<size_t Bytes, class Abi> class basic_mask { public: using value_type = bool; using abi_type = Abi; using iterator = simd-iterator<basic_mask>; using const_iterator = simd-iterator<const basic_mask>; constexpr iterator begin() noexcept { return {*this, 0}; } constexpr const_iterator begin() const noexcept { return {*this, 0}; } constexpr const_iterator cbegin() const noexcept { return {*this, 0}; } constexpr default_sentinel_t end() const noexcept { return {}; } constexpr default_sentinel_t cend() const noexcept { return {}; } static constexpr integral_constant<simd-size-type, simd-size-v<integer-from<Bytes>, Abi>> size {}; constexpr basic_mask() noexcept = default; / [simd.mask.ctor], basic_mask constructors constexpr explicit basic_mask(same_as<value_type> auto) noexcept; template<size_t UBytes, class UAbi> constexpr explicit basic_mask(const basic_mask<UBytes, UAbi>&) noexcept; template<class G> constexpr explicit basic_mask(G&& gen); template<same_as<bitset<size()> T> constexpr basic_mask(const T& b) noexcept; template<unsigned_integral T> requires (!same_as<T, value_type>) constexpr explicit basic_mask(T val) noexcept; / [simd.mask.subscr], basic_mask subscript operators constexpr value_type operator[](simd-size-type) const; template<simd-integral I> constexpr resize_t<I::size(), basic_mask> operator[](const I& indices) const; / [simd.mask.unary], basic_mask unary operators constexpr basic_mask operator!() const noexcept; constexpr see below operator+() const noexcept; constexpr see below operator-() const noexcept; constexpr see below operator~() const noexcept; / [simd.mask.conv], basic_mask conversions template<class U, class A> constexpr explicit(sizeof(U) != Bytes) operator basic_vec<U, A>() const noexcept; constexpr bitset<size()> to_bitset() const noexcept; constexpr unsigned long to_ullong() const; / [simd.mask.binary], basic_mask binary operators friend constexpr basic_mask operator&(const basic_mask&, const basic_mask&) noexcept; friend constexpr basic_mask operator|(const basic_mask&, const basic_mask&) noexcept; friend constexpr basic_mask operator&(const basic_mask&, const basic_mask&) noexcept; friend constexpr basic_mask operator|(const basic_mask&, const basic_mask&) noexcept; friend constexpr basic_mask operator^(const basic_mask&, const basic_mask&) noexcept; / [simd.mask.cassign], basic_mask compound assignment friend constexpr basic_mask& operator&=(basic_mask&, const basic_mask&) noexcept; friend constexpr basic_mask& operator|=(basic_mask&, const basic_mask&) noexcept; friend constexpr basic_mask& operator^=(basic_mask&, const basic_mask&) noexcept; / [simd.mask.comparison], basic_mask comparisons friend constexpr basic_mask operator=(const basic_mask&, const basic_mask&) noexcept; friend constexpr basic_mask operator!=(const basic_mask&, const basic_mask&) noexcept; friend constexpr basic_mask operator>=(const basic_mask&, const basic_mask&) noexcept; friend constexpr basic_mask operator<=(const basic_mask&, const basic_mask&) noexcept; friend constexpr basic_mask operator>(const basic_mask&, const basic_mask&) noexcept; friend constexpr basic_mask operator<(const basic_mask&, const basic_mask&) noexcept; / [simd.mask.cond], basic_mask exposition only conditional operators friend constexpr basic_mask simd-select-impl( / exposition only const basic_mask&, const basic_mask&, const basic_mask&) noexcept; friend constexpr basic_mask simd-select-impl( / exposition only const basic_mask&, same_as<bool> auto, same_as<bool> auto) noexcept; template<class T0, class T1> friend constexpr vec<see below, size()> simd-select-impl(const basic_mask&, const T0&, const T1&) noexcept; / exposition only }; }
1
#
Every specialization of basic_mask is a complete type.
The specialization of basic_mask<Bytes, Abi> is:
  • (1.1)
    disabled, if there is no vectorizable type T such that Bytes is equal to sizeof(T),
  • (1.2)
    otherwise, enabled, if there exists a vectorizable type T and a value N in the range [1, 64] such that Bytes is equal to sizeof(T) and Abi is deduce-abi-t<T, N>,
  • (1.3)
    otherwise, it is implementation-defined if such a specialization is enabled.
If basic_mask<Bytes, Abi> is disabled, the specialization has a deleted default constructor, deleted destructor, deleted copy constructor, and deleted copy assignment.
In addition only the value_type and abi_type members are present.
If basic_mask<Bytes, Abi> is enabled, basic_mask<Bytes, Abi> is trivially copyable.
2
#
Recommended practice: Implementations should support implicit conversions between specializations of basic_mask and appropriate implementation-defined types.
[Note 1: 
Appropriate types are non-standard vector types which are available in the implementation.
— end note]
🔗
constexpr explicit basic_mask(same_as<value_type> auto) noexcept;
1
#
Effects: Initializes each element with x.
🔗
template<size_t UBytes, class UAbi> constexpr explicit basic_mask(const basic_mask<UBytes, UAbi>& x) noexcept;
2
#
Constraints: basic_mask<UBytes, UAbi>​::​size() == size() is true.
3
#
Effects: Initializes the
🔗
template<class G> constexpr explicit basic_mask(G&& gen);
4
#
Constraints: The expression gen(integral_constant<simd-size-type, i>() is well-formed and its type is bool for all i in the range of [0, size()).
5
#
Effects: Initializes the
6
#
Remarks: gen is invoked exactly once for each i, in increasing order of i.
🔗
template<same_as<bitset<size()> T> constexpr basic_mask(const T& b) noexcept;
7
#
Effects: Initializes the
🔗
template<unsigned_integral T> requires (!same_as<T, value_type>) constexpr explicit basic_mask(T val) noexcept;
8
#
Effects: Initializes the first M elements to the corresponding bit values in val, where M is the smaller of size() and the number of bits in the value representation ([basic.types.general]) of the type of val.
If M is less than size(), the remaining elements are initialized to zero.

29.10.9.3 Subscript operator [simd.mask.subscr]

🔗
constexpr value_type operator[](simd-size-type i) const;
1
#
Throws: Nothing.
🔗
template<simd-integral I> constexpr resize_t<I::size(), basic_mask> operator[](const I& indices) const;
4
#
Effects: Equivalent to: return permute(*this, indices);
🔗
constexpr basic_mask operator!() const noexcept; constexpr see below operator+() const noexcept; constexpr see below operator-() const noexcept; constexpr see below operator~() const noexcept;
1
#
Returns: A data-parallel object where the
3
#
Remarks: If there exists a vectorizable signed integer type I such that sizeof(I) == Bytes is true, operator+, operator-, and operator return an enabled specialization R of basic_vec such that R​::​value_type denotes integer-from<Bytes> and R​::​size() == size() is true.
Otherwise, these operators are defined as deleted and their return types are unspecified.
🔗
template<class U, class A> constexpr explicit(sizeof(U) != Bytes) operator basic_vec<U, A>() const noexcept;
1
#
Returns: A data-parallel object where the
🔗
constexpr bitset<size()> to_bitset() const noexcept;
3
#
Returns: A bitset<size()> object where the
🔗
constexpr unsigned long to_ullong() const;
4
#
Throws: Nothing.

29.10.10 basic_mask non-member operations [simd.mask.nonmembers]

🔗
friend constexpr basic_mask operator&(const basic_mask& lhs, const basic_mask& rhs) noexcept; friend constexpr basic_mask operator|(const basic_mask& lhs, const basic_mask& rhs) noexcept; friend constexpr basic_mask operator& (const basic_mask& lhs, const basic_mask& rhs) noexcept; friend constexpr basic_mask operator| (const basic_mask& lhs, const basic_mask& rhs) noexcept; friend constexpr basic_mask operator^ (const basic_mask& lhs, const basic_mask& rhs) noexcept;
1
#
Returns: A basic_mask object initialized with the results of applying op to lhs and rhs as a binary element-wise operation.

29.10.10.2 Compound assignment [simd.mask.cassign]

🔗
friend constexpr basic_mask& operator&=(basic_mask& lhs, const basic_mask& rhs) noexcept; friend constexpr basic_mask& operator|=(basic_mask& lhs, const basic_mask& rhs) noexcept; friend constexpr basic_mask& operator^=(basic_mask& lhs, const basic_mask& rhs) noexcept;
1
#
Effects: These operators apply op to lhs and rhs as a binary element-wise operation.
3
#
Returns: lhs.
🔗
friend constexpr basic_mask operator=(const basic_mask& lhs, const basic_mask& rhs) noexcept; friend constexpr basic_mask operator!=(const basic_mask& lhs, const basic_mask& rhs) noexcept; friend constexpr basic_mask operator>=(const basic_mask& lhs, const basic_mask& rhs) noexcept; friend constexpr basic_mask operator<=(const basic_mask& lhs, const basic_mask& rhs) noexcept; friend constexpr basic_mask operator>(const basic_mask& lhs, const basic_mask& rhs) noexcept; friend constexpr basic_mask operator<(const basic_mask& lhs, const basic_mask& rhs) noexcept;
1
#
Returns: A basic_mask object initialized with the results of applying op to lhs and rhs as a binary element-wise operation.

29.10.10.4 Exposition-only conditional operators [simd.mask.cond]

🔗
friend constexpr basic_mask simd-select-impl( const basic_mask& mask, const basic_mask& a, const basic_mask& b) noexcept;
1
#
Returns: A basic_mask object where the
🔗
friend constexpr basic_mask simd-select-impl(const basic_mask& mask, same_as<bool> auto a, same_as<bool> auto b) noexcept;
2
#
Returns: A basic_mask object where the
🔗
template<class T0, class T1> friend constexpr vec<see below, size()> simd-select-impl(const basic_mask& mask, const T0& a, const T1& b) noexcept;
3
#
Returns: A vec<T0, size()> object where the
🔗
template<size_t Bytes, class Abi> constexpr bool all_of(const basic_mask<Bytes, Abi>& k) noexcept;
1
#
Returns: true if all boolean elements in k are true, otherwise false.
🔗
template<size_t Bytes, class Abi> constexpr bool any_of(const basic_mask<Bytes, Abi>& k) noexcept;
2
#
Returns: true if at least one boolean element in k is true, otherwise false.
🔗
template<size_t Bytes, class Abi> constexpr bool none_of(const basic_mask<Bytes, Abi>& k) noexcept;
3
#
Returns: !any_of(k).
🔗
template<size_t Bytes, class Abi> constexpr simd-size-type reduce_count(const basic_mask<Bytes, Abi>& k) noexcept;
4
#
Returns: The number of boolean elements in k that are true.
🔗
template<size_t Bytes, class Abi> constexpr simd-size-type reduce_min_index(const basic_mask<Bytes, Abi>& k);
5
#
Returns: The lowest element index i where k[i] is true.
🔗
template<size_t Bytes, class Abi> constexpr simd-size-type reduce_max_index(const basic_mask<Bytes, Abi>& k);
7
#
Returns: The greatest element index i where k[i] is true.
🔗
constexpr bool all_of(same_as<bool> auto x) noexcept; constexpr bool any_of(same_as<bool> auto x) noexcept; constexpr simd-size-type reduce_count(same_as<bool> auto x) noexcept;
9
#
Returns: x.
🔗
constexpr bool none_of(same_as<bool> auto x) noexcept;
10
#
Returns: !x.
🔗
constexpr simd-size-type reduce_min_index(same_as<bool> auto x); constexpr simd-size-type reduce_max_index(same_as<bool> auto x);
11
#
Returns: 0.

Follow Lee on X/Twitter - Father, Husband, Serial builder creating AI, crypto, games & web tools. We are friends :) AI Will Come To Life!

Check out: eBank.nz (Art Generator) | Netwrck.com (AI Tools) | Text-Generator.io (AI API) | BitBank.nz (Crypto AI) | ReadingTime (Kids Reading) | RewordGame | BigMultiplayerChess | WebFiddle | How.nz | Helix AI Assistant