29 Numerics library [numerics]

29.10 Data-parallel types [simd]

29.10.8 basic_vec non-member operations [simd.nonmembers]

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

Effects: Equivalent to: return partial_gather_from<V>(in, mask, indices, f);

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.

Mandates:

(6.1)
ranges::range_value_t<R> is a vectorizable type,
(6.2)
same_as<remove_cvref_t<V>, V> is true,
(6.3)
V is an enabled specialization of basic_vec,
(6.4)
V::size() == I::size() is true, and
(6.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:

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

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: V::size() == I::size() is true.

Mandates:

(15.1)
ranges::range_value_t<R> is a vectorizable type, and
(15.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:

(16.1)
For all selected indices i the values indices[i] are unique.
(16.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>>.
(16.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]] = v[i].