29 Numerics library [numerics]

29.10 Data-parallel types [simd]

29.10.8 basic_vec non-member operations [simd.nonmembers]

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

Effects: Equivalent to: return partial_load<V>(r, mask, f);

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.

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

Effects: Initializes the

i^{th}

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

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> && indirectly_writable<ranges::iterator_t<R>, T>
  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> && indirectly_writable<ranges::iterator_t<R>, T>
  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>
  requires indirectly_writable<I, T>
  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>
  requires indirectly_writable<I, T>
  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>
  requires indirectly_writable<I, T>
  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>
  requires indirectly_writable<I, T>
  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> && indirectly_writable<ranges::iterator_t<R>, T>
  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> && indirectly_writable<ranges::iterator_t<R>, T>
  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>
  requires indirectly_writable<I, T>
  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>
  requires indirectly_writable<I, T>
  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>
  requires indirectly_writable<I, T>
  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>
  requires indirectly_writable<I, T>
  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.

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 T to ranges::range_value_t<R> is value-preserving.

Preconditions:

(17.1)
[first, first + n) is a valid range for the overloads with an n parameter.
(17.2)
[first, last) is a valid range for the overloads with a last parameter.
(17.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>>.
(17.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] = v[i].