[simd.nonmembers]

🔗

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;

Constraints: requires (value_type a, value_type b) { a op b; } is true.

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;

Constraints: requires (value_type a, simd-size-type b) { a op b; } is true.

Returns: A basic_vec object where the

{i th element is initialized to the result of applying op to v [i] and n for all i in the range of [0, size ()) .}^{th element is initialized to the result of applying op to v [i] and n for all i in the range of [0, size ()) .}

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;

Constraints: requires (value_type a, value_type b) { a op b; } is true.

Effects: These operators apply the indicated operator to lhs and rhs as an element-wise operation.

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;

Constraints: requires (value_type a, simd-size-type b) { a op b; } is true.

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;

Constraints: requires (value_type a, value_type b) { a op b; } is true.

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;

Returns: A basic_vec object where the

{i th element equals mask [i] ? a [i] : b [i] for all i in the range of [0, size ()) .}^{th element equals mask [i] ? a [i] : b [i] for all i in the range of [0, size ()) .}

29.10.8.5 Reductions [simd.reductions]

🔗

template<class T, class Abi, class BinaryOperation = plus<>
  constexpr T reduce(const basic_vec<T, Abi>& x, BinaryOperation binary_op = {});

Constraints: BinaryOperation models reduction-binary-operation<T>.

Returns: GENERALIZED_SUM(binary_op, vec<T, 1>(x[0]), …, vec<T, 1>(x[x.size() - 1])[0] ([numerics.defns]).

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);

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<>.

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.

Returns: If none_of(mask) is true, returns identity_element.

Otherwise, returns GENERALIZED_SUM(binary_op, vec<T, 1>(x[

{k 0]), \dots, vec < T, 1 > (x [{k n]) [0] where {k 0, \dots, {k n are the selected indices of mask .}_{n are the selected indices of mask .}}_{0, \dots, {k n are the selected indices of mask .}_{n are the selected indices of mask .}}}_{n]) [0]}}_{0]), \dots, vec < T, 1 > (x [{k n]) [0] where {k 0, \dots, {k n are the selected indices of mask .}_{n are the selected indices of mask .}}_{0, \dots, {k n are the selected indices of mask .}_{n are the selected indices of mask .}}}_{n]) [0]}}

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;

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;

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;

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;

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 = {});

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.

Mandates: If ranges::size(r) is a constant expression then ranges::size(r) ≥ V::size().

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()

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 = {});

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.

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.

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.

Returns: A basic_vec object whose

{i th element is initialized with mask [i] & & i < ranges ​::​ size (r) ? static_cast < T > (​ranges ​::​ data (r) [i]) : T () for all i in the range of [0, V ​::​ size ()), where T is V ​::​ value_type .}^{th element is initialized with mask [i] & & i < ranges ​::​ size (r) ? static_cast < T > (​ranges ​::​ data (r) [i]) : T () for all i in the range of [0, V ​::​ size ()), where T is V ​::​ value_type .}

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 = {});

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.

Mandates: If ranges::size(r) is a constant expression then ranges::size(r) ≥ simd-size-v<T, Abi>.

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>

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 = {});

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.

Constraints:

(16.1)
ranges::iterator_t<R> models indirectly_writable<ranges::range_value_t<R>>, and
(16.2)
T satisfies explicitly-convertible-to<ranges::range_value_t<R>>.

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.

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.

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]).

29.10.8.7 Static permute [simd.permute.static]

🔗

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);

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]; } }

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 .

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).

Returns: A data-parallel object where the

{i th element is initialized to the result of perm-fn < i > () for all i in the range [0, N) .}^{th element is initialized to the result of perm-fn < i > () for all i in the range [0, N) .}

Remarks: The default argument for template parameter N is V::size().

29.10.8.8 Dynamic permute [simd.permute.dynamic]

🔗

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);

Returns: A data-parallel object where the

{i th element is initialized to the result of v [indices [i] for all i in the range [0, I ​::​ size ()) .}^{th element is initialized to the result of v [indices [i] for all i in the range [0, I ​::​ size ()) .}

29.10.8.9 Mask permute [simd.permute.mask]

🔗

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);

Let:

(1.1)
bit-index(i) be a function which returns the index of the ${i th element of selector that is true .}^{th element of selector that is true .}$
(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]

Returns: A data-parallel object where the

{i th element is initialized to the result of select-value (i) for all i in the range [0, V ​::​ size ()) .}^{th element is initialized to the result of select-value (i) for all i in the range [0, V ​::​ size ()) .}

🔗

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);

Let:

(3.1)
bit-index(i) be a function which returns the index of the ${i th element of selector that is true .}^{th element of selector that is true .}$
(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.

Returns: A data-parallel object where the

{i th element is initialized to the result of select-value (i) for all i in the range [0, V ​::​ size ()) .}^{th element is initialized to the result of select-value (i) for all i in the range [0, V ​::​ size ()) .}

🔗

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 = {});

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].

Returns: A data-parallel object where the

{i th element is initialized to the result of select-value (i) for all i in the range [0, V ​::​ size ()) .}^{th element is initialized to the result of select-value (i) for all i in the range [0, V ​::​ size ()) .}

29.10.8.10 Memory permute [simd.permute.memory]

🔗

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 = {});

Let mask be typename I::mask_type(true) for the overload with no mask parameter.

Preconditions: All values in select(mask, indices, typename I::value_type() are in the range [0, ranges::size(in)).

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 = {});

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.

Constraints: ranges::range_value_t<R> is a vectorizable type and satisfies explicitly-convertible-to<T>.

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.

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.

Returns: A basic_vec object where the

{i th element is initialized to the result of mask [i] & & indices [i] < ranges :: size (in) ? static_cast < T > (ranges :: data (in) [indices [i]) : T () for all i in the range [0, I ​::​ size ()) .}^{th element is initialized to the result of mask [i] & & indices [i] < ranges :: size (in) ? static_cast < T > (ranges :: data (in) [indices [i]) : T () for all i in the range [0, I ​::​ size ()) .}

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 = {});

Let mask be typename I::mask_type(true) for the overload with no mask parameter.

Preconditions: All values in select(mask, indices, typename I::value_type() are in the range [0, ranges::size(out)).

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 = {});

Let mask be typename I::mask_type(true) for the overload with no mask parameter.

Constraints:

(15.1)
V::size() == I::size() is true,
(15.2)
ranges::iterator_t<R> models indirectly_writable<ranges::range_value_t<R>>, and
(15.3)
typename V::value_type satisfies explicitly-convertible-to<ranges::range_value_t<R
>>.

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.

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.

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]).

29.10.8.11 Creation [simd.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;

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.

Returns:

(3.1)
If x.size() % T::size() == 0 is true, an array<T, N> with the ${i th basic_vec or basic_mask element of the {j th array element initialized to the value of the element in x with index i + j * T :: size () .}^{th array element initialized to the value of the element in x with index i + j * T :: size () .}}^{th basic_vec or basic_mask element of the {j th array element initialized to the value of the element in x with index i + j * T :: size () .}^{th array element initialized to the value of the element in x with index i + j * T :: size () .}}$
(3.2)
Otherwise, a tuple of N objects of type T and one object of type resize_t<x.size() % T::size(), T>.

The ${i th basic_vec or basic_mask element of the {j th tuple element of type T is initialized to the value of the element in x with index i + j * T :: size () .}^{th tuple element of type T is initialized to the value of the element in x with index i + j * T :: size () .}}^{th basic_vec or basic_mask element of the {j th tuple element of type T is initialized to the value of the element in x with index i + j * T :: size () .}^{th tuple element of type T is initialized to the value of the element in x with index i + j * T :: size () .}}$

The ${i th basic_vec or basic_mask element of the {N th tuple element is initialized to the value of the element in x with index i + N * T :: size () .}^{th tuple element is initialized to the value of the element in x with index i + N * T :: size () .}}^{th basic_vec or basic_mask element of the {N th tuple element is initialized to the value of the element in x with index i + N * T :: size () .}^{th tuple element is initialized to the value of the element in x with index i + N * T :: size () .}}$

🔗

template<simd-size-type N, class T, class Abi>
  constexpr auto chunk(const basic_vec<T, Abi>& x) noexcept;

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;

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;

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.

Returns: A data-parallel object initialized with the concatenated values in the xs pack of data-parallel objects: The

{i th basic_vec / basic_mask element of the {j th parameter in the xs pack is copied to the return value's element with index i + the sum of the width of the first j parameters in the xs pack .}^{th parameter in the xs pack is copied to the return value's element with index i + the sum of the width of the first j parameters in the xs pack .}}^{th basic_vec / basic_mask element of the {j th parameter in the xs pack is copied to the return value's element with index i + the sum of the width of the first j parameters in the xs pack .}^{th parameter in the xs pack is copied to the return value's element with index i + the sum of the width of the first j parameters in the xs pack .}}

29.10.8.12 Algorithms [simd.alg]

🔗

template<class T, class Abi>
  constexpr basic_vec<T, Abi> min(const basic_vec<T, Abi>& a,
                                  const basic_vec<T, Abi>& b) noexcept;

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;

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;

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);

Preconditions: No element in lo is greater than the corresponding element in hi.

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)>;

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));

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);

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].); }); }

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.

Remarks: It is unspecified whether errno ([errno]) is accessed.

29 Numerics library [numerics]

29.10 Data-parallel types [simd]

29.10.8 basic_vec non-member operations [simd.nonmembers]

29.10.8.1 Binary operators [simd.binary]

29.10.8.2 Compound assignment [simd.cassign]

29.10.8.3 Comparison operators [simd.comparison]

29.10.8.4 Exposition-only conditional operators [simd.cond]

29.10.8.5 Reductions [simd.reductions]

29.10.8.6 Load and store functions [simd.loadstore]

29.10.8.7 Static permute [simd.permute.static]

29.10.8.8 Dynamic permute [simd.permute.dynamic]

29.10.8.9 Mask permute [simd.permute.mask]

29.10.8.10 Memory permute [simd.permute.memory]

29.10.8.11 Creation [simd.creation]

29.10.8.12 Algorithms [simd.alg]

29.10.8.13 Mathematical functions [simd.math]

29.10.8.14 Bit manipulation [simd.bit]

29.10.8.15 Complex math [simd.complex.math]

29.10.8.1 Binary operators [simd.binary]

29.10.8.2 Compound assignment [simd.cassign]

29.10.8.3 Comparison operators [simd.comparison]

29.10.8.4 Exposition-only conditional operators [simd.cond]

29.10.8.5 Reductions [simd.reductions]

29.10.8.6 Load and store functions [simd.loadstore]

29.10.8.7 Static permute [simd.permute.static]

29.10.8.8 Dynamic permute [simd.permute.dynamic]

29.10.8.9 Mask permute [simd.permute.mask]

29.10.8.10 Memory permute [simd.permute.memory]

29.10.8.11 Creation [simd.creation]

29.10.8.12 Algorithms [simd.alg]

29.10.8.13 Mathematical functions [simd.math]

29.10.8.14 Bit manipulation [simd.bit]

29.10.8.15 Complex math [simd.complex.math]