From 03c552493f1219207556fbab4799de6760639912 Mon Sep 17 00:00:00 2001 From: Matthias Kretz Date: Mon, 23 Jun 2025 12:30:11 +0200 Subject: [PATCH 1/5] P3691R1 Reconsider naming of the namespace for std::simd --- source/numerics.tex | 1315 +++++++++++++++++++++---------------------- 1 file changed, 650 insertions(+), 665 deletions(-) diff --git a/source/numerics.tex b/source/numerics.tex index 5a11a8b523..7664a8fd6c 100644 --- a/source/numerics.tex +++ b/source/numerics.tex @@ -16173,11 +16173,11 @@ \pnum The term \defnadj{data-parallel}{type} refers to all enabled specializations of -the \tcode{basic_simd} and \tcode{basic_simd_mask} class templates. +the \tcode{basic_vec} and \tcode{basic_mask} class templates. A \defnadj{data-parallel}{object} is an object of data-parallel type. \pnum -Each specialization of \tcode{basic_simd} or \tcode{basic_simd_mask} is either +Each specialization of \tcode{basic_vec} or \tcode{basic_mask} is either enabled or disabled, as described in \ref{simd.overview} and \ref{simd.mask.overview}. @@ -16199,7 +16199,7 @@ objects. \pnum -Given a \tcode{basic_simd_mask} object \tcode{mask}, the +Given a \tcode{basic_mask} object \tcode{mask}, the \defnadj{selected}{indices} signify the integers $i$ in the range \range{0}{mask.size()} for which \tcode{mask[$i$]} is \tcode{true}. Given a data-parallel object \tcode{data}, the \defnadj{selected}{elements} @@ -16233,12 +16233,12 @@ template concept @\defexposconceptnc{simd-vec-type}@ = // \expos - @\libconcept{same_as}@> && + @\libconcept{same_as}@> && is_default_constructible_v; template concept @\defexposconceptnc{simd-mask-type}@ = // \expos - @\libconcept{same_as}@, typename V::abi_type>> && + @\libconcept{same_as}@, typename V::abi_type>> && is_default_constructible_v; template @@ -16305,8 +16305,8 @@ \begin{itemdescr} \pnum -\tcode{\exposid{simd-size-v}} denotes the width of \tcode{basic_simd} if the specialization \tcode{basic_simd} is enabled, or \tcode{0} +\tcode{\exposid{simd-size-v}} denotes the width of \tcode{basic_vec} if the specialization \tcode{basic_vec} is enabled, or \tcode{0} otherwise. \end{itemdescr} @@ -16316,7 +16316,7 @@ \begin{itemdescr} \pnum -\tcode{\exposid{mask-element-size}>} has the value +\tcode{\exposid{mask-element-size}>} has the value \tcode{Bytes}. \end{itemdescr} @@ -16333,7 +16333,7 @@ \begin{itemize} \item \tcode{decltype(x + x)}, if the type of \tcode{x + x} is an enabled - specialization of \tcode{basic_simd}; otherwise + specialization of \tcode{basic_vec}; otherwise \item \tcode{void}. \end{itemize} @@ -16354,7 +16354,7 @@ \tcode{\exposid{deduced-simd-t}}, if that type is not \tcode{void}, otherwise \item - \tcode{simd}. + \tcode{vec}. \end{itemize} \end{itemdescr} @@ -16402,8 +16402,8 @@ \begin{itemdecl} template concept @\defexposconcept{reduction-binary-operation}@ = - requires (const BinaryOperation binary_op, const simd v) { - { binary_op(v, v) } -> @\libconcept{same_as}@>; + requires (const BinaryOperation binary_op, const vec v) { + { binary_op(v, v) } -> @\libconcept{same_as}@>; }; \end{itemdecl} @@ -16416,8 +16416,8 @@ operation is commutative. \item An object of type \tcode{BinaryOperation} can be invoked with two -arguments of type \tcode{basic_simd}, with unspecified ABI tag -\tcode{Abi}, returning a \tcode{basic_simd}. +arguments of type \tcode{basic_vec}, with unspecified ABI tag +\tcode{Abi}, returning a \tcode{basic_vec}. \end{itemize} \end{itemdescr} @@ -16457,7 +16457,7 @@ \item \tcode{N} is greater than zero, and \item \tcode{N} is not larger than an implementation-defined maximum. \end{itemize} -The \impldef{maximum width for \tcode{simd} and \tcode{simd_mask}} maximum for +The \impldef{maximum width for \tcode{vec} and \tcode{mask}} maximum for \tcode{N} is not smaller than 64 and can differ depending on \tcode{T}. \pnum @@ -16466,17 +16466,17 @@ \begin{itemize} \item \tcode{\exposid{simd-size-v}>} equals - \tcode{N}, \item \tcode{basic_simd>} is + \tcode{N}, \item \tcode{basic_vec>} is enabled\iref{simd.overview}, and \item - \tcode{basic_simd_mask, N>>} is enabled. \end{itemize} \pnum \tcode{\exposid{native-abi}} is an \impldef{default ABI tag for -\tcode{basic_simd} and \tcode{basic_simd_mask}} alias for an ABI tag. -\tcode{basic_simd>} is an enabled specialization. +\tcode{basic_vec} and \tcode{basic_mask}} alias for an ABI tag. +\tcode{basic_vec>} is an enabled specialization. \begin{note} The intent is to use the ABI tag producing the most efficient data-parallel execution for the element type \tcode{T} on the currently targeted system. @@ -16499,7 +16499,7 @@ \rSec2[simd.syn]{Header \tcode{} synopsis} \indexheader{simd}% \begin{codeblock} -namespace std::datapar { +namespace std::simd { // \ref{simd.traits}, \tcode{simd} type traits template struct alignment; template @@ -16522,17 +16522,17 @@ template class @\exposidnc{simd-iterator}@; // \expos - // \ref{simd.class}, Class template \tcode{basic_simd} - template> class basic_simd; + // \ref{simd.class}, Class template \tcode{basic_vec} + template> class basic_vec; template>> - using simd = basic_simd>; + using vec = basic_vec>; - // \ref{simd.mask.class}, Class template \tcode{basic_simd_mask} - template>> class basic_simd_mask; + // \ref{simd.mask.class}, Class template \tcode{basic_mask} + template>> class basic_mask; template>> - using simd_mask = basic_simd_mask>; + using mask = basic_mask>; - // \ref{simd.loadstore}, \tcode{basic_simd} load and store functions + // \ref{simd.loadstore}, \tcode{basic_vec} load and store functions template requires ranges::@\libconcept{sized_range}@ constexpr V unchecked_load(R&& r, flags f = {}); @@ -16572,55 +16572,55 @@ template requires ranges::@\libconcept{sized_range}@ && @\libconcept{indirectly_writable}@, T> - constexpr void unchecked_store(const basic_simd& v, R&& r, + constexpr void unchecked_store(const basic_vec& v, R&& r, flags f = {}); template requires ranges::@\libconcept{sized_range}@ && @\libconcept{indirectly_writable}@, T> - constexpr void unchecked_store(const basic_simd& v, R&& r, - const typename basic_simd::mask_type& mask, flags f = {}); + constexpr void unchecked_store(const basic_vec& v, R&& r, + const typename basic_vec::mask_type& mask, flags f = {}); template requires @\libconcept{indirectly_writable}@ - constexpr void unchecked_store(const basic_simd& v, I first, + constexpr void unchecked_store(const basic_vec& v, I first, iter_difference_t n, flags f = {}); template requires @\libconcept{indirectly_writable}@ - constexpr void unchecked_store(const basic_simd& v, I first, - iter_difference_t n, const typename basic_simd::mask_type& mask, + constexpr void unchecked_store(const basic_vec& v, I first, + iter_difference_t n, const typename basic_vec::mask_type& mask, flags f = {}); template S, class... Flags> requires @\libconcept{indirectly_writable}@ - constexpr void unchecked_store(const basic_simd& v, I first, S last, + constexpr void unchecked_store(const basic_vec& v, I first, S last, flags f = {}); template S, class... Flags> requires @\libconcept{indirectly_writable}@ - constexpr void unchecked_store(const basic_simd& v, I first, S last, - const typename basic_simd::mask_type& mask, flags f = {}); + constexpr void unchecked_store(const basic_vec& v, I first, S last, + const typename basic_vec::mask_type& mask, flags f = {}); template requires ranges::@\libconcept{sized_range}@ && @\libconcept{indirectly_writable}@, T> - constexpr void partial_store(const basic_simd& v, R&& r, + constexpr void partial_store(const basic_vec& v, R&& r, flags f = {}); template requires ranges::@\libconcept{sized_range}@ && @\libconcept{indirectly_writable}@, T> - constexpr void partial_store(const basic_simd& v, R&& r, - const typename basic_simd::mask_type& mask, flags f = {}); + constexpr void partial_store(const basic_vec& v, R&& r, + const typename basic_vec::mask_type& mask, flags f = {}); template requires @\libconcept{indirectly_writable}@ constexpr void partial_store( - const basic_simd& v, I first, iter_difference_t n, flags f = {}); + const basic_vec& v, I first, iter_difference_t n, flags f = {}); template requires @\libconcept{indirectly_writable}@ constexpr void partial_store( - const basic_simd& v, I first, iter_difference_t n, - const typename basic_simd::mask_type& mask, flags f = {}); + const basic_vec& v, I first, iter_difference_t n, + const typename basic_vec::mask_type& mask, flags f = {}); template S, class... Flags> requires @\libconcept{indirectly_writable}@ - constexpr void partial_store(const basic_simd& v, I first, S last, + constexpr void partial_store(const basic_vec& v, I first, S last, flags f = {}); template S, class... Flags> requires @\libconcept{indirectly_writable}@ - constexpr void partial_store(const basic_simd& v, I first, S last, - const typename basic_simd::mask_type& mask, flags f = {}); + constexpr void partial_store(const basic_vec& v, I first, S last, + const typename basic_vec::mask_type& mask, flags f = {}); // \ref{simd.permute.static}, Permute by static index generator static constexpr @\exposid{simd-size-type}@ zero_element = @\impdefx{value of \tcode{simd::zero_element}}@; @@ -16650,8 +16650,8 @@ const typename V::value_type& fill_value); template<@\exposconcept{simd-vec-type}@ V> - constexpr V expand(const V& v, const typename V::mask_type& selector, - const V& original = {}); + constexpr V expand(const V& v, const typename V::mask_type& selector, + const V& original = {}); template<@\exposconcept{simd-mask-type}@ V> constexpr V expand(const V& v, const type_identity_t& selector, const V& original = {}); @@ -16705,38 +16705,38 @@ partial_scatter_to(const V& v, R&& out, const typename I::mask_type& mask, const I& indices, flags f = {}); - // \ref{simd.creation}, \tcode{basic_simd} and \tcode{basic_simd_mask} creation + // \ref{simd.creation}, \tcode{basic_vec} and \tcode{basic_mask} creation template - constexpr auto chunk(const basic_simd& x) noexcept; + constexpr auto chunk(const basic_vec& x) noexcept; template - constexpr auto chunk(const basic_simd_mask<@\exposid{mask-element-size}@, Abi>& x) noexcept; + constexpr auto chunk(const basic_mask<@\exposid{mask-element-size}@, Abi>& x) noexcept; template<@\exposid{simd-size-type}@ N, class T, class Abi> - constexpr auto chunk(const basic_simd& x) noexcept; + constexpr auto chunk(const basic_vec& x) noexcept; template<@\exposid{simd-size-type}@ N, size_t Bytes, class Abi> - constexpr auto chunk(const basic_simd_mask& x) noexcept; + constexpr auto chunk(const basic_mask& x) noexcept; template - constexpr basic_simd::size() + ...)>> - cat(const basic_simd&...) noexcept; + constexpr basic_vec::size() + ...)>> + cat(const basic_vec&...) noexcept; template - constexpr basic_simd_mask, - (basic_simd_mask::size() + ...)>> - cat(const basic_simd_mask&...) noexcept; + constexpr basic_mask, + (basic_mask::size() + ...)>> + cat(const basic_mask&...) noexcept; - // \ref{simd.mask.reductions}, \tcode{basic_simd_mask} reductions + // \ref{simd.mask.reductions}, \tcode{basic_mask} reductions template - constexpr bool all_of(const basic_simd_mask&) noexcept; + constexpr bool all_of(const basic_mask&) noexcept; template - constexpr bool any_of(const basic_simd_mask&) noexcept; + constexpr bool any_of(const basic_mask&) noexcept; template - constexpr bool none_of(const basic_simd_mask&) noexcept; + constexpr bool none_of(const basic_mask&) noexcept; template - constexpr @\exposid{simd-size-type}@ reduce_count(const basic_simd_mask&) noexcept; + constexpr @\exposid{simd-size-type}@ reduce_count(const basic_mask&) noexcept; template - constexpr @\exposid{simd-size-type}@ reduce_min_index(const basic_simd_mask&); + constexpr @\exposid{simd-size-type}@ reduce_min_index(const basic_mask&); template - constexpr @\exposid{simd-size-type}@ reduce_max_index(const basic_simd_mask&); + constexpr @\exposid{simd-size-type}@ reduce_max_index(const basic_mask&); constexpr bool all_of(@\libconcept{same_as}@ auto) noexcept; constexpr bool any_of(@\libconcept{same_as}@ auto) noexcept; @@ -16745,45 +16745,45 @@ constexpr @\exposid{simd-size-type}@ reduce_min_index(@\libconcept{same_as}@ auto); constexpr @\exposid{simd-size-type}@ reduce_max_index(@\libconcept{same_as}@ auto); - // \ref{simd.reductions}, \tcode{basic_simd} reductions + // \ref{simd.reductions}, \tcode{basic_vec} reductions template> - constexpr T reduce(const basic_simd&, BinaryOperation = {}); + constexpr T reduce(const basic_vec&, BinaryOperation = {}); template> constexpr T reduce( - const basic_simd& x, const typename basic_simd::mask_type& mask, + const basic_vec& x, const typename basic_vec::mask_type& mask, BinaryOperation binary_op = {}, type_identity_t identity_element = @\seebelow@); template - constexpr T reduce_min(const basic_simd&) noexcept; + constexpr T reduce_min(const basic_vec&) noexcept; template - constexpr T reduce_min(const basic_simd&, - const typename basic_simd::mask_type&) noexcept; + constexpr T reduce_min(const basic_vec&, + const typename basic_vec::mask_type&) noexcept; template - constexpr T reduce_max(const basic_simd&) noexcept; + constexpr T reduce_max(const basic_vec&) noexcept; template - constexpr T reduce_max(const basic_simd&, - const typename basic_simd::mask_type&) noexcept; + constexpr T reduce_max(const basic_vec&, + const typename basic_vec::mask_type&) noexcept; // \ref{simd.alg}, Algorithms template - constexpr basic_simd - min(const basic_simd& a, const basic_simd& b) noexcept; + constexpr basic_vec + min(const basic_vec& a, const basic_vec& b) noexcept; template - constexpr basic_simd - max(const basic_simd& a, const basic_simd& b) noexcept; + constexpr basic_vec + max(const basic_vec& a, const basic_vec& b) noexcept; template - constexpr pair, basic_simd> - minmax(const basic_simd& a, const basic_simd& b) noexcept; + constexpr pair, basic_vec> + minmax(const basic_vec& a, const basic_vec& b) noexcept; template - constexpr basic_simd - clamp(const basic_simd& v, const basic_simd& lo, - const basic_simd& hi); + constexpr basic_vec + clamp(const basic_vec& v, const basic_vec& lo, + const basic_vec& hi); template constexpr auto select(bool c, const T& a, const U& b) -> remove_cvref_t; template - constexpr auto select(const basic_simd_mask& c, const T& a, const U& b) + constexpr auto select(const basic_mask& c, const T& a, const U& b) noexcept -> decltype(@\exposid{simd-select-impl}@(c, a, b)); // \ref{simd.math}, Mathematical functions @@ -16817,8 +16817,8 @@ template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-simd-t}@ log2(const V& x); template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-simd-t}@ logb(const V& x); template - constexpr basic_simd modf(const type_identity_t>& value, - basic_simd* iptr); + constexpr basic_vec modf(const type_identity_t>& value, + basic_vec* iptr); template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-simd-t}@ scalbn(const V& x, const rebind_t>& n); template<@\exposconcept{math-floating-point}@ V> @@ -16826,7 +16826,7 @@ const V& x, const rebind_t>& n); template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-simd-t}@ cbrt(const V& x); template<@\libconcept{signed_integral}@ T, class Abi> - constexpr basic_simd abs(const basic_simd& j); + constexpr basic_vec abs(const basic_vec& j); template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-simd-t}@ abs(const V& j); template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-simd-t}@ fabs(const V& x); template @@ -16988,7 +16988,7 @@ template<@\exposconcept{simd-vec-type}@ V> constexpr rebind_t, V> popcount(const V& v) noexcept; - // \ref{simd.complex.math}, simd complex math + // \ref{simd.complex.math}, vec complex math template<@\exposconcept{simd-complex}@ V> constexpr rebind_t<@\exposid{simd-complex-value-type}@, V> real(const V&) noexcept; @@ -17032,130 +17032,130 @@ namespace std { // See \ref{simd.alg}, Algorithms - using datapar::min; - using datapar::max; - using datapar::minmax; - using datapar::clamp; + using simd::min; + using simd::max; + using simd::minmax; + using simd::clamp; // See \ref{simd.math}, Mathematical functions - using datapar::acos; - using datapar::asin; - using datapar::atan; - using datapar::atan2; - using datapar::cos; - using datapar::sin; - using datapar::tan; - using datapar::acosh; - using datapar::asinh; - using datapar::atanh; - using datapar::cosh; - using datapar::sinh; - using datapar::tanh; - using datapar::exp; - using datapar::exp2; - using datapar::expm1; - using datapar::frexp; - using datapar::ilogb; - using datapar::ldexp; - using datapar::log; - using datapar::log10; - using datapar::log1p; - using datapar::log2; - using datapar::logb; - using datapar::modf; - using datapar::scalbn; - using datapar::scalbln; - using datapar::cbrt; - using datapar::abs; - using datapar::abs; - using datapar::fabs; - using datapar::hypot; - using datapar::pow; - using datapar::sqrt; - using datapar::erf; - using datapar::erfc; - using datapar::lgamma; - using datapar::tgamma; - using datapar::ceil; - using datapar::floor; - using datapar::nearbyint; - using datapar::rint; - using datapar::lrint; - using datapar::llrint; - using datapar::round; - using datapar::lround; - using datapar::llround; - using datapar::trunc; - using datapar::fmod; - using datapar::remainder; - using datapar::remquo; - using datapar::copysign; - using datapar::nextafter; - using datapar::fdim; - using datapar::fmax; - using datapar::fmin; - using datapar::fma; - using datapar::lerp; - using datapar::fpclassify; - using datapar::isfinite; - using datapar::isinf; - using datapar::isnan; - using datapar::isnormal; - using datapar::signbit; - using datapar::isgreater; - using datapar::isgreaterequal; - using datapar::isless; - using datapar::islessequal; - using datapar::islessgreater; - using datapar::isunordered; - using datapar::assoc_laguerre; - using datapar::assoc_legendre; - using datapar::beta; - using datapar::comp_ellint_1; - using datapar::comp_ellint_2; - using datapar::comp_ellint_3; - using datapar::cyl_bessel_i; - using datapar::cyl_bessel_j; - using datapar::cyl_bessel_k; - using datapar::cyl_neumann; - using datapar::ellint_1; - using datapar::ellint_2; - using datapar::ellint_3; - using datapar::expint; - using datapar::hermite; - using datapar::laguerre; - using datapar::legendre; - using datapar::riemann_zeta; - using datapar::sph_bessel; - using datapar::sph_legendre; - using datapar::sph_neumann; + 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::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 \ref{simd.bit}, Bit manipulation - using datapar::byteswap; - using datapar::bit_ceil; - using datapar::bit_floor; - using datapar::has_single_bit; - using datapar::rotl; - using datapar::rotr; - using datapar::bit_width; - using datapar::countl_zero; - using datapar::countl_one; - using datapar::countr_zero; - using datapar::countr_one; - using datapar::popcount; - - // See \ref{simd.complex.math}, simd complex math - using datapar::real; - using datapar::imag; - using datapar::arg; - using datapar::norm; - using datapar::conj; - using datapar::proj; - using datapar::polar; + 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 \ref{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; } \end{codeblock} -\rSec2[simd.traits]{\tcode{simd} type traits} +\rSec2[simd.traits]{\tcode{vec} type traits} \begin{itemdecl} template struct alignment { @\seebelow@ }; @@ -17166,10 +17166,10 @@ \tcode{alignment} has a member \tcode{value} if and only if \begin{itemize} \item - \tcode{T} is a specialization of \tcode{basic_simd_mask} and \tcode{U} is + \tcode{T} is a specialization of \tcode{basic_mask} and \tcode{U} is \tcode{bool}, or \item - \tcode{T} is a specialization of \tcode{basic_simd} and \tcode{U} is a + \tcode{T} is a specialization of \tcode{basic_vec} and \tcode{U} is a vectorizable type. \end{itemize} @@ -17204,18 +17204,18 @@ \end{itemize} \pnum -If \tcode V is a specialization of \tcode{basic_simd}, let \tcode{Abi1} denote -an ABI tag such that \tcode{basic_simd::\brk{}size()} equals +If \tcode V is a specialization of \tcode{basic_vec}, let \tcode{Abi1} denote +an ABI tag such that \tcode{basic_vec::\brk{}size()} equals \tcode{V::size()}. -If \tcode V is a specialization of \tcode{basic_simd_mask}, let \tcode{Abi1} -denote an ABI tag such that \tcode{basic_simd_mask::\brk{}size()} equals \tcode{V::size()}. \pnum -Where present, the member typedef \tcode{type} names \tcode{basic_simd} -if \tcode V is a specialization of \tcode{basic_simd} or -\tcode{basic_simd_mask} if \tcode V is a specialization of -\tcode{basic_simd_mask}. +Where present, the member typedef \tcode{type} names \tcode{basic_vec} +if \tcode V is a specialization of \tcode{basic_vec} or +\tcode{basic_mask} if \tcode V is a specialization of +\tcode{basic_mask}. \end{itemdescr} \begin{itemdecl} @@ -17228,10 +17228,10 @@ \begin{itemize} \item \tcode{typename V::value_type} if \tcode{V} is a specialization of - \tcode{basic_simd}, + \tcode{basic_vec}, \item otherwise \tcode{\exposid{integer-from}<\exposid{mask-element-size}>} if - \tcode{V} is a specialization of \tcode{basic_simd_mask}. + \tcode{V} is a specialization of \tcode{basic_mask}. \end{itemize} \pnum @@ -17242,18 +17242,16 @@ \end{itemize} \pnum -If \tcode V is a specialization of \tcode{basic_simd}, let \tcode{Abi1} denote an -ABI tag such that \tcode{basic_simd::\brk{}size()} equals -\tcode{N}. -If \tcode V is a specialization of \tcode{basic_simd_mask}, let \tcode{Abi1} -denote an ABI tag such that \tcode{basic_simd_mask::size()} equals \tcode{N}. +If \tcode V is a specialization of \tcode{basic_vec}, let \tcode{Abi1} denote an +ABI tag such that \tcode{basic_vec::\brk{}size()} equals \tcode{N}. +If \tcode V is a specialization of \tcode{basic_mask}, let \tcode{Abi1} +denote an ABI tag such that \tcode{basic_mask::size()} equals \tcode{N}. \pnum -Where present, the member typedef \tcode{type} names \tcode{basic_simd} -if \tcode V is a specialization of \tcode{basic_simd} or -\tcode{basic_simd_mask} if \tcode V is a specialization of -\tcode{basic_simd_mask}. +Where present, the member typedef \tcode{type} names \tcode{basic_vec} +if \tcode V is a specialization of \tcode{basic_vec} or +\tcode{basic_mask} if \tcode V is a specialization of +\tcode{basic_mask}. \end{itemdescr} \rSec2[simd.flags]{Load and store flags} @@ -17261,7 +17259,7 @@ \rSec3[simd.flags.overview]{Class template \tcode{flags} overview} \begin{codeblock} -namespace std::datapar { +namespace std::simd { template struct flags { // \ref{simd.flags.oper}, \tcode{flags} operators template @@ -17302,7 +17300,7 @@ \rSec2[simd.iterator]{Class template \exposid{simd-iterator}} \begin{codeblock} -namespace std::datapar { +namespace std::simd { template class @\exposidnc{simd-iterator}@ { // \expos V* @\exposid{data_}@ = nullptr; // \expos @@ -17556,96 +17554,96 @@ Equivalent to: \tcode{return V::size() - i.\exposid{offset_};} \end{itemdescr} -\rSec2[simd.class]{Class template \tcode{basic_simd}} +\rSec2[simd.class]{Class template \tcode{basic_vec}} -\rSec3[simd.overview]{Class template \tcode{basic_simd} overview} +\rSec3[simd.overview]{Class template \tcode{basic_vec} overview} \begin{codeblock} -namespace std::datapar { - template class basic_simd { +namespace std::simd { + template class basic_vec { public: using value_type = T; - using mask_type = basic_simd_mask; + using mask_type = basic_mask; using abi_type = Abi; - using @\libmember{iterator}{basic_simd}@ = @\exposid{simd-iterator}@; - using @\libmember{const_iterator}{basic_simd}@ = @\exposid{simd-iterator}@; + using @\libmember{iterator}{basic_vec}@ = @\exposid{simd-iterator}@; + using @\libmember{const_iterator}{basic_vec}@ = @\exposid{simd-iterator}@; - constexpr iterator @\libmember{begin}{basic_simd}@() noexcept { return {*this, 0}; } - constexpr const_iterator @\libmember{begin}{basic_simd}@() const noexcept { return {*this, 0}; } - constexpr const_iterator @\libmember{cbegin}{basic_simd}@() const noexcept { return {*this, 0}; } - constexpr default_sentinel_t @\libmember{end}{basic_simd}@() const noexcept { return {}; } - constexpr default_sentinel_t @\libmember{cend}{basic_simd}@() const noexcept { return {}; } + constexpr iterator @\libmember{begin}{basic_vec}@() noexcept { return {*this, 0}; } + constexpr const_iterator @\libmember{begin}{basic_vec}@() const noexcept { return {*this, 0}; } + constexpr const_iterator @\libmember{cbegin}{basic_vec}@() const noexcept { return {*this, 0}; } + constexpr default_sentinel_t @\libmember{end}{basic_vec}@() const noexcept { return {}; } + constexpr default_sentinel_t @\libmember{cend}{basic_vec}@() const noexcept { return {}; } static constexpr integral_constant<@\exposid{simd-size-type}@, @\exposid{simd-size-v}@> size {}; - constexpr basic_simd() noexcept = default; + constexpr basic_vec() noexcept = default; - // \ref{simd.ctor}, \tcode{basic_simd} constructors + // \ref{simd.ctor}, \tcode{basic_vec} constructors template - constexpr explicit(@\seebelow@) basic_simd(U&& value) noexcept; + constexpr explicit(@\seebelow@) basic_vec(U&& value) noexcept; template - constexpr explicit(@\seebelow@) basic_simd(const basic_simd&) noexcept; + constexpr explicit(@\seebelow@) basic_vec(const basic_vec&) noexcept; template - constexpr explicit basic_simd(G&& gen) noexcept; + constexpr explicit basic_vec(G&& gen) noexcept; template - constexpr basic_simd(R&& range, flags = {}); + constexpr basic_vec(R&& range, flags = {}); template - constexpr basic_simd(R&& range, const mask_type& mask, flags = {}); + constexpr basic_vec(R&& range, const mask_type& mask, flags = {}); template<@\exposconcept{simd-floating-point}@ V> - constexpr explicit(@\seebelow@) basic_simd(const V& reals, const V& imags = {}) noexcept; + constexpr explicit(@\seebelow@) basic_vec(const V& reals, const V& imags = {}) noexcept; - // \ref{simd.subscr}, \tcode{basic_simd} subscript operators + // \ref{simd.subscr}, \tcode{basic_vec} subscript operators constexpr value_type operator[](@\exposid{simd-size-type}@) const; template<@\exposconcept{simd-integral}@ I> - constexpr resize_t operator[](const I& indices) const; + constexpr resize_t operator[](const I& indices) const; - // \ref{simd.unary}, \tcode{basic_simd} unary operators - constexpr basic_simd& operator++() noexcept; - constexpr basic_simd operator++(int) noexcept; - constexpr basic_simd& operator--() noexcept; - constexpr basic_simd operator--(int) noexcept; + // \ref{simd.unary}, \tcode{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_simd operator~() const noexcept; - constexpr basic_simd operator+() const noexcept; - constexpr basic_simd operator-() const noexcept; - - // \ref{simd.binary}, \tcode{basic_simd} binary operators - friend constexpr basic_simd operator+(const basic_simd&, const basic_simd&) noexcept; - friend constexpr basic_simd operator-(const basic_simd&, const basic_simd&) noexcept; - friend constexpr basic_simd operator*(const basic_simd&, const basic_simd&) noexcept; - friend constexpr basic_simd operator/(const basic_simd&, const basic_simd&) noexcept; - friend constexpr basic_simd operator%(const basic_simd&, const basic_simd&) noexcept; - friend constexpr basic_simd operator&(const basic_simd&, const basic_simd&) noexcept; - friend constexpr basic_simd operator|(const basic_simd&, const basic_simd&) noexcept; - friend constexpr basic_simd operator^(const basic_simd&, const basic_simd&) noexcept; - friend constexpr basic_simd operator<<(const basic_simd&, const basic_simd&) noexcept; - friend constexpr basic_simd operator>>(const basic_simd&, const basic_simd&) noexcept; - friend constexpr basic_simd operator<<(const basic_simd&, @\exposid{simd-size-type}@) noexcept; - friend constexpr basic_simd operator>>(const basic_simd&, @\exposid{simd-size-type}@) noexcept; - - // \ref{simd.cassign}, \tcode{basic_simd} compound assignment - friend constexpr basic_simd& operator+=(basic_simd&, const basic_simd&) noexcept; - friend constexpr basic_simd& operator-=(basic_simd&, const basic_simd&) noexcept; - friend constexpr basic_simd& operator*=(basic_simd&, const basic_simd&) noexcept; - friend constexpr basic_simd& operator/=(basic_simd&, const basic_simd&) noexcept; - friend constexpr basic_simd& operator%=(basic_simd&, const basic_simd&) noexcept; - friend constexpr basic_simd& operator&=(basic_simd&, const basic_simd&) noexcept; - friend constexpr basic_simd& operator|=(basic_simd&, const basic_simd&) noexcept; - friend constexpr basic_simd& operator^=(basic_simd&, const basic_simd&) noexcept; - friend constexpr basic_simd& operator<<=(basic_simd&, const basic_simd&) noexcept; - friend constexpr basic_simd& operator>>=(basic_simd&, const basic_simd&) noexcept; - friend constexpr basic_simd& operator<<=(basic_simd&, @\exposid{simd-size-type}@) noexcept; - friend constexpr basic_simd& operator>>=(basic_simd&, @\exposid{simd-size-type}@) noexcept; - - // \ref{simd.comparison}, \tcode{basic_simd} compare operators - friend constexpr mask_type operator==(const basic_simd&, const basic_simd&) noexcept; - friend constexpr mask_type operator!=(const basic_simd&, const basic_simd&) noexcept; - friend constexpr mask_type operator>=(const basic_simd&, const basic_simd&) noexcept; - friend constexpr mask_type operator<=(const basic_simd&, const basic_simd&) noexcept; - friend constexpr mask_type operator>(const basic_simd&, const basic_simd&) noexcept; - friend constexpr mask_type operator<(const basic_simd&, const basic_simd&) noexcept; - - // \ref{simd.complex.access}, \tcode{basic_simd} complex-value accessors + constexpr basic_vec operator~() const noexcept; + constexpr basic_vec operator+() const noexcept; + constexpr basic_vec operator-() const noexcept; + + // \ref{simd.binary}, \tcode{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&, @\exposid{simd-size-type}@) noexcept; + friend constexpr basic_vec operator>>(const basic_vec&, @\exposid{simd-size-type}@) noexcept; + + // \ref{simd.cassign}, \tcode{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&, @\exposid{simd-size-type}@) noexcept; + friend constexpr basic_vec& operator>>=(basic_vec&, @\exposid{simd-size-type}@) noexcept; + + // \ref{simd.comparison}, \tcode{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; + + // \ref{simd.complex.access}, \tcode{basic_vec} complex-value accessors constexpr auto real() const noexcept; constexpr auto imag() const noexcept; template<@\exposconcept{simd-floating-point}@ V> @@ -17653,19 +17651,19 @@ template<@\exposconcept{simd-floating-point}@ V> constexpr void imag(const V& v) noexcept; - // \ref{simd.cond}, \tcode{basic_simd} exposition only conditional operators - friend constexpr basic_simd @\exposid{simd-select-impl}@( // \expos - const mask_type&, const basic_simd&, const basic_simd&) noexcept; + // \ref{simd.cond}, \tcode{basic_vec} exposition only conditional operators + friend constexpr basic_vec @\exposid{simd-select-impl}@( // \expos + const mask_type&, const basic_vec&, const basic_vec&) noexcept; }; template - basic_simd(R&& r, Ts...) -> @\seebelow@; + basic_vec(R&& r, Ts...) -> @\seebelow@; } \end{codeblock} \pnum -Every specialization of \tcode{basic_simd} is a complete type. -The specialization of \tcode{basic_simd} is +Every specialization of \tcode{basic_vec} is a complete type. +The specialization of \tcode{basic_vec} is \begin{itemize} \item enabled, if \tcode{T} is a vectorizable type, and there exists value @@ -17674,17 +17672,17 @@ \item otherwise, disabled, if \tcode{T} is not a vectorizable type, \item - otherwise, it is \impldef{set of enabled \tcode{basic_simd} + otherwise, it is \impldef{set of enabled \tcode{basic_vec} specializations} if such a specialization is enabled. \end{itemize} -If \tcode{basic_simd} is disabled, then the specialization has a +If \tcode{basic_vec} is disabled, then the specialization has a deleted default constructor, deleted destructor, deleted copy constructor, and deleted copy assignment. In addition only the \tcode{value_type}, \tcode{abi_type}, and \tcode{mask_type} members are present. -If \tcode{basic_simd} is enabled, then \tcode{basic_simd} is +If \tcode{basic_vec} is enabled, then \tcode{basic_vec} is trivially copyable, default-initialization of an object of such a type default-initializes all elements, and value-initialization value-initializes all elements\iref{dcl.init.general}. @@ -17692,17 +17690,17 @@ \pnum \recommended Implementations should support implicit conversions between specializations of -\tcode{basic_simd} and appropriate \impldef{conversions of \tcode{basic_simd} +\tcode{basic_vec} and appropriate \impldef{conversions of \tcode{basic_vec} from/to implementation-specific vector types} types. \begin{note} Appropriate types are non-standard vector types which are available in the implementation. \end{note} -\rSec3[simd.ctor]{\tcode{basic_simd} constructors} +\rSec3[simd.ctor]{\tcode{basic_vec} constructors} \begin{itemdecl} -template constexpr explicit(@\seebelow@) basic_simd(U&& value) noexcept; +template constexpr explicit(@\seebelow@) basic_vec(U&& value) noexcept; \end{itemdecl} \begin{itemdescr} @@ -17738,7 +17736,7 @@ \begin{itemdecl} template - constexpr explicit(@\seebelow@) basic_simd(const basic_simd& x) noexcept; + constexpr explicit(@\seebelow@) basic_vec(const basic_vec& x) noexcept; \end{itemdecl} \begin{itemdescr} @@ -17770,7 +17768,7 @@ \end{itemdescr} \begin{itemdecl} -template constexpr explicit basic_simd(G&& gen); +template constexpr explicit basic_vec(G&& gen); \end{itemdecl} \begin{itemdescr} @@ -17799,9 +17797,9 @@ \begin{itemdecl} template - constexpr basic_simd(R&& r, flags = {}); + constexpr basic_vec(R&& r, flags = {}); template - constexpr basic_simd(R&& r, const mask_type& mask, flags = {}); + constexpr basic_vec(R&& r, const mask_type& mask, flags = {}); \end{itemdecl} \begin{itemdescr} @@ -17835,7 +17833,7 @@ \item If the template parameter pack \tcode{Flags} contains \tcode{\exposid{aligned-flag}}, \tcode{ranges::data(r)} points to - storage aligned by \tcode{alignment_v>}. \item If the template parameter pack \tcode{Flags} contains @@ -17852,7 +17850,7 @@ \begin{itemdecl} template - basic_simd(R&& r, Ts...) -> @\seebelow@; + basic_vec(R&& r, Ts...) -> @\seebelow@; \end{itemdecl} \begin{itemdescr} @@ -17866,14 +17864,14 @@ \pnum \remarks -The deduced type is equivalent to \tcode{simd, +The deduced type is equivalent to \tcode{vec, ranges::size(r)>}. \end{itemdescr} \begin{itemdecl} template<@\exposconcept{simd-floating-point}@ V> constexpr explicit(@\seebelow@) - basic_simd(const V& reals, const V& imags = {}) noexcept; + basic_vec(const V& reals, const V& imags = {}) noexcept; \end{itemdecl} \begin{itemdescr} @@ -17881,7 +17879,7 @@ \constraints \begin{itemize} \item - \tcode{\exposconcept{simd-complex}} is modeled, and + \tcode{\exposconcept{simd-complex}} is modeled, and \item \tcode{V::size() == size()} is \tcode{true}. \end{itemize} @@ -17898,7 +17896,7 @@ or equal to the floating-point conversion rank of \tcode{V::value_type}. \end{itemdescr} -\rSec3[simd.subscr]{\tcode{basic_simd} subscript operator} +\rSec3[simd.subscr]{\tcode{basic_vec} subscript operator} \begin{itemdecl} constexpr value_type operator[](@\exposid{simd-size-type}@ i) const; @@ -17920,7 +17918,7 @@ \begin{itemdecl} template<@\exposconcept{simd-integral}@ I> - constexpr resize_t operator[](const I& indices) const; + constexpr resize_t operator[](const I& indices) const; \end{itemdecl} \begin{itemdescr} @@ -17929,13 +17927,13 @@ Equivalent to: \tcode{return permute(*this, indices);} \end{itemdescr} -\rSec3[simd.unary]{\tcode{basic_simd} unary operators} +\rSec3[simd.unary]{\tcode{basic_vec} unary operators} \pnum Effects in \ref{simd.unary} are applied as unary element-wise operations. \begin{itemdecl} -constexpr basic_simd& operator++() noexcept; +constexpr basic_vec& operator++() noexcept; \end{itemdecl} \begin{itemdescr} @@ -17953,7 +17951,7 @@ \end{itemdescr} \begin{itemdecl} -constexpr basic_simd operator++(int) noexcept; +constexpr basic_vec operator++(int) noexcept; \end{itemdecl} \begin{itemdescr} @@ -17971,7 +17969,7 @@ \end{itemdescr} \begin{itemdecl} -constexpr basic_simd& operator--() noexcept; +constexpr basic_vec& operator--() noexcept; \end{itemdecl} \begin{itemdescr} @@ -17989,7 +17987,7 @@ \end{itemdescr} \begin{itemdecl} -constexpr basic_simd operator--(int) noexcept; +constexpr basic_vec operator--(int) noexcept; \end{itemdecl} \begin{itemdescr} @@ -18017,12 +18015,12 @@ \pnum \returns -A \tcode{basic_simd_mask} object with the $i^\text{th}$ element set to +A \tcode{basic_mask} object with the $i^\text{th}$ element set to \tcode{!operator[]($i$)} for all $i$ in the range of \range{0}{size()}. \end{itemdescr} \begin{itemdecl} -constexpr basic_simd operator~() const noexcept; +constexpr basic_vec operator~() const noexcept; \end{itemdecl} \begin{itemdescr} @@ -18032,12 +18030,12 @@ \pnum \returns -A \tcode{basic_simd} object with the $i^\text{th}$ element set to +A \tcode{basic_vec} object with the $i^\text{th}$ element set to \tcode{\~{}operator[]($i$)} for all $i$ in the range of \range{0}{size()}. \end{itemdescr} \begin{itemdecl} -constexpr basic_simd operator+() const noexcept; +constexpr basic_vec operator+() const noexcept; \end{itemdecl} \begin{itemdescr} @@ -18051,7 +18049,7 @@ \end{itemdescr} \begin{itemdecl} -constexpr basic_simd operator-() const noexcept; +constexpr basic_vec operator-() const noexcept; \end{itemdecl} \begin{itemdescr} @@ -18061,25 +18059,25 @@ \pnum \returns -A \tcode{basic_simd} object where the $i^\text{th}$ element is initialized to +A \tcode{basic_vec} object where the $i^\text{th}$ element is initialized to \tcode{-operator[]($i$)} for all $i$ in the range of \range{0}{size()}. \end{itemdescr} -\rSec2[simd.nonmembers]{\tcode{basic_simd} non-member operations} +\rSec2[simd.nonmembers]{\tcode{basic_vec} non-member operations} -\rSec3[simd.binary]{\tcode{basic_simd} binary operators} +\rSec3[simd.binary]{\tcode{basic_vec} binary operators} \begin{itemdecl} -friend constexpr basic_simd operator+(const basic_simd& lhs, const basic_simd& rhs) noexcept; -friend constexpr basic_simd operator-(const basic_simd& lhs, const basic_simd& rhs) noexcept; -friend constexpr basic_simd operator*(const basic_simd& lhs, const basic_simd& rhs) noexcept; -friend constexpr basic_simd operator/(const basic_simd& lhs, const basic_simd& rhs) noexcept; -friend constexpr basic_simd operator%(const basic_simd& lhs, const basic_simd& rhs) noexcept; -friend constexpr basic_simd operator&(const basic_simd& lhs, const basic_simd& rhs) noexcept; -friend constexpr basic_simd operator|(const basic_simd& lhs, const basic_simd& rhs) noexcept; -friend constexpr basic_simd operator^(const basic_simd& lhs, const basic_simd& rhs) noexcept; -friend constexpr basic_simd operator<<(const basic_simd& lhs, const basic_simd& rhs) noexcept; -friend constexpr basic_simd operator>>(const basic_simd& lhs, const basic_simd& 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; +friend constexpr basic_vec operator>>(const basic_vec& lhs, const basic_vec& rhs) noexcept; \end{itemdecl} \begin{itemdescr} @@ -18093,14 +18091,14 @@ \pnum \returns -A \tcode{basic_simd} object initialized with the results of applying +A \tcode{basic_vec} object initialized with the results of applying \placeholder{op} to \tcode{lhs} and \tcode{rhs} as a binary element-wise operation. \end{itemdescr} \begin{itemdecl} -friend constexpr basic_simd operator<<(const basic_simd& v, @\exposid{simd-size-type}@ n) noexcept; -friend constexpr basic_simd operator>>(const basic_simd& v, @\exposid{simd-size-type}@ n) noexcept; +friend constexpr basic_vec operator<<(const basic_vec& v, @\exposid{simd-size-type}@ n) noexcept; +friend constexpr basic_vec operator>>(const basic_vec& v, @\exposid{simd-size-type}@ n) noexcept; \end{itemdecl} \begin{itemdescr} @@ -18114,24 +18112,24 @@ \pnum \returns -A \tcode{basic_simd} object where the $i^\text{th}$ element is initialized to +A \tcode{basic_vec} object where the $i^\text{th}$ element is initialized to the result of applying \placeholder{op} to \tcode{v[$i$]} and \tcode{n} for all $i$ in the range of \range{0}{size()}. \end{itemdescr} -\rSec3[simd.cassign]{\tcode{basic_simd} compound assignment} +\rSec3[simd.cassign]{\tcode{basic_vec} compound assignment} \begin{itemdecl} -friend constexpr basic_simd& operator+=(basic_simd& lhs, const basic_simd& rhs) noexcept; -friend constexpr basic_simd& operator-=(basic_simd& lhs, const basic_simd& rhs) noexcept; -friend constexpr basic_simd& operator*=(basic_simd& lhs, const basic_simd& rhs) noexcept; -friend constexpr basic_simd& operator/=(basic_simd& lhs, const basic_simd& rhs) noexcept; -friend constexpr basic_simd& operator%=(basic_simd& lhs, const basic_simd& rhs) noexcept; -friend constexpr basic_simd& operator&=(basic_simd& lhs, const basic_simd& rhs) noexcept; -friend constexpr basic_simd& operator|=(basic_simd& lhs, const basic_simd& rhs) noexcept; -friend constexpr basic_simd& operator^=(basic_simd& lhs, const basic_simd& rhs) noexcept; -friend constexpr basic_simd& operator<<=(basic_simd& lhs, const basic_simd& rhs) noexcept; -friend constexpr basic_simd& operator>>=(basic_simd& lhs, const basic_simd& 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; +friend constexpr basic_vec& operator>>=(basic_vec& lhs, const basic_vec& rhs) noexcept; \end{itemdecl} \begin{itemdescr} @@ -18154,8 +18152,8 @@ \end{itemdescr} \begin{itemdecl} -friend constexpr basic_simd& operator<<=(basic_simd& lhs, @\exposid{simd-size-type}@ n) noexcept; -friend constexpr basic_simd& operator>>=(basic_simd& lhs, @\exposid{simd-size-type}@ n) noexcept; +friend constexpr basic_vec& operator<<=(basic_vec& lhs, @\exposid{simd-size-type}@ n) noexcept; +friend constexpr basic_vec& operator>>=(basic_vec& lhs, @\exposid{simd-size-type}@ n) noexcept; \end{itemdecl} \begin{itemdescr} @@ -18169,18 +18167,18 @@ \pnum \effects -Equivalent to: \tcode{return operator \placeholder{op} (lhs, basic_simd(n));} +Equivalent to: \tcode{return operator \placeholder{op} (lhs, basic_vec(n));} \end{itemdescr} -\rSec3[simd.comparison]{\tcode{basic_simd} compare operators} +\rSec3[simd.comparison]{\tcode{basic_vec} compare operators} \begin{itemdecl} -friend constexpr mask_type operator==(const basic_simd& lhs, const basic_simd& rhs) noexcept; -friend constexpr mask_type operator!=(const basic_simd& lhs, const basic_simd& rhs) noexcept; -friend constexpr mask_type operator>=(const basic_simd& lhs, const basic_simd& rhs) noexcept; -friend constexpr mask_type operator<=(const basic_simd& lhs, const basic_simd& rhs) noexcept; -friend constexpr mask_type operator>(const basic_simd& lhs, const basic_simd& rhs) noexcept; -friend constexpr mask_type operator<(const basic_simd& lhs, const basic_simd& 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; +friend constexpr mask_type operator<(const basic_vec& lhs, const basic_vec& rhs) noexcept; \end{itemdecl} \begin{itemdescr} @@ -18194,12 +18192,12 @@ \pnum \returns -A \tcode{basic_simd_mask} object initialized with the results of applying +A \tcode{basic_mask} object initialized with the results of applying \placeholder{op} to \tcode{lhs} and \tcode{rhs} as a binary element-wise operation. \end{itemdescr} -\rSec3[simd.complex.access]{\tcode{simd} complex accessors} +\rSec3[simd.complex.access]{\tcode{vec} complex accessors} \begin{itemdecl} constexpr auto real() const noexcept; @@ -18209,11 +18207,11 @@ \begin{itemdescr} \pnum \constraints -\tcode{\exposconcept{simd-complex}} is modeled. +\tcode{\exposconcept{simd-complex}} is modeled. \pnum \returns -An object of type \tcode{rebind_t} +An object of type \tcode{rebind_t} where the $i^\text{th}$ element is initialized to the result of \tcode{\placeholder{cmplx-func}(operator[]($i$))} for all $i$ in the range \range{0}{size()}, where \placeholder{cmplx-func} is the corresponding function @@ -18232,7 +18230,7 @@ \constraints \begin{itemize} \item - \tcode{\exposconcept{simd-complex}} is modeled, + \tcode{\exposconcept{simd-complex}} is modeled, \item \tcode{\libconcept{same_as}} is modeled, and @@ -18242,32 +18240,32 @@ \pnum \effects -Replaces each element of the \tcode{basic_simd} object such that the +Replaces each element of the \tcode{basic_vec} object such that the $i^\text{th}$ element is replaced with \tcode{value_type(v[$i$], operator[]($i$).imag())} or \tcode{value_type(operator[]($i$).real(), v[$i$])} for \tcode{real} and \tcode{imag} respectively, for all $i$ in the range \range{0}{size()}. \end{itemdescr} -\rSec3[simd.cond]{\tcode{basic_simd} exposition only conditional operators} +\rSec3[simd.cond]{\tcode{basic_vec} exposition only conditional operators} \begin{itemdecl} -friend constexpr basic_simd -@\exposid{simd-select-impl}@(const mask_type& mask, const basic_simd& a, const basic_simd& b) noexcept; +friend constexpr basic_vec +@\exposid{simd-select-impl}@(const mask_type& mask, const basic_vec& a, const basic_vec& b) noexcept; \end{itemdecl} \begin{itemdescr} \pnum \returns -A \tcode{basic_simd} object where the $i^\text{th}$ element equals +A \tcode{basic_vec} object where the $i^\text{th}$ element equals \tcode{mask[$i$] ? a[$i$] : b[$i$]} for all $i$ in the range of \range{0}{size()}. \end{itemdescr} -\rSec3[simd.reductions]{\tcode{basic_simd} reductions} +\rSec3[simd.reductions]{\tcode{basic_vec} reductions} \begin{itemdecl} template> - constexpr T reduce(const basic_simd& x, BinaryOperation binary_op = {}); + constexpr T reduce(const basic_vec& x, BinaryOperation binary_op = {}); \end{itemdecl} \begin{itemdescr} @@ -18282,8 +18280,8 @@ \pnum \returns -\tcode{\placeholdernc{GENERALIZED_SUM}(binary_op, simd(x[0]), $\ldots$, -simd(x[x.size() - 1])\brk{})[0]}\iref{numerics.defns}. +\tcode{\placeholdernc{GENERALIZED_SUM}(binary_op, vec(x[0]), $\ldots$, +vec(x[x.size() - 1]))[\brk{}0]}\iref{numerics.defns}. \pnum \throws @@ -18293,7 +18291,7 @@ \begin{itemdecl} template> constexpr T reduce( - const basic_simd& x, const typename basic_simd::mask_type& mask, + const basic_vec& x, const typename basic_vec::mask_type& mask, BinaryOperation binary_op = {}, type_identity_t identity_element = @\seebelow@); \end{itemdecl} @@ -18318,16 +18316,16 @@ \tcode{binary_op} does not modify \tcode{x}. \item For all finite values \tcode{y} representable by \tcode{T}, the results of - \tcode{y == binary_op(simd(iden\-ti\-ty\-_\-element), simd(y))[0]} and \tcode{y == binary_op(simd(y), simd(iden\-ti\-ty\-_\-element), vec(y))[0]} and \tcode{y == binary_op(vec(y), vec(iden\-ti\-ty\-_\-element))[0]} are \tcode{true}. \end{itemize} \pnum \returns If \tcode{none_of(mask)} is \tcode{true}, returns \tcode{identity_element}. -Otherwise, returns \tcode{\placeholdernc{GENERALIZED_SUM}(binary_op, simd(x[$k_0$]), $\ldots$, simd(x[$k_n$]))[0]} where $k_0, \ldots, k_n$ are +Otherwise, returns \tcode{\placeholdernc{GENERALIZED_SUM}(binary_op, vec(x[$k_0$]), $\ldots$, vec(x[$k_n$]))[0]} where $k_0, \ldots, k_n$ are the selected indices of \tcode{mask}. \pnum @@ -18347,7 +18345,7 @@ \end{itemdescr} \begin{itemdecl} -template constexpr T reduce_min(const basic_simd& x) noexcept; +template constexpr T reduce_min(const basic_vec& x) noexcept; \end{itemdecl} \begin{itemdescr} @@ -18358,13 +18356,13 @@ \pnum \returns The value of an element \tcode{x[$j$]} for which \tcode{x[$i$] < x[$j$]} is -\tcode{false} for all $i$ in the range of \range{0}{basic_simd::size()}. +\tcode{false} for all $i$ in the range of \range{0}{basic_vec::size()}. \end{itemdescr} \begin{itemdecl} template constexpr T reduce_min( - const basic_simd&, const typename basic_simd::mask_type&) noexcept; + const basic_vec&, const typename basic_vec::mask_type&) noexcept; \end{itemdecl} \begin{itemdescr} @@ -18382,7 +18380,7 @@ \end{itemdescr} \begin{itemdecl} -template constexpr T reduce_max(const basic_simd& x) noexcept; +template constexpr T reduce_max(const basic_vec& x) noexcept; \end{itemdecl} \begin{itemdescr} @@ -18393,13 +18391,13 @@ \pnum \returns The value of an element \tcode{x[$j$]} for which \tcode{x[$j$] < x[$i$]} is -\tcode{false} for all $i$ in the range of \range{0}{basic_simd::size()}. +\tcode{false} for all $i$ in the range of \range{0}{basic_vec::size()}. \end{itemdescr} \begin{itemdecl} template constexpr T reduce_max( - const basic_simd&, const typename basic_simd::mask_type&) noexcept; + const basic_vec&, const typename basic_vec::mask_type&) noexcept; \end{itemdecl} \begin{itemdescr} @@ -18416,7 +18414,7 @@ \tcode{mask}. \end{itemdescr} -\rSec3[simd.loadstore]{\tcode{basic_simd} load and store functions} +\rSec3[simd.loadstore]{\tcode{basic_vec} load and store functions} \begin{itemdecl} template @@ -18475,7 +18473,7 @@ \pnum \remarks The default argument for template parameter \tcode{V} is -\tcode{basic_simd>}. +\tcode{basic_vec>}. \end{itemdescr} \begin{itemdecl} @@ -18521,7 +18519,7 @@ \item \tcode{same_as, V>} is \tcode{true}, \item - \tcode{V} is an enabled specialization of \tcode{basic_simd}, and + \tcode{V} is an enabled specialization of \tcode{basic_vec}, and \item if the template parameter pack \tcode{Flags} does not contain \tcode{\exposid{convert-flag}}, then the conversion from @@ -18558,33 +18556,33 @@ \pnum \remarks The default argument for template parameter \tcode{V} is -\tcode{basic_simd>}. +\tcode{basic_vec>}. \end{itemdescr} \begin{itemdecl} template requires ranges::@\libconcept{sized_range}@ && @\libconcept{indirectly_writable}@, T> - constexpr void unchecked_store(const basic_simd& v, R&& r, flags f = {}); + constexpr void unchecked_store(const basic_vec& v, R&& r, flags f = {}); template requires ranges::@\libconcept{sized_range}@ && @\libconcept{indirectly_writable}@, T> - constexpr void unchecked_store(const basic_simd& v, R&& r, - const typename basic_simd::mask_type& mask, flags f = {}); + constexpr void unchecked_store(const basic_vec& v, R&& r, + const typename basic_vec::mask_type& mask, flags f = {}); template requires @\libconcept{indirectly_writable}@ - constexpr void unchecked_store(const basic_simd& v, I first, iter_difference_t n, + constexpr void unchecked_store(const basic_vec& v, I first, iter_difference_t n, flags f = {}); template requires @\libconcept{indirectly_writable}@ - constexpr void unchecked_store(const basic_simd& v, I first, iter_difference_t n, - const typename basic_simd::mask_type& mask, flags f = {}); + constexpr void unchecked_store(const basic_vec& v, I first, iter_difference_t n, + const typename basic_vec::mask_type& mask, flags f = {}); template S, class... Flags> requires @\libconcept{indirectly_writable}@ - constexpr void unchecked_store(const basic_simd& v, I first, S last, + constexpr void unchecked_store(const basic_vec& v, I first, S last, flags f = {}); template S, class... Flags> requires @\libconcept{indirectly_writable}@ - constexpr void unchecked_store(const basic_simd& v, I first, S last, - const typename basic_simd::mask_type& mask, flags f = {}); + constexpr void unchecked_store(const basic_vec& v, I first, S last, + const typename basic_vec::mask_type& mask, flags f = {}); \end{itemdecl} \begin{itemdescr} @@ -18592,7 +18590,7 @@ Let \begin{itemize} \item - \tcode{mask} be \tcode{basic_simd::mask_type(true)} for the + \tcode{mask} be \tcode{basic_vec::mask_type(true)} for the overloads with no \tcode{mask} parameter; \item \tcode{R} be \tcode{span>} for the overloads with no @@ -18629,27 +18627,27 @@ \begin{itemdecl} template requires ranges::@\libconcept{sized_range}@ && @\libconcept{indirectly_writable}@, T> - constexpr void partial_store(const basic_simd& v, R&& r, flags f = {}); + constexpr void partial_store(const basic_vec& v, R&& r, flags f = {}); template requires ranges::@\libconcept{sized_range}@ && @\libconcept{indirectly_writable}@, T> - constexpr void partial_store(const basic_simd& v, R&& r, - const typename basic_simd::mask_type& mask, flags f = {}); + constexpr void partial_store(const basic_vec& v, R&& r, + const typename basic_vec::mask_type& mask, flags f = {}); template requires @\libconcept{indirectly_writable}@ - constexpr void partial_store(const basic_simd& v, I first, iter_difference_t n, + constexpr void partial_store(const basic_vec& v, I first, iter_difference_t n, flags f = {}); template requires @\libconcept{indirectly_writable}@ - constexpr void partial_store(const basic_simd& v, I first, iter_difference_t n, - const typename basic_simd::mask_type& mask, flags f = {}); + constexpr void partial_store(const basic_vec& v, I first, iter_difference_t n, + const typename basic_vec::mask_type& mask, flags f = {}); template S, class... Flags> requires @\libconcept{indirectly_writable}@ - constexpr void partial_store(const basic_simd& v, I first, S last, + constexpr void partial_store(const basic_vec& v, I first, S last, flags f = {}); template S, class... Flags> requires @\libconcept{indirectly_writable}@ - constexpr void partial_store(const basic_simd& v, I first, S last, - const typename basic_simd::mask_type& mask, flags f = {}); + constexpr void partial_store(const basic_vec& v, I first, S last, + const typename basic_vec::mask_type& mask, flags f = {}); \end{itemdecl} \begin{itemdescr} @@ -18657,7 +18655,7 @@ Let \begin{itemize} \item - \tcode{mask} be \tcode{basic_simd::mask_type(true)} for the + \tcode{mask} be \tcode{basic_vec::mask_type(true)} for the overloads with no \tcode{mask} parameter; \item \tcode{R} be \tcode{span>} for the overloads with no @@ -18691,7 +18689,7 @@ \item If the template parameter pack \tcode{Flags} contains \tcode{\exposid{aligned-flag}}, \tcode{ranges::data(r)} points to storage - aligned by \tcode{alignment_v, + aligned by \tcode{alignment_v, ranges::range_value_t>}. \item If the template parameter pack \tcode{Flags} contains @@ -18701,17 +18699,16 @@ \pnum \effects -For all $i$ in the range of \range{0}{basic_simd::size()}, if +For all $i$ in the range of \range{0}{basic_vec::size()}, if \tcode{mask[$i$] \&\& $i$ < ranges::\brk{}size(r)} is \tcode{true}, evaluates \tcode{ranges::data(r)[$i$] = v[$i$]}. \end{itemdescr} -\rSec3[simd.permute.static]{\tcode{simd} static permute} +\rSec3[simd.permute.static]{\tcode{vec} static permute} \begin{itemdecl} template<@\exposid{simd-size-type}@ N = @\seebelow@, @\exposconcept{simd-vec-type}@ V, class IdxMap> constexpr resize_t permute(const V& v, IdxMap&& idxmap); - template<@\exposid{simd-size-type}@ N = @\seebelow@, @\exposconcept{simd-mask-type}@ V, class IdxMap> constexpr resize_t permute(const V& v, IdxMap&& idxmap); \end{itemdecl} @@ -18754,7 +18751,7 @@ \pnum \returns -A \tcode{basic_simd} or \tcode{basic_simd_mask} object where the +A \tcode{basic_vec} or \tcode{basic_mask} object where the $i^\text{th}$ element is initialized to the result of \tcode{\exposid{perm-fn}<$i$>()} for all $i$ in the range \range{0}{N}. @@ -18763,12 +18760,11 @@ The default argument for template parameter \tcode{N} is \tcode{V::size()}. \end{itemdescr} -\rSec3[simd.permute.dynamic]{\tcode{simd} dynamic permute} +\rSec3[simd.permute.dynamic]{\tcode{vec} dynamic permute} \begin{itemdecl} template<@\exposconcept{simd-vec-type}@ V, @\exposconcept{simd-integral}@ I> constexpr resize_t permute(const V& v, const I& indices); - template<@\exposconcept{simd-mask-type}@ V, @\exposconcept{simd-integral}@ I> constexpr resize_t permute(const V& v, const I& indices); \end{itemdecl} @@ -18780,17 +18776,16 @@ \pnum \returns -A \tcode{basic_simd} or \tcode{basic_simd_mask} object where the $i^\text{th}$ +A \tcode{basic_vec} or \tcode{basic_mask} object where the $i^\text{th}$ element is initialized to the result of \tcode{v[indices[$i$]]} for all $i$ in the range \range{0}{I::size()}. \end{itemdescr} -\rSec3[simd.permute.mask]{\tcode{simd} mask permute} +\rSec3[simd.permute.mask]{\tcode{vec} mask permute} \begin{itemdecl} template<@\exposconcept{simd-vec-type}@ V> constexpr V compress(const V& v, const typename V::mask_type& selector); - template<@\exposconcept{simd-mask-type}@ V> constexpr V compress(const V& v, const type_identity_t& selector); \end{itemdecl} @@ -18814,7 +18809,7 @@ \pnum \returns -A \tcode{basic_simd} or \tcode{basic_simd_mask} object where the $i^\text{th}$ +A \tcode{basic_vec} or \tcode{basic_mask} object where the $i^\text{th}$ element is initialized to the result of \tcode{\exposidnc{select-value}($i$)} for all $i$ in the range \range{0}{V::size()}. \end{itemdescr} @@ -18823,7 +18818,6 @@ template<@\exposconcept{simd-vec-type}@ V> constexpr V compress(const V& v, const typename V::mask_type& selector, const typename V::value_type& fill_value); - template<@\exposconcept{simd-mask-type}@ V> constexpr V compress(const V& v, const type_identity_t& selector, const typename V::value_type& fill_value); @@ -18844,7 +18838,7 @@ \pnum \returns -A \tcode{basic_simd} or \tcode{basic_simd_mask} object where the $i^\text{th}$ +A \tcode{basic_vec} or \tcode{basic_mask} object where the $i^\text{th}$ element is initialized to the result of \tcode{\exposidnc{select-value}($i$)} for all $i$ in the range \range{0}{V::size()}. \end{itemdescr} @@ -18852,7 +18846,6 @@ \begin{itemdecl} template<@\exposconcept{simd-vec-type}@ V> constexpr V expand(const V& v, const typename V::mask_type& selector, const V& original = {}); - template<@\exposconcept{simd-mask-type}@ V> constexpr V expand(const V& v, const type_identity_t& selector, const V& original = {}); \end{itemdecl} @@ -18875,7 +18868,7 @@ \pnum \returns -A \tcode{basic_simd} or \tcode{basic_simd_mask} object where the $i^\text{th}$ +A \tcode{basic_vec} or \tcode{basic_mask} object where the $i^\text{th}$ element is initialized to the result of \tcode{\exposidnc{select-value}($i$)} for all $i$ in the range \range{0}{V::size()}. \end{itemdescr} @@ -18883,13 +18876,10 @@ \rSec3[simd.permute.memory]{\tcode{simd} memory permute} \begin{itemdecl} -template +template requires ranges::@\libconcept{sized_range}@ constexpr V unchecked_gather_from(R&& in, const I& indices, flags f = {}); - -template +template requires ranges::@\libconcept{sized_range}@ constexpr V unchecked_gather_from(R&& in, const typename I::mask_type& mask, const I& indices, flags f = {}); @@ -18912,17 +18902,14 @@ \pnum \remarks The default argument for template parameter \tcode{V} is -\tcode{simd, I::size()>}. +\tcode{vec, I::\brk{}size()>}. \end{itemdescr} \begin{itemdecl} -template +template requires ranges::@\libconcept{sized_range}@ constexpr V partial_gather_from(R&& in, const I& indices, flags f = {}); - -template +template requires ranges::@\libconcept{sized_range}@ constexpr V partial_gather_from(R&& in, const typename I::mask_type& mask, const I& indices, flags f = {}); @@ -18947,7 +18934,7 @@ \item \tcode{same_as, V>} is \tcode{true}, \item -\tcode{V} is an enabled specialization of \tcode{basic_simd}, +\tcode{V} is an enabled specialization of \tcode{basic_vec}, \item \tcode{V::size() == I::size()} is \tcode{true}, and \item @@ -18971,7 +18958,7 @@ \pnum \returns -A \tcode{basic_simd} object where the $i^\text{th}$ +A \tcode{basic_vec} object where the $i^\text{th}$ element is initialized to the result of \begin{codeblock} mask[@$i$@] && indices[@$i$@] < ranges::size(in) ? static_cast(ranges::data(in)[indices[@$i$@]]) : T() @@ -18981,15 +18968,14 @@ \pnum \remarks The default argument for template parameter \tcode{V} is -\tcode{simd, I::size()>}. +\tcode{vec, I::\brk{}size()>}. \end{itemdescr} \begin{itemdecl} template<@\exposconcept{simd-vec-type}@ V, ranges::@\libconcept{contiguous_range}@ R, @\exposconcept{simd-integral}@ I, class... Flags> requires ranges::@\libconcept{sized_range}@ - constexpr void unchecked_scatter_to(const V& v, R&& out, - const I& indices, flags f = {}); - + constexpr void unchecked_scatter_to(const V& v, R&& out, const I& indices, + flags f = {}); template<@\exposconcept{simd-vec-type}@ V, ranges::@\libconcept{contiguous_range}@ R, @\exposconcept{simd-integral}@ I, class... Flags> requires ranges::@\libconcept{sized_range}@ constexpr void unchecked_scatter_to(const V& v, R&& out, const typename I::mask_type& mask, @@ -19014,9 +19000,8 @@ \begin{itemdecl} template<@\exposconcept{simd-vec-type}@ V, ranges::@\libconcept{contiguous_range}@ R, @\exposconcept{simd-integral}@ I, class... Flags> requires ranges::@\libconcept{sized_range}@ - constexpr void partial_scatter_to(const V& v, R&& out, - const I& indices, flags f = {}); - + constexpr void + partial_scatter_to(const V& v, R&& out, const I& indices, flags f = {}); template<@\exposconcept{simd-vec-type}@ V, ranges::@\libconcept{contiguous_range}@ R, @\exposconcept{simd-integral}@ I, class... Flags> requires ranges::@\libconcept{sized_range}@ constexpr void partial_scatter_to(const V& v, R&& out, const typename I::mask_type& mask, @@ -19065,13 +19050,13 @@ \tcode{ranges::data(out)[indices[$i$]] = v[$i$]}. \end{itemdescr} -\rSec3[simd.creation]{\tcode{basic_simd} and \tcode{basic_simd_mask} creation} +\rSec3[simd.creation]{\tcode{basic_vec} and \tcode{basic_mask} creation} \begin{itemdecl} template - constexpr auto chunk(const basic_simd& x) noexcept; + constexpr auto chunk(const basic_vec& x) noexcept; template - constexpr auto chunk(const basic_simd_mask<@\exposid{mask-element-size}@, Abi>& x) noexcept; + constexpr auto chunk(const basic_mask<@\exposid{mask-element-size}@, Abi>& x) noexcept; \end{itemdecl} \begin{itemdescr} @@ -19080,18 +19065,18 @@ \begin{itemize} \item For the first overload, - \tcode{T} is an enabled specialization of \tcode{basic_simd}. - If \tcode{basic_simd<\brk{}typename T::\brk{}value_type, Abi>::size() \% T::size()} + \tcode{T} is an enabled specialization of \tcode{basic_vec}. + If \tcode{basic_vec<\brk{}typename T::\brk{}value_type, Abi>::size() \% T::size()} is not \tcode{0}, then - \tcode{resize_t::size() + \tcode{resize_t::size() \% T::size(), T>} is valid and denotes a type. \item For the second overload, - \tcode{T} is an enabled specialization of \tcode{basic_simd\-_\-mask}. - If \tcode{basic_simd_mask<\exposid{mask-element-size}, Abi>::size() \% T::size()} + \tcode{T} is an enabled specialization of \tcode{basic_mask}. + If \tcode{basic_mask<\exposid{mask-el\-e\-ment-size}, Abi>::size() \% T::size()} is not \tcode{0}, then - \tcode{resize_t<\brk{}ba\-sic\-_\-simd_mask<\brk{}\exposid{mask-element-size}, + \tcode{resize_t<\brk{}basic_mask<\brk{}\exposid{mask-el\-e\-ment-size}, Abi>::size() \% T::size(), T>} is valid and denotes a type. \end{itemize} @@ -19103,18 +19088,18 @@ \begin{itemize} \item If \tcode{x.size() \% T::size() == 0} is \tcode{true}, an \tcode{array} with the $i^\text{th}$ \tcode{basic_simd} or \tcode{basic_simd_mask} + $N$>} with the $i^\text{th}$ \tcode{basic_vec} or \tcode{basic_mask} element of the $j^\text{th}$ \tcode{array} element initialized to the value of the element in \tcode{x} with index \tcode{$i$ + $j$ * T::size()}. \item Otherwise, a \tcode{tuple} of $N$ objects of type \tcode{T} and one object of type \tcode{resize_t}. - The $i^\text{th}$ \tcode{basic_simd} or \tcode{basic_simd_mask} element of + The $i^\text{th}$ \tcode{basic_vec} or \tcode{basic_mask} element of the $j^\text{th}$ \tcode{tuple} element of type \tcode{T} is initialized to the value of the element in \tcode{x} with index \tcode{$i$ + $j$ * T::size()}. - The $i^\text{th}$ \tcode{basic_simd} or \tcode{basic_simd_mask} element of + The $i^\text{th}$ \tcode{basic_vec} or \tcode{basic_mask} element of the $N^\text{th}$ \tcode{tuple} element is initialized to the value of the element in \tcode{x} with index \tcode{$i$ + $N$ * T::size()}. \end{itemize} @@ -19122,34 +19107,34 @@ \begin{itemdecl} template<@\exposid{simd-size-type}@ N, class T, class Abi> - constexpr auto chunk(const basic_simd& x) noexcept; + constexpr auto chunk(const basic_vec& x) noexcept; \end{itemdecl} \begin{itemdescr} \pnum \effects -Equivalent to: \tcode{return chunk>>(x);} +Equivalent to: \tcode{return chunk>>(x);} \end{itemdescr} \begin{itemdecl} template<@\exposid{simd-size-type}@ N, size_t Bytes, class Abi> - constexpr auto chunk(const basic_simd_mask& x) noexcept; + constexpr auto chunk(const basic_mask& x) noexcept; \end{itemdecl} \begin{itemdescr} \pnum \effects -Equivalent to: \tcode{return chunk>>(x);} +Equivalent to: \tcode{return chunk>>(x);} \end{itemdescr} \begin{itemdecl} template - constexpr simd::size() + ...)> - cat(const basic_simd&... xs) noexcept; + constexpr vec::size() + ...)> + cat(const basic_vec&... xs) noexcept; template - constexpr basic_simd_mask, - (basic_simd_mask::size() + ...)>> - cat(const basic_simd_mask&... xs) noexcept; + constexpr basic_mask, + (basic_mask::size() + ...)>> + cat(const basic_mask&... xs) noexcept; \end{itemdecl} \begin{itemdescr} @@ -19157,20 +19142,20 @@ \constraints \begin{itemize} \item - For the first overload \tcode{simd::size() + ...)>} + For the first overload \tcode{vec::size() + ...)>} is enabled. \item For the second overload - \tcode{basic_simd_mask, - (ba\-sic_simd_mask::size() + ...)>>} is enabled. + (basic_mask::size() + ...)>>} is enabled. \end{itemize} \pnum \returns A data-parallel object initialized with the concatenated values in the \tcode{xs} pack of data-parallel objects: The $i^\text{th}$ -\tcode{basic_simd}/\tcode{basic_simd_mask} element of the $j^\text{th}$ +\tcode{basic_vec}/\tcode{basic_mask} element of the $j^\text{th}$ parameter in the \tcode{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 \tcode{xs} pack. @@ -19180,8 +19165,8 @@ \begin{itemdecl} template - constexpr basic_simd min(const basic_simd& a, - const basic_simd& b) noexcept; + constexpr basic_vec min(const basic_vec& a, + const basic_vec& b) noexcept; \end{itemdecl} \begin{itemdescr} @@ -19192,13 +19177,13 @@ \pnum \returns The result of the element-wise application of \tcode{min(a[$i$], b[$i$])} for -all $i$ in the range of \range{0}{basic_simd::size()}. +all $i$ in the range of \range{0}{basic_vec::size()}. \end{itemdescr} \begin{itemdecl} template - constexpr basic_simd max(const basic_simd& a, - const basic_simd& b) noexcept; + constexpr basic_vec max(const basic_vec& a, + const basic_vec& b) noexcept; \end{itemdecl} \begin{itemdescr} @@ -19209,13 +19194,13 @@ \pnum \returns The result of the element-wise application of \tcode{max(a[$i$], b[$i$])} for -all $i$ in the range of \range{0}{basic_simd::size()}. +all $i$ in the range of \range{0}{basic_vec::size()}. \end{itemdescr} \begin{itemdecl} template - constexpr pair, basic_simd> - minmax(const basic_simd& a, const basic_simd& b) noexcept; + constexpr pair, basic_vec> + minmax(const basic_vec& a, const basic_vec& b) noexcept; \end{itemdecl} \begin{itemdescr} @@ -19226,8 +19211,8 @@ \begin{itemdecl} template - constexpr basic_simd clamp( - const basic_simd& v, const basic_simd& lo, const basic_simd& hi); + constexpr basic_vec clamp( + const basic_vec& v, const basic_vec& lo, const basic_vec& hi); \end{itemdecl} \begin{itemdescr} @@ -19243,7 +19228,7 @@ \pnum \returns The result of element-wise application of \tcode{clamp(v[$i$], lo[$i$], -hi[$i$])} for all $i$ in the range of \range{0}{basic_simd::size()}. +hi[$i$])} for all $i$ in the range of \range{0}{basic_vec::size()}. \end{itemdescr} \begin{itemdecl} @@ -19260,7 +19245,7 @@ \begin{itemdecl} template - constexpr auto select(const basic_simd_mask& c, const T& a, const U& b) + constexpr auto select(const basic_mask& c, const T& a, const U& b) noexcept -> decltype(@\exposid{simd-select-impl}@(c, a, b)); \end{itemdecl} @@ -19288,7 +19273,7 @@ constexpr @\exposid{deduced-simd-t}@ scalbln(const V& x, const rebind_t>& n); template<@\libconcept{signed_integral}@ T, class Abi> - constexpr basic_simd abs(const basic_simd& j); + constexpr basic_vec abs(const basic_vec& j); template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-simd-t}@ abs(const V& j); template<@\exposconcept{math-floating-point}@ V> @@ -19360,10 +19345,10 @@ \pnum Let \tcode{Ret} denote the return type of the specialization of a function template with the name \placeholder{math-func}. -Let \placeholder{math-func-simd} denote: +Let \placeholder{math-func-vec} denote: \begin{codeblock} template -Ret @\placeholder{math-func-simd}@(Args... args) { +Ret @\placeholder{math-func-vec}@(Args... args) { return Ret([&](@\exposid{simd-size-type}@ i) { @\placeholder{math-func}@(@\exposid{make-compatible-simd-t}@(args)[i]...); }); @@ -19373,10 +19358,10 @@ \pnum \returns A value \tcode{ret} of type \tcode{Ret}, that is element-wise equal to the -result of calling \placeholder{math-func-simd} with the arguments of the above +result of calling \placeholder{math-func-vec} with the arguments of the above functions. If in an invocation of a scalar overload of \placeholder{math-func} for index -\tcode{i} in \placeholder{math-func-simd} a domain, pole, or range error would +\tcode{i} in \placeholder{math-func-vec} a domain, pole, or range error would occur, the value of \tcode{ret[i]} is unspecified. \pnum @@ -19471,10 +19456,10 @@ \pnum Let \tcode{Ret} denote the return type of the specialization of a function template with the name \placeholder{math-func}. -Let \placeholder{math-func-simd} denote: +Let \placeholder{math-func-vec} denote: \begin{codeblock} template -Ret @\placeholder{math-func-simd}@(Args... args) { +Ret @\placeholder{math-func-vec}@(Args... args) { return Ret([&](@\exposid{simd-size-type}@ i) { @\placeholder{math-func}@(@\exposid{make-compatible-simd-t}@(args)[i]...); }); @@ -19484,10 +19469,10 @@ \pnum \returns A value \tcode{ret} of type \tcode{Ret}, that is element-wise approximately -equal to the result of calling \placeholder{math-func-simd} with the arguments +equal to the result of calling \placeholder{math-func-vec} with the arguments of the above functions. If in an invocation of a scalar overload of \placeholder{math-func} for index -\tcode{i} in \placeholder{math-func-simd} a domain, pole, or range error would +\tcode{i} in \placeholder{math-func-vec} a domain, pole, or range error would occur, the value of \tcode{ret[i]} is unspecified. \pnum @@ -19503,10 +19488,10 @@ \begin{itemdescr} \pnum Let \tcode{Ret} be \tcode{\exposid{deduced-simd-t}}. -Let \placeholder{frexp-simd} denote: +Let \placeholder{frexp-vec} denote: \begin{codeblock} template -pair> @\placeholder{frexp-simd}@(const V& x) { +pair> @\placeholder{frexp-vec}@(const V& x) { int r1[Ret::size()]; Ret r0([&](@\exposid{simd-size-type}@ i) { frexp(@\exposid{make-compatible-simd-t}@(x)[i], &r1[i]); @@ -19516,7 +19501,7 @@ \end{codeblock} Let \tcode{ret} be a value of type \tcode{pair>} that is the same value as the result of calling -\placeholder{frexp-simd}\tcode{(x)}. +\placeholder{frexp-vec}\tcode{(x)}. \pnum \effects @@ -19536,10 +19521,10 @@ \begin{itemdescr} \pnum Let \tcode{Ret} be \tcode{\exposid{math-common-simd-t}}. -Let \placeholder{remquo-simd} denote: +Let \placeholder{remquo-vec} denote: \begin{codeblock} template -pair> @\placeholder{remquo-simd}@(const V0& x, const V1& y) { +pair> @\placeholder{remquo-vec}@(const V0& x, const V1& y) { int r1[Ret::size()]; Ret r0([&](@\exposid{simd-size-type}@ i) { remquo(@\exposid{make-compatible-simd-t}@(x)[i], @@ -19550,9 +19535,9 @@ \end{codeblock} Let \tcode{ret} be a value of type \tcode{pair>} that is the same value as the result of calling -\placeholder{remquo-simd}\tcode{(x, y)}. +\placeholder{remquo-vec}\tcode{(x, y)}. If in an invocation of a scalar overload of \tcode{remquo} for index \tcode{i} -in \placeholder{remquo-simd} a domain, pole, or range error would occur, the +in \placeholder{remquo-vec} a domain, pole, or range error would occur, the value of \tcode{ret[i]} is unspecified. \pnum @@ -19570,16 +19555,16 @@ \begin{itemdecl} template - constexpr basic_simd modf(const type_identity_t>& value, - basic_simd* iptr); + constexpr basic_vec modf(const type_identity_t>& value, + basic_vec* iptr); \end{itemdecl} \begin{itemdescr} \pnum -Let \tcode{V} be \tcode{basic_simd}. -Let \placeholder{modf-simd} denote: +Let \tcode{V} be \tcode{basic_vec}. +Let \placeholder{modf-vec} denote: \begin{codeblock} -pair @\placeholder{modf-simd}@(const V& x) { +pair @\placeholder{modf-vec}@(const V& x) { T r1[Ret::size()]; V r0([&](@\exposid{simd-size-type}@ i) { modf(V(x)[i], &r1[i]); @@ -19588,7 +19573,7 @@ } \end{codeblock} Let \tcode{ret} be a value of type \tcode{pair} that is the same value as -the result of calling \placeholder{modf-simd}\tcode{(value)}. +the result of calling \placeholder{modf-vec}\tcode{(value)}. \pnum \effects @@ -19599,7 +19584,7 @@ \tcode{ret.first}. \end{itemdescr} -\rSec3[simd.bit]{\tcode{basic_simd} bit library} +\rSec3[simd.bit]{\tcode{basic_vec} bit library} \begin{itemdecl} template<@\exposconcept{simd-vec-type}@ V> constexpr V byteswap(const V& v) noexcept; @@ -19612,7 +19597,7 @@ \pnum \returns -A \tcode{basic_simd} object where the $i^\text{th}$ element is initialized to +A \tcode{basic_vec} object where the $i^\text{th}$ element is initialized to the result of \tcode{std::byteswap(v[$i$])} for all $i$ in the range \range{0}{V::size()}. \end{itemdescr} @@ -19634,7 +19619,7 @@ \pnum \returns -A \tcode{basic_simd} object where the $i^\text{th}$ element is initialized to +A \tcode{basic_vec} object where the $i^\text{th}$ element is initialized to the result of \tcode{std::bit_ceil(v[$i$])} for all $i$ in the range \range{0}{V::size()}. @@ -19655,7 +19640,7 @@ \pnum \returns -A \tcode{basic_simd} object where the $i^\text{th}$ element is initialized to +A \tcode{basic_vec} object where the $i^\text{th}$ element is initialized to the result of \tcode{std::bit_floor(v[$i$])} for all $i$ in the range \range{0}{V::size()}. \end{itemdescr} @@ -19672,7 +19657,7 @@ \pnum \returns -A \tcode{basic_simd_mask} object where the $i^\text{th}$ element is initialized +A \tcode{basic_mask} object where the $i^\text{th}$ element is initialized to the result of \tcode{std::has_single_bit(v[$i$])} for all $i$ in the range \range{0}{V::size()}. \end{itemdescr} @@ -19700,7 +19685,7 @@ \pnum \returns -A \tcode{basic_simd} object where the $i^\text{th}$ element is initialized to +A \tcode{basic_vec} object where the $i^\text{th}$ element is initialized to the result of \tcode{\placeholder{bit-func}(v0[$i$], static_cast(v1[$i$]))} for all $i$ in the range \range{0}{V0::size()}, where \placeholder{bit-func} is the corresponding scalar function from \libheader{bit}. @@ -19718,7 +19703,7 @@ \pnum \returns -A \tcode{basic_simd} object where the $i^\text{th}$ element is initialized to +A \tcode{basic_vec} object where the $i^\text{th}$ element is initialized to the result of \tcode{\placeholder{bit-func}(v[$i$], s)} for all $i$ in the range \range{0}{V::size()}, where \placeholder{bit-func} is the corresponding scalar function from \libheader{bit}. @@ -19746,13 +19731,13 @@ \pnum \returns -A \tcode{basic_simd} object where the $i^\text{th}$ element is initialized to +A \tcode{basic_vec} object where the $i^\text{th}$ element is initialized to the result of \tcode{\placeholder{bit-func}(v[$i$])} for all $i$ in the range \range{0}{V::size()}, where \placeholder{bit-func} is the corresponding scalar function from \libheader{bit}. \end{itemdescr} -\rSec3[simd.complex.math]{\tcode{simd} complex math} +\rSec3[simd.complex.math]{\tcode{vec} complex math} \begin{itemdecl} template<@\exposconcept{simd-complex}@ V> @@ -19791,7 +19776,7 @@ \begin{itemdescr} \pnum \returns -A \tcode{basic_simd} object \tcode{ret} where the $i^\text{th}$ element is +A \tcode{basic_vec} object \tcode{ret} where the $i^\text{th}$ element is initialized to the result of \tcode{\placeholder{cmplx-func}(v[$i$])} for all $i$ in the range \range{0}{V::size()}, where \placeholder{cmplx-func} is the corresponding function from \libheader{complex}. If in an invocation of @@ -19813,7 +19798,7 @@ \begin{itemdescr} \pnum \returns -A \tcode{basic_simd} object \tcode{ret} where the $i^\text{th}$ element is +A \tcode{basic_vec} object \tcode{ret} where the $i^\text{th}$ element is initialized to the result of \tcode{\placeholder{cmplx-func}(x[$i$], y[$i$])} for all $i$ in the range \range{0}{V::size()}, where \placeholder{cmplx-func} is the corresponding function from \libheader{complex}. If in an invocation of @@ -19825,107 +19810,107 @@ It is unspecified whether \tcode{errno}\iref{errno} is accessed. \end{itemdescr} -\rSec2[simd.mask.class]{Class template \tcode{basic_simd_mask}} +\rSec2[simd.mask.class]{Class template \tcode{basic_mask}} -\rSec3[simd.mask.overview]{Class template \tcode{basic_simd_mask} overview} +\rSec3[simd.mask.overview]{Class template \tcode{basic_mask} overview} \begin{codeblock} -namespace std::datapar { - template class basic_simd_mask { +namespace std::simd { + template class basic_mask { public: using value_type = bool; using abi_type = Abi; - using @\libmember{iterator}{basic_simd_mask}@ = @\exposid{simd-iterator}@; - using @\libmember{const_iterator}{basic_simd_mask}@ = @\exposid{simd-iterator}@; + using @\libmember{iterator}{basic_mask}@ = @\exposid{simd-iterator}@; + using @\libmember{const_iterator}{basic_mask}@ = @\exposid{simd-iterator}@; - constexpr iterator @\libmember{begin}{basic_simd_mask}@() noexcept { return {*this, 0}; } - constexpr const_iterator @\libmember{begin}{basic_simd_mask}@() const noexcept { return {*this, 0}; } - constexpr const_iterator @\libmember{cbegin}{basic_simd_mask}@() const noexcept { return {*this, 0}; } - constexpr default_sentinel_t @\libmember{end}{basic_simd_mask}@() const noexcept { return {}; } - constexpr default_sentinel_t @\libmember{cend}{basic_simd_mask}@() const noexcept { return {}; } + constexpr iterator @\libmember{begin}{basic_mask}@() noexcept { return {*this, 0}; } + constexpr const_iterator @\libmember{begin}{basic_mask}@() const noexcept { return {*this, 0}; } + constexpr const_iterator @\libmember{cbegin}{basic_mask}@() const noexcept { return {*this, 0}; } + constexpr default_sentinel_t @\libmember{end}{basic_mask}@() const noexcept { return {}; } + constexpr default_sentinel_t @\libmember{cend}{basic_mask}@() const noexcept { return {}; } static constexpr integral_constant<@\exposid{simd-size-type}@, @\exposid{simd-size-v}@<@\exposid{integer-from}@, Abi>> size {}; - constexpr basic_simd_mask() noexcept = default; + constexpr basic_mask() noexcept = default; - // \ref{simd.mask.ctor}, \tcode{basic_simd_mask} constructors - constexpr explicit basic_simd_mask(value_type) noexcept; + // \ref{simd.mask.ctor}, \tcode{basic_mask} constructors + constexpr explicit basic_mask(value_type) noexcept; template - constexpr explicit basic_simd_mask(const basic_simd_mask&) noexcept; + constexpr explicit basic_mask(const basic_mask&) noexcept; template - constexpr explicit basic_simd_mask(G&& gen) noexcept; - constexpr basic_simd_mask(const bitset& b) noexcept; - constexpr explicit basic_simd_mask(@\libconcept{unsigned_integral}@ auto val) noexcept; + constexpr explicit basic_mask(G&& gen) noexcept; + constexpr basic_mask(const bitset& b) noexcept; + constexpr explicit basic_mask(@\libconcept{unsigned_integral}@ auto val) noexcept; - // \ref{simd.mask.subscr}, \tcode{basic_simd_mask} subscript operators + // \ref{simd.mask.subscr}, \tcode{basic_mask} subscript operators constexpr value_type operator[](@\exposid{simd-size-type}@) const; template<@\exposconcept{simd-integral}@ I> - constexpr resize_t operator[](const I& indices) const; + constexpr resize_t operator[](const I& indices) const; - // \ref{simd.mask.unary}, \tcode{basic_simd_mask} unary operators - constexpr basic_simd_mask operator!() const noexcept; - constexpr basic_simd<@\exposid{integer-from}@, Abi> operator+() const noexcept; - constexpr basic_simd<@\exposid{integer-from}@, Abi> operator-() const noexcept; - constexpr basic_simd<@\exposid{integer-from}@, Abi> operator~() const noexcept; + // \ref{simd.mask.unary}, \tcode{basic_mask} unary operators + constexpr basic_mask operator!() const noexcept; + constexpr basic_vec<@\exposid{integer-from}@, Abi> operator+() const noexcept; + constexpr basic_vec<@\exposid{integer-from}@, Abi> operator-() const noexcept; + constexpr basic_vec<@\exposid{integer-from}@, Abi> operator~() const noexcept; - // \ref{simd.mask.conv}, \tcode{basic_simd_mask} conversion operators + // \ref{simd.mask.conv}, \tcode{basic_mask} conversion operators template - constexpr explicit(sizeof(U) != Bytes) operator basic_simd() const noexcept; + constexpr explicit(sizeof(U) != Bytes) operator basic_vec() const noexcept; - // \ref{simd.mask.namedconv}, \tcode{basic_simd_mask} named type convertors + // \ref{simd.mask.namedconv}, \tcode{basic_mask} named type convertors constexpr bitset to_bitset() const noexcept; constexpr unsigned long long to_ullong() const; - // \ref{simd.mask.binary}, \tcode{basic_simd_mask} binary operators - friend constexpr basic_simd_mask - operator&&(const basic_simd_mask&, const basic_simd_mask&) noexcept; - friend constexpr basic_simd_mask - operator||(const basic_simd_mask&, const basic_simd_mask&) noexcept; - friend constexpr basic_simd_mask - operator&(const basic_simd_mask&, const basic_simd_mask&) noexcept; - friend constexpr basic_simd_mask - operator|(const basic_simd_mask&, const basic_simd_mask&) noexcept; - friend constexpr basic_simd_mask - operator^(const basic_simd_mask&, const basic_simd_mask&) noexcept; - - // \ref{simd.mask.cassign}, \tcode{basic_simd_mask} compound assignment - friend constexpr basic_simd_mask& - operator&=(basic_simd_mask&, const basic_simd_mask&) noexcept; - friend constexpr basic_simd_mask& - operator|=(basic_simd_mask&, const basic_simd_mask&) noexcept; - friend constexpr basic_simd_mask& - operator^=(basic_simd_mask&, const basic_simd_mask&) noexcept; - - // \ref{simd.mask.comparison}, \tcode{basic_simd_mask} comparisons - friend constexpr basic_simd_mask - operator==(const basic_simd_mask&, const basic_simd_mask&) noexcept; - friend constexpr basic_simd_mask - operator!=(const basic_simd_mask&, const basic_simd_mask&) noexcept; - friend constexpr basic_simd_mask - operator>=(const basic_simd_mask&, const basic_simd_mask&) noexcept; - friend constexpr basic_simd_mask - operator<=(const basic_simd_mask&, const basic_simd_mask&) noexcept; - friend constexpr basic_simd_mask - operator>(const basic_simd_mask&, const basic_simd_mask&) noexcept; - friend constexpr basic_simd_mask - operator<(const basic_simd_mask&, const basic_simd_mask&) noexcept; - - // \ref{simd.mask.cond}, \tcode{basic_simd_mask} exposition only conditional operators - friend constexpr basic_simd_mask @\exposid{simd-select-impl}@( // \expos - const basic_simd_mask&, const basic_simd_mask&, const basic_simd_mask&) noexcept; - friend constexpr basic_simd_mask @\exposid{simd-select-impl}@( // \expos - const basic_simd_mask&, @\libconcept{same_as}@ auto, @\libconcept{same_as}@ auto) noexcept; + // \ref{simd.mask.binary}, \tcode{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; + + // \ref{simd.mask.cassign}, \tcode{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; + + // \ref{simd.mask.comparison}, \tcode{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; + + // \ref{simd.mask.cond}, \tcode{basic_mask} exposition only conditional operators + friend constexpr basic_mask @\exposid{simd-select-impl}@( // \expos + const basic_mask&, const basic_mask&, const basic_mask&) noexcept; + friend constexpr basic_mask @\exposid{simd-select-impl}@( // \expos + const basic_mask&, @\libconcept{same_as}@ auto, @\libconcept{same_as}@ auto) noexcept; template - friend constexpr simd<@\seebelow@, size()> - @\exposid{simd-select-impl}@(const basic_simd_mask&, const T0&, const T1&) noexcept; // \expos + friend constexpr vec<@\seebelow@, size()> + @\exposid{simd-select-impl}@(const basic_mask&, const T0&, const T1&) noexcept; // \expos }; } \end{codeblock} \pnum -Every specialization of \tcode{basic_simd_mask} is a complete type. -The specialization of \tcode{basic_simd_mask} is: +Every specialization of \tcode{basic_mask} is a complete type. +The specialization of \tcode{basic_mask} is: \begin{itemize} \item disabled, if there is no vectorizable type \tcode{T} such that \tcode{Bytes} @@ -19936,32 +19921,32 @@ to \tcode{sizeof(T)} and \tcode{Abi} is \tcode{\exposid{deduce-abi-t}}, \item - otherwise, it is \impldef{set of enabled \tcode{basic_simd_mask} + otherwise, it is \impldef{set of enabled \tcode{basic_mask} specializations} if such a specialization is enabled. \end{itemize} -If \tcode{basic_simd_mask} is disabled, the specialization has a +If \tcode{basic_mask} is disabled, the specialization has a deleted default constructor, deleted destructor, deleted copy constructor, and deleted copy assignment. In addition only the \tcode{value_type} and \tcode{abi_type} members are present. -If \tcode{basic_simd_mask} is enabled, -\tcode{basic_simd_mask} is trivially copyable. +If \tcode{basic_mask} is enabled, +\tcode{basic_mask} is trivially copyable. \pnum \recommended Implementations should support implicit conversions between -specializations of \tcode{basic_simd_mask} and appropriate \impldef{conversions -of \tcode{basic_simd_mask} from/to implementation-specific vector types} types. +specializations of \tcode{basic_mask} and appropriate \impldef{conversions +of \tcode{basic_mask} from/to implementation-specific vector types} types. \begin{note} Appropriate types are non-standard vector types which are available in the implementation. \end{note} -\rSec3[simd.mask.ctor]{\tcode{basic_simd_mask} constructors} +\rSec3[simd.mask.ctor]{\tcode{basic_mask} constructors} \begin{itemdecl} -constexpr explicit basic_simd_mask(value_type x) noexcept; +constexpr explicit basic_mask(value_type x) noexcept; \end{itemdecl} \begin{itemdescr} @@ -19972,13 +19957,13 @@ \begin{itemdecl} template - constexpr explicit basic_simd_mask(const basic_simd_mask& x) noexcept; + constexpr explicit basic_mask(const basic_mask& x) noexcept; \end{itemdecl} \begin{itemdescr} \pnum \constraints -\tcode{basic_simd_mask::size() == size()} is +\tcode{basic_mask::size() == size()} is \tcode{true}. \pnum @@ -19988,7 +19973,7 @@ \end{itemdescr} \begin{itemdecl} -template constexpr explicit basic_simd_mask(G&& gen); +template constexpr explicit basic_mask(G&& gen); \end{itemdecl} \begin{itemdescr} @@ -20010,7 +19995,7 @@ \end{itemdescr} \begin{itemdecl} -constexpr basic_simd_mask(const bitset& b) noexcept; +constexpr basic_mask(const bitset& b) noexcept; \end{itemdecl} \begin{itemdescr} @@ -20021,7 +20006,7 @@ \end{itemdescr} \begin{itemdecl} -constexpr explicit basic_simd_mask(@\libconcept{unsigned_integral}@ auto val) noexcept; +constexpr explicit basic_mask(@\libconcept{unsigned_integral}@ auto val) noexcept; \end{itemdecl} \begin{itemdescr} @@ -20034,7 +20019,7 @@ zero. \end{itemdescr} -\rSec3[simd.mask.subscr]{\tcode{basic_simd_mask} subscript operator} +\rSec3[simd.mask.subscr]{\tcode{basic_mask} subscript operator} \begin{itemdecl} constexpr value_type operator[](@\exposid{simd-size-type}@ i) const; @@ -20056,7 +20041,7 @@ \begin{itemdecl} template<@\exposconcept{simd-integral}@ I> - constexpr resize_t operator[](const I& indices) const; + constexpr resize_t operator[](const I& indices) const; \end{itemdecl} \begin{itemdescr} @@ -20065,13 +20050,13 @@ Equivalent to: \tcode{return permute(*this, indices);} \end{itemdescr} -\rSec3[simd.mask.unary]{\tcode{basic_simd_mask} unary operators} +\rSec3[simd.mask.unary]{\tcode{basic_mask} unary operators} \begin{itemdecl} -constexpr basic_simd_mask operator!() const noexcept; -constexpr basic_simd<@\exposid{integer-from}@, Abi> operator+() const noexcept; -constexpr basic_simd<@\exposid{integer-from}@, Abi> operator-() const noexcept; -constexpr basic_simd<@\exposid{integer-from}@, Abi> operator~() const noexcept; +constexpr basic_mask operator!() const noexcept; +constexpr basic_vec<@\exposid{integer-from}@, Abi> operator+() const noexcept; +constexpr basic_vec<@\exposid{integer-from}@, Abi> operator-() const noexcept; +constexpr basic_vec<@\exposid{integer-from}@, Abi> operator~() const noexcept; \end{itemdecl} \begin{itemdescr} @@ -20085,11 +20070,11 @@ the range of \range{0}{size()}. \end{itemdescr} -\rSec3[simd.mask.conv]{\tcode{basic_simd_mask} conversion operators} +\rSec3[simd.mask.conv]{\tcode{basic_mask} conversion operators} \begin{itemdecl} template - constexpr explicit(sizeof(U) != Bytes) operator basic_simd() const noexcept; + constexpr explicit(sizeof(U) != Bytes) operator basic_vec() const noexcept; \end{itemdecl} \begin{itemdescr} @@ -20103,7 +20088,7 @@ \tcode{static_cast(operator[]($i$))}. \end{itemdescr} -\rSec3[simd.mask.namedconv]{\tcode{basic_simd_mask} named conversion operators} +\rSec3[simd.mask.namedconv]{\tcode{basic_mask} named conversion operators} \begin{itemdecl} constexpr bitset to_bitset() const noexcept; @@ -20142,19 +20127,19 @@ \rSec2[simd.mask.nonmembers]{Non-member operations} -\rSec3[simd.mask.binary]{\tcode{basic_simd_mask} binary operators} +\rSec3[simd.mask.binary]{\tcode{basic_mask} binary operators} \begin{itemdecl} -friend constexpr basic_simd_mask - operator&&(const basic_simd_mask& lhs, const basic_simd_mask& rhs) noexcept; -friend constexpr basic_simd_mask - operator||(const basic_simd_mask& lhs, const basic_simd_mask& rhs) noexcept; -friend constexpr basic_simd_mask - operator& (const basic_simd_mask& lhs, const basic_simd_mask& rhs) noexcept; -friend constexpr basic_simd_mask - operator| (const basic_simd_mask& lhs, const basic_simd_mask& rhs) noexcept; -friend constexpr basic_simd_mask - operator^ (const basic_simd_mask& lhs, const basic_simd_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; \end{itemdecl} \begin{itemdescr} @@ -20163,20 +20148,20 @@ \pnum \returns -A \tcode{basic_simd_mask} object initialized with the results of applying +A \tcode{basic_mask} object initialized with the results of applying \placeholder{op} to \tcode{lhs} and \tcode{rhs} as a binary element-wise operation. \end{itemdescr} -\rSec3[simd.mask.cassign]{\tcode{basic_simd_mask} compound assignment} +\rSec3[simd.mask.cassign]{\tcode{basic_mask} compound assignment} \begin{itemdecl} -friend constexpr basic_simd_mask& - operator&=(basic_simd_mask& lhs, const basic_simd_mask& rhs) noexcept; -friend constexpr basic_simd_mask& - operator|=(basic_simd_mask& lhs, const basic_simd_mask& rhs) noexcept; -friend constexpr basic_simd_mask& - operator^=(basic_simd_mask& lhs, const basic_simd_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; +friend constexpr basic_mask& + operator^=(basic_mask& lhs, const basic_mask& rhs) noexcept; \end{itemdecl} \begin{itemdescr} @@ -20193,21 +20178,21 @@ \tcode{lhs}. \end{itemdescr} -\rSec3[simd.mask.comparison]{\tcode{basic_simd_mask} comparisons} +\rSec3[simd.mask.comparison]{\tcode{basic_mask} comparisons} \begin{itemdecl} -friend constexpr basic_simd_mask - operator==(const basic_simd_mask&, const basic_simd_mask&) noexcept; -friend constexpr basic_simd_mask - operator!=(const basic_simd_mask&, const basic_simd_mask&) noexcept; -friend constexpr basic_simd_mask - operator>=(const basic_simd_mask&, const basic_simd_mask&) noexcept; -friend constexpr basic_simd_mask - operator<=(const basic_simd_mask&, const basic_simd_mask&) noexcept; -friend constexpr basic_simd_mask - operator>(const basic_simd_mask&, const basic_simd_mask&) noexcept; -friend constexpr basic_simd_mask - operator<(const basic_simd_mask&, const basic_simd_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; +friend constexpr basic_mask + operator<(const basic_mask&, const basic_mask&) noexcept; \end{itemdecl} \begin{itemdescr} @@ -20216,42 +20201,42 @@ \pnum \returns -A \tcode{basic_simd_mask} object initialized with the results of applying +A \tcode{basic_mask} object initialized with the results of applying \placeholder{op} to \tcode{lhs} and \tcode{rhs} as a binary element-wise operation. \end{itemdescr} -\rSec3[simd.mask.cond]{\tcode{basic_simd_mask} exposition only conditional operators} +\rSec3[simd.mask.cond]{\tcode{basic_mask} exposition only conditional operators} \begin{itemdecl} -friend constexpr basic_simd_mask @\exposid{simd-select-impl}@( - const basic_simd_mask& mask, const basic_simd_mask& a, const basic_simd_mask& b) noexcept; +friend constexpr basic_mask @\exposid{simd-select-impl}@( + const basic_mask& mask, const basic_mask& a, const basic_mask& b) noexcept; \end{itemdecl} \begin{itemdescr} \pnum \returns -A \tcode{basic_simd_mask} object where the $i^\text{th}$ element equals +A \tcode{basic_mask} object where the $i^\text{th}$ element equals \tcode{mask[$i$] ? a[$i$] : b[$i$]} for all $i$ in the range of \range{0}{size()}. \end{itemdescr} \begin{itemdecl} -friend constexpr basic_simd_mask -@\exposid{simd-select-impl}@(const basic_simd_mask& mask, @\libconcept{same_as}@ auto a, @\libconcept{same_as}@ auto b) noexcept; +friend constexpr basic_mask +@\exposid{simd-select-impl}@(const basic_mask& mask, @\libconcept{same_as}@ auto a, @\libconcept{same_as}@ auto b) noexcept; \end{itemdecl} \begin{itemdescr} \pnum \returns -A \tcode{basic_simd_mask} object where the $i^\text{th}$ element equals +A \tcode{basic_mask} object where the $i^\text{th}$ element equals \tcode{mask[$i$] ? a : b} for all $i$ in the range of \range{0}{size()}. \end{itemdescr} \begin{itemdecl} template - friend constexpr simd<@\seebelow@, size()> - @\exposid{simd-select-impl}@(const basic_simd_mask& mask, const T0& a, const T1& b) noexcept; + friend constexpr vec<@\seebelow@, size()> + @\exposid{simd-select-impl}@(const basic_mask& mask, const T0& a, const T1& b) noexcept; \end{itemdecl} \begin{itemdescr} @@ -20268,15 +20253,15 @@ \pnum \returns -A \tcode{simd} object where the $i^\text{th}$ element equals +A \tcode{vec} object where the $i^\text{th}$ element equals \tcode{mask[$i$] ? a : b} for all $i$ in the range of \range{0}{size()}. \end{itemdescr} -\rSec3[simd.mask.reductions]{\tcode{basic_simd_mask} reductions} +\rSec3[simd.mask.reductions]{\tcode{basic_mask} reductions} \begin{itemdecl} template - constexpr bool all_of(const basic_simd_mask& k) noexcept; + constexpr bool all_of(const basic_mask& k) noexcept; \end{itemdecl} \begin{itemdescr} @@ -20288,7 +20273,7 @@ \begin{itemdecl} template - constexpr bool any_of(const basic_simd_mask& k) noexcept; + constexpr bool any_of(const basic_mask& k) noexcept; \end{itemdecl} \begin{itemdescr} @@ -20300,7 +20285,7 @@ \begin{itemdecl} template - constexpr bool none_of(const basic_simd_mask& k) noexcept; + constexpr bool none_of(const basic_mask& k) noexcept; \end{itemdecl} \begin{itemdescr} @@ -20311,7 +20296,7 @@ \begin{itemdecl} template - constexpr @\exposid{simd-size-type}@ reduce_count(const basic_simd_mask& k) noexcept; + constexpr @\exposid{simd-size-type}@ reduce_count(const basic_mask& k) noexcept; \end{itemdecl} \begin{itemdescr} @@ -20322,7 +20307,7 @@ \begin{itemdecl} template - constexpr @\exposid{simd-size-type}@ reduce_min_index(const basic_simd_mask& k); + constexpr @\exposid{simd-size-type}@ reduce_min_index(const basic_mask& k); \end{itemdecl} \begin{itemdescr} @@ -20337,7 +20322,7 @@ \begin{itemdecl} template - constexpr @\exposid{simd-size-type}@ reduce_max_index(const basic_simd_mask& k); + constexpr @\exposid{simd-size-type}@ reduce_max_index(const basic_mask& k); \end{itemdecl} \begin{itemdescr} From b6e501026e14600fed911183336266c0ebdf5728 Mon Sep 17 00:00:00 2001 From: Matthias Kretz Date: Mon, 23 Jun 2025 15:34:44 +0200 Subject: [PATCH 2/5] [simd] Use M instead of V for mask types --- source/numerics.tex | 38 +++++++++++++++++++------------------- 1 file changed, 19 insertions(+), 19 deletions(-) diff --git a/source/numerics.tex b/source/numerics.tex index 7664a8fd6c..3a76f14228 100644 --- a/source/numerics.tex +++ b/source/numerics.tex @@ -16634,27 +16634,27 @@ // \ref{simd.permute.dynamic}, Permute by dynamic index template<@\exposconcept{simd-vec-type}@ V, @\exposconcept{simd-integral}@ I> constexpr resize_t permute(const V& v, const I& indices); - template<@\exposconcept{simd-mask-type}@ V, @\exposconcept{simd-integral}@ I> - constexpr resize_t permute(const V& v, const I& indices); + template<@\exposconcept{simd-mask-type}@ M, @\exposconcept{simd-integral}@ I> + constexpr resize_t permute(const M& v, const I& indices); // \ref{simd.permute.mask}, Permute by active mask bits template<@\exposconcept{simd-vec-type}@ V> constexpr V compress(const V& v, const typename V::mask_type& selector); - template<@\exposconcept{simd-mask-type}@ V> - constexpr V compress(const V& v, const type_identity_t& selector); + template<@\exposconcept{simd-mask-type}@ M> + constexpr M compress(const M& v, const type_identity_t& selector); template<@\exposconcept{simd-vec-type}@ V> constexpr V compress(const V& v, const typename V::mask_type& selector, const typename V::value_type& fill_value); - template<@\exposconcept{simd-mask-type}@ V> - constexpr V compress(const V& v, const type_identity_t& selector, + template<@\exposconcept{simd-mask-type}@ M> + constexpr M compress(const M& v, const type_identity_t& selector, const typename V::value_type& fill_value); template<@\exposconcept{simd-vec-type}@ V> constexpr V expand(const V& v, const typename V::mask_type& selector, const V& original = {}); - template<@\exposconcept{simd-mask-type}@ V> - constexpr V expand(const V& v, const type_identity_t& selector, - const V& original = {}); + template<@\exposconcept{simd-mask-type}@ M> + constexpr M expand(const M& v, const type_identity_t& selector, + const M& original = {}); // \ref{simd.permute.memory}, Permute to and from memory template constexpr resize_t permute(const V& v, IdxMap&& idxmap); -template<@\exposid{simd-size-type}@ N = @\seebelow@, @\exposconcept{simd-mask-type}@ V, class IdxMap> - constexpr resize_t permute(const V& v, IdxMap&& idxmap); +template<@\exposid{simd-size-type}@ N = @\seebelow@, @\exposconcept{simd-mask-type}@ M, class IdxMap> + constexpr resize_t permute(const M& v, IdxMap&& idxmap); \end{itemdecl} \begin{itemdescr} @@ -18765,8 +18765,8 @@ \begin{itemdecl} template<@\exposconcept{simd-vec-type}@ V, @\exposconcept{simd-integral}@ I> constexpr resize_t permute(const V& v, const I& indices); -template<@\exposconcept{simd-mask-type}@ V, @\exposconcept{simd-integral}@ I> - constexpr resize_t permute(const V& v, const I& indices); +template<@\exposconcept{simd-mask-type}@ M, @\exposconcept{simd-integral}@ I> + constexpr resize_t permute(const M& v, const I& indices); \end{itemdecl} \begin{itemdescr} @@ -18786,8 +18786,8 @@ \begin{itemdecl} template<@\exposconcept{simd-vec-type}@ V> constexpr V compress(const V& v, const typename V::mask_type& selector); -template<@\exposconcept{simd-mask-type}@ V> - constexpr V compress(const V& v, const type_identity_t& selector); +template<@\exposconcept{simd-mask-type}@ M> + constexpr M compress(const M& v, const type_identity_t& selector); \end{itemdecl} \begin{itemdescr} @@ -18818,8 +18818,8 @@ template<@\exposconcept{simd-vec-type}@ V> constexpr V compress(const V& v, const typename V::mask_type& selector, const typename V::value_type& fill_value); -template<@\exposconcept{simd-mask-type}@ V> - constexpr V compress(const V& v, const type_identity_t& selector, +template<@\exposconcept{simd-mask-type}@ M> + constexpr M compress(const M& v, const type_identity_t& selector, const typename V::value_type& fill_value); \end{itemdecl} @@ -18846,8 +18846,8 @@ \begin{itemdecl} template<@\exposconcept{simd-vec-type}@ V> constexpr V expand(const V& v, const typename V::mask_type& selector, const V& original = {}); -template<@\exposconcept{simd-mask-type}@ V> - constexpr V expand(const V& v, const type_identity_t& selector, const V& original = {}); +template<@\exposconcept{simd-mask-type}@ M> + constexpr M expand(const M& v, const type_identity_t& selector, const M& original = {}); \end{itemdecl} \begin{itemdescr} From 15dcd4d4eca3a5d769254fa6e49ffd09bbd42cb1 Mon Sep 17 00:00:00 2001 From: Matthias Kretz Date: Tue, 24 Jun 2025 11:54:16 +0200 Subject: [PATCH 3/5] [simd] Rename \expos alias deduced-simd-t to deduced-vec-t Better name for an alias that is either a basic_vec specialization or void. --- source/numerics.tex | 302 ++++++++++++++++++++++---------------------- 1 file changed, 151 insertions(+), 151 deletions(-) diff --git a/source/numerics.tex b/source/numerics.tex index 3a76f14228..bfa3f83195 100644 --- a/source/numerics.tex +++ b/source/numerics.tex @@ -16227,7 +16227,7 @@ bool_constant::value && bool_constant(T()) == T::value>::value; -template using @\exposidnc{deduced-simd-t} = \seebelownc@; // \expos +template using @\exposidnc{deduced-vec-t} = \seebelownc@; // \expos template using @\exposidnc{make-compatible-simd-t} = \seebelownc@; // \expos @@ -16258,7 +16258,7 @@ template concept @\defexposconceptnc{math-floating-point}@ = // \expos - (@\exposconceptnc{simd-floating-point}<\exposidnc{deduced-simd-t}@> || ...); + (@\exposconceptnc{simd-floating-point}<\exposidnc{deduced-vec-t}@> || ...); template requires @\exposconceptnc{math-floating-point}@ @@ -16321,7 +16321,7 @@ \end{itemdescr} \begin{itemdecl} -template using @\exposid{deduced-simd-t}@ = @\seebelow@; +template using @\exposid{deduced-vec-t}@ = @\seebelow@; \end{itemdecl} \begin{itemdescr} @@ -16329,7 +16329,7 @@ Let \tcode{x} denote an lvalue of type \tcode{const T}. \pnum -\tcode{\exposid{deduced-simd-t}} is an alias for +\tcode{\exposid{deduced-vec-t}} is an alias for \begin{itemize} \item \tcode{decltype(x + x)}, if the type of \tcode{x + x} is an enabled @@ -16351,7 +16351,7 @@ \tcode{\exposid{make-compatible-simd-t}} is an alias for \begin{itemize} \item - \tcode{\exposid{deduced-simd-t}}, if that type is not \tcode{void}, + \tcode{\exposid{deduced-vec-t}}, if that type is not \tcode{void}, otherwise \item \tcode{vec}. @@ -16375,20 +16375,20 @@ Let \tcode{\exposid{math-common-simd-t}} be an alias for \begin{itemize} \item - \tcode{\exposid{deduced-simd-t}}, if \tcode{sizeof...(Ts)} equals $1$; + \tcode{\exposid{deduced-vec-t}}, if \tcode{sizeof...(Ts)} equals $1$; otherwise \item - \tcode{common_type_t<\exposid{deduced-simd-t}, - \exposid{deduced-simd-t}>}, if \tcode{sizeof...(Ts)} equals $2$ and + \tcode{common_type_t<\exposid{deduced-vec-t}, + \exposid{deduced-vec-t}>}, if \tcode{sizeof...(Ts)} equals $2$ and \tcode{\exposconcept{math-floating-point} \&\& \exposconcept{math-floating-point}} is \tcode{true}; otherwise \item - \tcode{common_type_t<\exposid{deduced-simd-t}, T1>}, if + \tcode{common_type_t<\exposid{deduced-vec-t}, T1>}, if \tcode{sizeof...(Ts)} equals $2$ and \tcode{\exposconceptx{math-floating-\brk{}point}{math-floating-point}<\brk{}T0>} is \tcode{true}; otherwise \item - \tcode{common_type_t>}, if + \tcode{common_type_t>}, if \tcode{sizeof...(Ts)} equals $2$; otherwise \item \tcode{common_type_t<\exposid{math-common-simd-t}, TRest...>}, if @@ -16787,75 +16787,75 @@ noexcept -> decltype(@\exposid{simd-select-impl}@(c, a, b)); // \ref{simd.math}, Mathematical functions - template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-simd-t}@ acos(const V& x); - template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-simd-t}@ asin(const V& x); - template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-simd-t}@ atan(const V& x); + template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-vec-t}@ acos(const V& x); + template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-vec-t}@ asin(const V& x); + template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-vec-t}@ atan(const V& x); template constexpr @\exposid{math-common-simd-t}@ atan2(const V0& y, const V1& x); - template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-simd-t}@ cos(const V& x); - template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-simd-t}@ sin(const V& x); - template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-simd-t}@ tan(const V& x); - template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-simd-t}@ acosh(const V& x); - template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-simd-t}@ asinh(const V& x); - template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-simd-t}@ atanh(const V& x); - template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-simd-t}@ cosh(const V& x); - template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-simd-t}@ sinh(const V& x); - template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-simd-t}@ tanh(const V& x); - template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-simd-t}@ exp(const V& x); - template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-simd-t}@ exp2(const V& x); - template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-simd-t}@ expm1(const V& x); + template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-vec-t}@ cos(const V& x); + template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-vec-t}@ sin(const V& x); + template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-vec-t}@ tan(const V& x); + template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-vec-t}@ acosh(const V& x); + template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-vec-t}@ asinh(const V& x); + template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-vec-t}@ atanh(const V& x); + template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-vec-t}@ cosh(const V& x); + template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-vec-t}@ sinh(const V& x); + template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-vec-t}@ tanh(const V& x); + template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-vec-t}@ exp(const V& x); + template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-vec-t}@ exp2(const V& x); + template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-vec-t}@ expm1(const V& x); template<@\exposconcept{math-floating-point}@ V> - constexpr @\exposid{deduced-simd-t}@ - frexp(const V& value, rebind_t>* exp); + constexpr @\exposid{deduced-vec-t}@ + frexp(const V& value, rebind_t>* exp); template<@\exposconcept{math-floating-point}@ V> - constexpr rebind_t> ilogb(const V& x); - template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-simd-t}@ ldexp(const V& x, const - rebind_t>& exp); - template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-simd-t}@ log(const V& x); - template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-simd-t}@ log10(const V& x); - template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-simd-t}@ log1p(const V& x); - template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-simd-t}@ log2(const V& x); - template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-simd-t}@ logb(const V& x); + constexpr rebind_t> ilogb(const V& x); + template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-vec-t}@ ldexp(const V& x, const + rebind_t>& exp); + template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-vec-t}@ log(const V& x); + template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-vec-t}@ log10(const V& x); + template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-vec-t}@ log1p(const V& x); + template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-vec-t}@ log2(const V& x); + template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-vec-t}@ logb(const V& x); template constexpr basic_vec modf(const type_identity_t>& value, basic_vec* iptr); - template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-simd-t}@ scalbn(const V& x, const - rebind_t>& n); + template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-vec-t}@ scalbn(const V& x, const + rebind_t>& n); template<@\exposconcept{math-floating-point}@ V> - constexpr @\exposid{deduced-simd-t}@ scalbln( - const V& x, const rebind_t>& n); - template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-simd-t}@ cbrt(const V& x); + constexpr @\exposid{deduced-vec-t}@ scalbln( + const V& x, const rebind_t>& n); + template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-vec-t}@ cbrt(const V& x); template<@\libconcept{signed_integral}@ T, class Abi> constexpr basic_vec abs(const basic_vec& j); - template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-simd-t}@ abs(const V& j); - template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-simd-t}@ fabs(const V& x); + template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-vec-t}@ abs(const V& j); + template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-vec-t}@ fabs(const V& x); template constexpr @\exposid{math-common-simd-t}@ hypot(const V0& x, const V1& y); template constexpr @\exposid{math-common-simd-t}@ hypot(const V0& x, const V1& y, const V2& z); template constexpr @\exposid{math-common-simd-t}@ pow(const V0& x, const V1& y); - template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-simd-t}@ sqrt(const V& x); - template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-simd-t}@ erf(const V& x); - template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-simd-t}@ erfc(const V& x); - template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-simd-t}@ lgamma(const V& x); - template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-simd-t}@ tgamma(const V& x); - template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-simd-t}@ ceil(const V& x); - template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-simd-t}@ floor(const V& x); - template<@\exposconcept{math-floating-point}@ V> @\exposid{deduced-simd-t}@ nearbyint(const V& x); - template<@\exposconcept{math-floating-point}@ V> @\exposid{deduced-simd-t}@ rint(const V& x); + template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-vec-t}@ sqrt(const V& x); + template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-vec-t}@ erf(const V& x); + template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-vec-t}@ erfc(const V& x); + template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-vec-t}@ lgamma(const V& x); + template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-vec-t}@ tgamma(const V& x); + template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-vec-t}@ ceil(const V& x); + template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-vec-t}@ floor(const V& x); + template<@\exposconcept{math-floating-point}@ V> @\exposid{deduced-vec-t}@ nearbyint(const V& x); + template<@\exposconcept{math-floating-point}@ V> @\exposid{deduced-vec-t}@ rint(const V& x); template<@\exposconcept{math-floating-point}@ V> - rebind_t> lrint(const V& x); + rebind_t> lrint(const V& x); template<@\exposconcept{math-floating-point}@ V> - rebind_t llrint(const @\exposid{deduced-simd-t}@& x); + rebind_t llrint(const @\exposid{deduced-vec-t}@& x); template<@\exposconcept{math-floating-point}@ V> - constexpr @\exposid{deduced-simd-t}@ round(const V& x); + constexpr @\exposid{deduced-vec-t}@ round(const V& x); template<@\exposconcept{math-floating-point}@ V> - constexpr rebind_t> lround(const V& x); + constexpr rebind_t> lround(const V& x); template<@\exposconcept{math-floating-point}@ V> - constexpr rebind_t> llround(const V& x); + constexpr rebind_t> llround(const V& x); template<@\exposconcept{math-floating-point}@ V> - constexpr @\exposid{deduced-simd-t}@ trunc(const V& x); + constexpr @\exposid{deduced-vec-t}@ trunc(const V& x); template constexpr @\exposid{math-common-simd-t}@ fmod(const V0& x, const V1& y); template @@ -16879,17 +16879,17 @@ constexpr @\exposid{math-common-simd-t}@ lerp(const V0& a, const V1& b, const V2& t) noexcept; template<@\exposconcept{math-floating-point}@ V> - constexpr rebind_t> fpclassify(const V& x); + constexpr rebind_t> fpclassify(const V& x); template<@\exposconcept{math-floating-point}@ V> - constexpr typename @\exposid{deduced-simd-t}@::mask_type isfinite(const V& x); + constexpr typename @\exposid{deduced-vec-t}@::mask_type isfinite(const V& x); template<@\exposconcept{math-floating-point}@ V> - constexpr typename @\exposid{deduced-simd-t}@::mask_type isinf(const V& x); + constexpr typename @\exposid{deduced-vec-t}@::mask_type isinf(const V& x); template<@\exposconcept{math-floating-point}@ V> - constexpr typename @\exposid{deduced-simd-t}@::mask_type isnan(const V& x); + constexpr typename @\exposid{deduced-vec-t}@::mask_type isnan(const V& x); template<@\exposconcept{math-floating-point}@ V> - constexpr typename @\exposid{deduced-simd-t}@::mask_type isnormal(const V& x); + constexpr typename @\exposid{deduced-vec-t}@::mask_type isnormal(const V& x); template<@\exposconcept{math-floating-point}@ V> - constexpr typename @\exposid{deduced-simd-t}@::mask_type signbit(const V& x); + constexpr typename @\exposid{deduced-vec-t}@::mask_type signbit(const V& x); template constexpr typename @\exposid{math-common-simd-t}@::mask_type isgreater(const V0& x, const V1& y); @@ -16909,17 +16909,17 @@ constexpr typename @\exposid{math-common-simd-t}@::mask_type isunordered(const V0& x, const V1& y); template<@\exposconcept{math-floating-point}@ V> - @\exposid{deduced-simd-t}@ assoc_laguerre(const rebind_t>& n, const - rebind_t>& m, + @\exposid{deduced-vec-t}@ assoc_laguerre(const rebind_t>& n, const + rebind_t>& m, const V& x); template<@\exposconcept{math-floating-point}@ V> - @\exposid{deduced-simd-t}@ assoc_legendre(const rebind_t>& l, const - rebind_t>& m, + @\exposid{deduced-vec-t}@ assoc_legendre(const rebind_t>& l, const + rebind_t>& m, const V& x); template @\exposid{math-common-simd-t}@ beta(const V0& x, const V1& y); - template<@\exposconcept{math-floating-point}@ V> @\exposid{deduced-simd-t}@ comp_ellint_1(const V& k); - template<@\exposconcept{math-floating-point}@ V> @\exposid{deduced-simd-t}@ comp_ellint_2(const V& k); + template<@\exposconcept{math-floating-point}@ V> @\exposid{deduced-vec-t}@ comp_ellint_1(const V& k); + template<@\exposconcept{math-floating-point}@ V> @\exposid{deduced-vec-t}@ comp_ellint_2(const V& k); template @\exposid{math-common-simd-t}@ comp_ellint_3(const V0& k, const V1& nu); template @@ -16936,24 +16936,24 @@ @\exposid{math-common-simd-t}@ ellint_2(const V0& k, const V1& phi); template @\exposid{math-common-simd-t}@ ellint_3(const V0& k, const V1& nu, const V2& phi); - template<@\exposconcept{math-floating-point}@ V> @\exposid{deduced-simd-t}@ expint(const V& x); + template<@\exposconcept{math-floating-point}@ V> @\exposid{deduced-vec-t}@ expint(const V& x); template<@\exposconcept{math-floating-point}@ V> - @\exposid{deduced-simd-t}@ hermite(const rebind_t>& n, const V& x); + @\exposid{deduced-vec-t}@ hermite(const rebind_t>& n, const V& x); template<@\exposconcept{math-floating-point}@ V> - @\exposid{deduced-simd-t}@ laguerre(const rebind_t>& n, const V& x); + @\exposid{deduced-vec-t}@ laguerre(const rebind_t>& n, const V& x); template<@\exposconcept{math-floating-point}@ V> - @\exposid{deduced-simd-t}@ legendre(const rebind_t>& l, const V& x); + @\exposid{deduced-vec-t}@ legendre(const rebind_t>& l, const V& x); template<@\exposconcept{math-floating-point}@ V> - @\exposid{deduced-simd-t}@ riemann_zeta(const V& x); + @\exposid{deduced-vec-t}@ riemann_zeta(const V& x); template<@\exposconcept{math-floating-point}@ V> - @\exposid{deduced-simd-t}@ sph_bessel( - const rebind_t>& n, const V& x); + @\exposid{deduced-vec-t}@ sph_bessel( + const rebind_t>& n, const V& x); template<@\exposconcept{math-floating-point}@ V> - @\exposid{deduced-simd-t}@ sph_legendre(const rebind_t>& l, - const rebind_t>& m, const V& theta); + @\exposid{deduced-vec-t}@ sph_legendre(const rebind_t>& l, + const rebind_t>& m, const V& theta); template<@\exposconcept{math-floating-point}@ V> - @\exposid{deduced-simd-t}@ - sph_neumann(const rebind_t>& n, const V& x); + @\exposid{deduced-vec-t}@ + sph_neumann(const rebind_t>& n, const V& x); // \ref{simd.bit}, Bit manipulation template<@\exposconcept{simd-vec-type}@ V> constexpr V byteswap(const V& v) noexcept; @@ -19264,42 +19264,42 @@ \begin{itemdecl} template<@\exposconcept{math-floating-point}@ V> - constexpr rebind_t> ilogb(const V& x); + constexpr rebind_t> ilogb(const V& x); template<@\exposconcept{math-floating-point}@ V> - constexpr @\exposid{deduced-simd-t}@ ldexp(const V& x, const rebind_t>& exp); + constexpr @\exposid{deduced-vec-t}@ ldexp(const V& x, const rebind_t>& exp); template<@\exposconcept{math-floating-point}@ V> - constexpr @\exposid{deduced-simd-t}@ scalbn(const V& x, const rebind_t>& n); + constexpr @\exposid{deduced-vec-t}@ scalbn(const V& x, const rebind_t>& n); template<@\exposconcept{math-floating-point}@ V> - constexpr @\exposid{deduced-simd-t}@ - scalbln(const V& x, const rebind_t>& n); + constexpr @\exposid{deduced-vec-t}@ + scalbln(const V& x, const rebind_t>& n); template<@\libconcept{signed_integral}@ T, class Abi> constexpr basic_vec abs(const basic_vec& j); template<@\exposconcept{math-floating-point}@ V> - constexpr @\exposid{deduced-simd-t}@ abs(const V& j); + constexpr @\exposid{deduced-vec-t}@ abs(const V& j); template<@\exposconcept{math-floating-point}@ V> - constexpr @\exposid{deduced-simd-t}@ fabs(const V& x); + constexpr @\exposid{deduced-vec-t}@ fabs(const V& x); template<@\exposconcept{math-floating-point}@ V> - constexpr @\exposid{deduced-simd-t}@ ceil(const V& x); + constexpr @\exposid{deduced-vec-t}@ ceil(const V& x); template<@\exposconcept{math-floating-point}@ V> - constexpr @\exposid{deduced-simd-t}@ floor(const V& x); + constexpr @\exposid{deduced-vec-t}@ floor(const V& x); template<@\exposconcept{math-floating-point}@ V> - @\exposid{deduced-simd-t}@ nearbyint(const V& x); + @\exposid{deduced-vec-t}@ nearbyint(const V& x); template<@\exposconcept{math-floating-point}@ V> - @\exposid{deduced-simd-t}@ rint(const V& x); + @\exposid{deduced-vec-t}@ rint(const V& x); template<@\exposconcept{math-floating-point}@ V> - rebind_t> lrint(const V& x); + rebind_t> lrint(const V& x); template<@\exposconcept{math-floating-point}@ V> - rebind_t> llrint(const V& x); + rebind_t> llrint(const V& x); template<@\exposconcept{math-floating-point}@ V> - constexpr @\exposid{deduced-simd-t}@ round(const V& x); + constexpr @\exposid{deduced-vec-t}@ round(const V& x); template<@\exposconcept{math-floating-point}@ V> - constexpr rebind_t> lround(const V& x); + constexpr rebind_t> lround(const V& x); template<@\exposconcept{math-floating-point}@ V> - constexpr rebind_t> llround(const V& x); + constexpr rebind_t> llround(const V& x); template constexpr @\exposid{math-common-simd-t}@ fmod(const V0& x, const V1& y); template<@\exposconcept{math-floating-point}@ V> - constexpr @\exposid{deduced-simd-t}@ trunc(const V& x); + constexpr @\exposid{deduced-vec-t}@ trunc(const V& x); template constexpr @\exposid{math-common-simd-t}@ remainder(const V0& x, const V1& y); template @@ -19315,17 +19315,17 @@ template constexpr @\exposid{math-common-simd-t}@ fma(const V0& x, const V1& y, const V2& z); template<@\exposconcept{math-floating-point}@ V> - constexpr rebind_t> fpclassify(const V& x); + constexpr rebind_t> fpclassify(const V& x); template<@\exposconcept{math-floating-point}@ V> - constexpr typename @\exposid{deduced-simd-t}@::mask_type isfinite(const V& x); + constexpr typename @\exposid{deduced-vec-t}@::mask_type isfinite(const V& x); template<@\exposconcept{math-floating-point}@ V> - constexpr typename @\exposid{deduced-simd-t}@::mask_type isinf(const V& x); + constexpr typename @\exposid{deduced-vec-t}@::mask_type isinf(const V& x); template<@\exposconcept{math-floating-point}@ V> - constexpr typename @\exposid{deduced-simd-t}@::mask_type isnan(const V& x); + constexpr typename @\exposid{deduced-vec-t}@::mask_type isnan(const V& x); template<@\exposconcept{math-floating-point}@ V> - constexpr typename @\exposid{deduced-simd-t}@::mask_type isnormal(const V& x); + constexpr typename @\exposid{deduced-vec-t}@::mask_type isnormal(const V& x); template<@\exposconcept{math-floating-point}@ V> - constexpr typename @\exposid{deduced-simd-t}@::mask_type signbit(const V& x); + constexpr typename @\exposid{deduced-vec-t}@::mask_type signbit(const V& x); template constexpr typename @\exposid{math-common-simd-t}@::mask_type isgreater(const V0& x, const V1& y); template @@ -19370,54 +19370,54 @@ \end{itemdescr} \begin{itemdecl} -template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-simd-t}@ acos(const V& x); -template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-simd-t}@ asin(const V& x); -template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-simd-t}@ atan(const V& x); +template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-vec-t}@ acos(const V& x); +template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-vec-t}@ asin(const V& x); +template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-vec-t}@ atan(const V& x); template constexpr @\exposid{math-common-simd-t}@ atan2(const V0& y, const V1& x); -template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-simd-t}@ cos(const V& x); -template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-simd-t}@ sin(const V& x); -template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-simd-t}@ tan(const V& x); -template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-simd-t}@ acosh(const V& x); -template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-simd-t}@ asinh(const V& x); -template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-simd-t}@ atanh(const V& x); -template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-simd-t}@ cosh(const V& x); -template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-simd-t}@ sinh(const V& x); -template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-simd-t}@ tanh(const V& x); -template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-simd-t}@ exp(const V& x); -template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-simd-t}@ exp2(const V& x); -template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-simd-t}@ expm1(const V& x); -template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-simd-t}@ log(const V& x); -template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-simd-t}@ log10(const V& x); -template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-simd-t}@ log1p(const V& x); -template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-simd-t}@ log2(const V& x); -template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-simd-t}@ logb(const V& x); -template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-simd-t}@ cbrt(const V& x); +template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-vec-t}@ cos(const V& x); +template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-vec-t}@ sin(const V& x); +template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-vec-t}@ tan(const V& x); +template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-vec-t}@ acosh(const V& x); +template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-vec-t}@ asinh(const V& x); +template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-vec-t}@ atanh(const V& x); +template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-vec-t}@ cosh(const V& x); +template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-vec-t}@ sinh(const V& x); +template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-vec-t}@ tanh(const V& x); +template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-vec-t}@ exp(const V& x); +template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-vec-t}@ exp2(const V& x); +template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-vec-t}@ expm1(const V& x); +template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-vec-t}@ log(const V& x); +template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-vec-t}@ log10(const V& x); +template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-vec-t}@ log1p(const V& x); +template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-vec-t}@ log2(const V& x); +template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-vec-t}@ logb(const V& x); +template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-vec-t}@ cbrt(const V& x); template constexpr @\exposid{math-common-simd-t}@ hypot(const V0& x, const V1& y); template constexpr @\exposid{math-common-simd-t}@ hypot(const V0& x, const V1& y, const V2& z); template constexpr @\exposid{math-common-simd-t}@ pow(const V0& x, const V1& y); -template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-simd-t}@ sqrt(const V& x); -template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-simd-t}@ erf(const V& x); -template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-simd-t}@ erfc(const V& x); -template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-simd-t}@ lgamma(const V& x); -template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-simd-t}@ tgamma(const V& x); +template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-vec-t}@ sqrt(const V& x); +template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-vec-t}@ erf(const V& x); +template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-vec-t}@ erfc(const V& x); +template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-vec-t}@ lgamma(const V& x); +template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-vec-t}@ tgamma(const V& x); template constexpr @\exposid{math-common-simd-t}@ lerp(const V0& a, const V1& b, const V2& t) noexcept; template<@\exposconcept{math-floating-point}@ V> - @\exposid{deduced-simd-t}@ assoc_laguerre(const rebind_t>& n, const - rebind_t>& m, + @\exposid{deduced-vec-t}@ assoc_laguerre(const rebind_t>& n, const + rebind_t>& m, const V& x); template<@\exposconcept{math-floating-point}@ V> - @\exposid{deduced-simd-t}@ assoc_legendre(const rebind_t>& l, const - rebind_t>& m, + @\exposid{deduced-vec-t}@ assoc_legendre(const rebind_t>& l, const + rebind_t>& m, const V& x); template @\exposid{math-common-simd-t}@ beta(const V0& x, const V1& y); -template<@\exposconcept{math-floating-point}@ V> @\exposid{deduced-simd-t}@ comp_ellint_1(const V& k); -template<@\exposconcept{math-floating-point}@ V> @\exposid{deduced-simd-t}@ comp_ellint_2(const V& k); +template<@\exposconcept{math-floating-point}@ V> @\exposid{deduced-vec-t}@ comp_ellint_1(const V& k); +template<@\exposconcept{math-floating-point}@ V> @\exposid{deduced-vec-t}@ comp_ellint_2(const V& k); template @\exposid{math-common-simd-t}@ comp_ellint_3(const V0& k, const V1& nu); template @@ -19434,22 +19434,22 @@ @\exposid{math-common-simd-t}@ ellint_2(const V0& k, const V1& phi); template @\exposid{math-common-simd-t}@ ellint_3(const V0& k, const V1& nu, const V2& phi); -template<@\exposconcept{math-floating-point}@ V> @\exposid{deduced-simd-t}@ expint(const V& x); -template<@\exposconcept{math-floating-point}@ V> @\exposid{deduced-simd-t}@ hermite(const rebind_t>& n, const V& x); -template<@\exposconcept{math-floating-point}@ V> @\exposid{deduced-simd-t}@ laguerre(const rebind_t>& n, const V& x); -template<@\exposconcept{math-floating-point}@ V> @\exposid{deduced-simd-t}@ legendre(const rebind_t>& l, const V& x); -template<@\exposconcept{math-floating-point}@ V> @\exposid{deduced-simd-t}@ riemann_zeta(const V& x); -template<@\exposconcept{math-floating-point}@ V> @\exposid{deduced-simd-t}@ sph_bessel(const rebind_t>& n, const V& x); +template<@\exposconcept{math-floating-point}@ V> @\exposid{deduced-vec-t}@ expint(const V& x); +template<@\exposconcept{math-floating-point}@ V> @\exposid{deduced-vec-t}@ hermite(const rebind_t>& n, const V& x); +template<@\exposconcept{math-floating-point}@ V> @\exposid{deduced-vec-t}@ laguerre(const rebind_t>& n, const V& x); +template<@\exposconcept{math-floating-point}@ V> @\exposid{deduced-vec-t}@ legendre(const rebind_t>& l, const V& x); +template<@\exposconcept{math-floating-point}@ V> @\exposid{deduced-vec-t}@ riemann_zeta(const V& x); +template<@\exposconcept{math-floating-point}@ V> @\exposid{deduced-vec-t}@ sph_bessel(const rebind_t>& n, const V& x); template<@\exposconcept{math-floating-point}@ V> - @\exposid{deduced-simd-t}@ sph_legendre(const rebind_t>& l, - const rebind_t>& m, + @\exposid{deduced-vec-t}@ sph_legendre(const rebind_t>& l, + const rebind_t>& m, const V& theta); -template<@\exposconcept{math-floating-point}@ V> @\exposid{deduced-simd-t}@ sph_neumann(const rebind_t>& n, const V& x); +template<@\exposconcept{math-floating-point}@ V> @\exposid{deduced-vec-t}@ sph_neumann(const rebind_t>& n, const V& x); \end{itemdecl} \begin{itemdescr} @@ -19482,12 +19482,12 @@ \begin{itemdecl} template<@\exposconcept{math-floating-point}@ V> - constexpr @\exposid{deduced-simd-t}@ frexp(const V& value, rebind_t>* exp); + constexpr @\exposid{deduced-vec-t}@ frexp(const V& value, rebind_t>* exp); \end{itemdecl} \begin{itemdescr} \pnum -Let \tcode{Ret} be \tcode{\exposid{deduced-simd-t}}. +Let \tcode{Ret} be \tcode{\exposid{deduced-vec-t}}. Let \placeholder{frexp-vec} denote: \begin{codeblock} template From 7d8e6d718421cc8c0e3eddfbc5a5802a5f25b8e6 Mon Sep 17 00:00:00 2001 From: Matthias Kretz Date: Tue, 24 Jun 2025 17:23:32 +0200 Subject: [PATCH 4/5] [simd.permute.*] Shorten 'basic_vec and basic_mask' to 'data-parallel' --- source/numerics.tex | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/source/numerics.tex b/source/numerics.tex index bfa3f83195..1d6d8ee081 100644 --- a/source/numerics.tex +++ b/source/numerics.tex @@ -18751,7 +18751,7 @@ \pnum \returns -A \tcode{basic_vec} or \tcode{basic_mask} object where the +A data-parallel object where the $i^\text{th}$ element is initialized to the result of \tcode{\exposid{perm-fn}<$i$>()} for all $i$ in the range \range{0}{N}. @@ -18776,7 +18776,7 @@ \pnum \returns -A \tcode{basic_vec} or \tcode{basic_mask} object where the $i^\text{th}$ +A data-parallel object where the $i^\text{th}$ element is initialized to the result of \tcode{v[indices[$i$]]} for all $i$ in the range \range{0}{I::size()}. \end{itemdescr} @@ -18809,7 +18809,7 @@ \pnum \returns -A \tcode{basic_vec} or \tcode{basic_mask} object where the $i^\text{th}$ +A data-parallel object where the $i^\text{th}$ element is initialized to the result of \tcode{\exposidnc{select-value}($i$)} for all $i$ in the range \range{0}{V::size()}. \end{itemdescr} @@ -18838,7 +18838,7 @@ \pnum \returns -A \tcode{basic_vec} or \tcode{basic_mask} object where the $i^\text{th}$ +A data-parallel object where the $i^\text{th}$ element is initialized to the result of \tcode{\exposidnc{select-value}($i$)} for all $i$ in the range \range{0}{V::size()}. \end{itemdescr} @@ -18868,7 +18868,7 @@ \pnum \returns -A \tcode{basic_vec} or \tcode{basic_mask} object where the $i^\text{th}$ +A data-parallel object where the $i^\text{th}$ element is initialized to the result of \tcode{\exposidnc{select-value}($i$)} for all $i$ in the range \range{0}{V::size()}. \end{itemdescr} From a7f5d6a8ead725ce81641b408f0d0503b611a580 Mon Sep 17 00:00:00 2001 From: Matthias Kretz Date: Wed, 25 Jun 2025 11:49:36 +0200 Subject: [PATCH 5/5] [simd] Add simd types and functions to the index --- source/numerics.tex | 296 +++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 278 insertions(+), 18 deletions(-) diff --git a/source/numerics.tex b/source/numerics.tex index 1d6d8ee081..59d0c30c13 100644 --- a/source/numerics.tex +++ b/source/numerics.tex @@ -16503,20 +16503,20 @@ // \ref{simd.traits}, \tcode{simd} type traits template struct alignment; template - constexpr size_t alignment_v = alignment::value; + constexpr size_t @\libmember{alignment_v}{simd}@ = alignment::value; template struct rebind { using type = @\seebelow@; }; - template using rebind_t = typename rebind::type; + template using @\libmember{rebind_t}{simd}@ = typename rebind::type; template<@\exposid{simd-size-type}@ N, class V> struct resize { using type = @\seebelow@; }; - template<@\exposid{simd-size-type}@ N, class V> using resize_t = typename resize::type; + template<@\exposid{simd-size-type}@ N, class V> using @\libmember{resize_t}{simd}@ = typename resize::type; // \ref{simd.flags}, Load and store flags template struct flags; - inline constexpr flags<> flag_default{}; - inline constexpr flags<@\exposid{convert-flag}@> flag_convert{}; - inline constexpr flags<@\exposid{aligned-flag}@> flag_aligned{}; + inline constexpr flags<> @\libmember{flag_default}{simd}@{}; + inline constexpr flags<@\exposid{convert-flag}@> @\libmember{flag_convert}{simd}@{}; + inline constexpr flags<@\exposid{aligned-flag}@> @\libmember{flag_aligned}{simd}@{}; template requires (has_single_bit(N)) - constexpr flags<@\exposid{overaligned-flag}@> flag_overaligned{}; + constexpr flags<@\exposid{overaligned-flag}@> @\libmember{flag_overaligned}{simd}@{}; // \ref{simd.iterator}, Class template \exposid{simd-iterator} template @@ -16525,12 +16525,12 @@ // \ref{simd.class}, Class template \tcode{basic_vec} template> class basic_vec; template>> - using vec = basic_vec>; + using @\libmember{vec}{simd}@ = basic_vec>; // \ref{simd.mask.class}, Class template \tcode{basic_mask} template>> class basic_mask; template>> - using mask = basic_mask>; + using @\libmember{mask}{simd}@ = basic_mask>; // \ref{simd.loadstore}, \tcode{basic_vec} load and store functions template @@ -16623,8 +16623,8 @@ const typename basic_vec::mask_type& mask, flags f = {}); // \ref{simd.permute.static}, Permute by static index generator - static constexpr @\exposid{simd-size-type}@ zero_element = @\impdefx{value of \tcode{simd::zero_element}}@; - static constexpr @\exposid{simd-size-type}@ uninit_element = @\impdefx{value of \tcode{simd::uninit_element}}@; + static constexpr @\exposid{simd-size-type}@ @\libmember{zero_element}{simd}@ = @\impdefx{value of \tcode{simd::zero_element}}@; + static constexpr @\exposid{simd-size-type}@ @\libmember{uninit_element}{simd}@ = @\impdefx{value of \tcode{simd::uninit_element}}@; template<@\exposid{simd-size-type}@ N = @\seebelow@, @\exposconcept{simd-vec-type}@ V, class IdxMap> constexpr resize_t permute(const V& v, IdxMap&& idxmap); @@ -17157,6 +17157,7 @@ \rSec2[simd.traits]{\tcode{vec} type traits} +\indexlibrarymember{alignment}{simd} \begin{itemdecl} template struct alignment { @\seebelow@ }; \end{itemdecl} @@ -17189,6 +17190,7 @@ is undefined. \end{itemdescr} +\indexlibrarymember{rebind}{simd} \begin{itemdecl} template struct rebind { using type = @\seebelow@; }; \end{itemdecl} @@ -17218,6 +17220,7 @@ \tcode{basic_mask}. \end{itemdescr} +\indexlibrarymember{resize}{simd} \begin{itemdecl} template<@\exposid{simd-size-type}@ N, class V> struct resize { using type = @\seebelow@; }; \end{itemdecl} @@ -17258,6 +17261,7 @@ \rSec3[simd.flags.overview]{Class template \tcode{flags} overview} +\indexlibrarymember{flags}{simd} \begin{codeblock} namespace std::simd { template struct flags { @@ -17280,6 +17284,7 @@ \rSec3[simd.flags.oper]{\tcode{flags} operators} +\indexlibrarymember{operator|}{simd::flags} \begin{itemdecl} template friend consteval auto operator|(flags a, flags b); @@ -17299,6 +17304,11 @@ \end{itemdescr} \rSec2[simd.iterator]{Class template \exposid{simd-iterator}} + +\indexlibrarymember{iterator}{basic_vec}% +\indexlibrarymember{iterator}{basic_mask}% +\indexlibrarymember{const_iterator}{basic_vec}% +\indexlibrarymember{const_iterator}{basic_mask}% \begin{codeblock} namespace std::simd { template @@ -17558,13 +17568,14 @@ \rSec3[simd.overview]{Class template \tcode{basic_vec} overview} +\indexlibraryglobal{basic_vec}% \begin{codeblock} namespace std::simd { template class basic_vec { public: - using value_type = T; - using mask_type = basic_mask; - using abi_type = Abi; + using @\libmember{value_type}{basic_vec}@ = T; + using @\libmember{mask_type}{basic_vec}@ = basic_mask; + using @\libmember{abi_type}{basic_vec}@ = Abi; using @\libmember{iterator}{basic_vec}@ = @\exposid{simd-iterator}@; using @\libmember{const_iterator}{basic_vec}@ = @\exposid{simd-iterator}@; @@ -17574,7 +17585,7 @@ constexpr default_sentinel_t @\libmember{end}{basic_vec}@() const noexcept { return {}; } constexpr default_sentinel_t @\libmember{cend}{basic_vec}@() const noexcept { return {}; } - static constexpr integral_constant<@\exposid{simd-size-type}@, @\exposid{simd-size-v}@> size {}; + static constexpr integral_constant<@\exposid{simd-size-type}@, @\exposid{simd-size-v}@> @\libmember{size}{basic_vec}@ {}; constexpr basic_vec() noexcept = default; @@ -17699,6 +17710,7 @@ \rSec3[simd.ctor]{\tcode{basic_vec} constructors} +\indexlibraryctor{basic_vec} \begin{itemdecl} template constexpr explicit(@\seebelow@) basic_vec(U&& value) noexcept; \end{itemdecl} @@ -17734,6 +17746,7 @@ \end{itemize} \end{itemdescr} +\indexlibraryctor{basic_vec} \begin{itemdecl} template constexpr explicit(@\seebelow@) basic_vec(const basic_vec& x) noexcept; @@ -17767,6 +17780,7 @@ \end{itemize} \end{itemdescr} +\indexlibraryctor{basic_vec} \begin{itemdecl} template constexpr explicit basic_vec(G&& gen); \end{itemdecl} @@ -17795,6 +17809,7 @@ \tcode{gen} is invoked exactly once for each $i$, in increasing order of $i$. \end{itemdescr} +\indexlibraryctor{basic_vec} \begin{itemdecl} template constexpr basic_vec(R&& r, flags = {}); @@ -17868,6 +17883,7 @@ ranges::size(r)>}. \end{itemdescr} +\indexlibraryctor{basic_vec} \begin{itemdecl} template<@\exposconcept{simd-floating-point}@ V> constexpr explicit(@\seebelow@) @@ -17898,6 +17914,7 @@ \rSec3[simd.subscr]{\tcode{basic_vec} subscript operator} +\indexlibrarymember{operator[]}{basic_vec} \begin{itemdecl} constexpr value_type operator[](@\exposid{simd-size-type}@ i) const; \end{itemdecl} @@ -17916,6 +17933,7 @@ Nothing. \end{itemdescr} +\indexlibrarymember{operator[]}{basic_vec} \begin{itemdecl} template<@\exposconcept{simd-integral}@ I> constexpr resize_t operator[](const I& indices) const; @@ -17932,6 +17950,7 @@ \pnum Effects in \ref{simd.unary} are applied as unary element-wise operations. +\indexlibrarymember{operator++}{basic_vec} \begin{itemdecl} constexpr basic_vec& operator++() noexcept; \end{itemdecl} @@ -17950,6 +17969,7 @@ \tcode{*this}. \end{itemdescr} +\indexlibrarymember{operator++}{basic_vec} \begin{itemdecl} constexpr basic_vec operator++(int) noexcept; \end{itemdecl} @@ -17968,6 +17988,7 @@ A copy of \tcode{*this} before incrementing. \end{itemdescr} +\indexlibrarymember{operator--}{basic_vec} \begin{itemdecl} constexpr basic_vec& operator--() noexcept; \end{itemdecl} @@ -17986,6 +18007,7 @@ \tcode{*this}. \end{itemdescr} +\indexlibrarymember{operator--}{basic_vec} \begin{itemdecl} constexpr basic_vec operator--(int) noexcept; \end{itemdecl} @@ -18004,6 +18026,7 @@ A copy of \tcode{*this} before decrementing. \end{itemdescr} +\indexlibrarymember{operator!}{basic_vec} \begin{itemdecl} constexpr mask_type operator!() const noexcept; \end{itemdecl} @@ -18019,6 +18042,7 @@ \tcode{!operator[]($i$)} for all $i$ in the range of \range{0}{size()}. \end{itemdescr} +\indexlibrarymember{operator~}{basic_vec} \begin{itemdecl} constexpr basic_vec operator~() const noexcept; \end{itemdecl} @@ -18034,6 +18058,7 @@ \tcode{\~{}operator[]($i$)} for all $i$ in the range of \range{0}{size()}. \end{itemdescr} +\indexlibrarymember{operator+}{basic_vec} \begin{itemdecl} constexpr basic_vec operator+() const noexcept; \end{itemdecl} @@ -18048,6 +18073,7 @@ \tcode{*this}. \end{itemdescr} +\indexlibrarymember{operator-}{basic_vec} \begin{itemdecl} constexpr basic_vec operator-() const noexcept; \end{itemdecl} @@ -18067,6 +18093,16 @@ \rSec3[simd.binary]{\tcode{basic_vec} binary operators} +\indexlibrarymember{operator+}{basic_vec} +\indexlibrarymember{operator-}{basic_vec} +\indexlibrarymember{operator*}{basic_vec} +\indexlibrarymember{operator/}{basic_vec} +\indexlibrarymember{operator\%}{basic_vec} +\indexlibrarymember{operator\&}{basic_vec} +\indexlibrarymember{operator|}{basic_vec} +\indexlibrarymember{operator\caret}{basic_vec} +\indexlibrarymember{operator<<}{basic_vec} +\indexlibrarymember{operator>>}{basic_vec} \begin{itemdecl} 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; @@ -18096,6 +18132,8 @@ operation. \end{itemdescr} +\indexlibrarymember{operator<<}{basic_vec} +\indexlibrarymember{operator>>}{basic_vec} \begin{itemdecl} friend constexpr basic_vec operator<<(const basic_vec& v, @\exposid{simd-size-type}@ n) noexcept; friend constexpr basic_vec operator>>(const basic_vec& v, @\exposid{simd-size-type}@ n) noexcept; @@ -18119,6 +18157,16 @@ \rSec3[simd.cassign]{\tcode{basic_vec} compound assignment} +\indexlibrarymember{operator+=}{basic_vec} +\indexlibrarymember{operator-=}{basic_vec} +\indexlibrarymember{operator*=}{basic_vec} +\indexlibrarymember{operator/=}{basic_vec} +\indexlibrarymember{operator\%=}{basic_vec} +\indexlibrarymember{operator\&=}{basic_vec} +\indexlibrarymember{operator|=}{basic_vec} +\indexlibrarymember{operator\caret=}{basic_vec} +\indexlibrarymember{operator<<=}{basic_vec} +\indexlibrarymember{operator>>=}{basic_vec} \begin{itemdecl} 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; @@ -18151,6 +18199,8 @@ \tcode{lhs}. \end{itemdescr} +\indexlibrarymember{operator<<=}{basic_vec} +\indexlibrarymember{operator>>=}{basic_vec} \begin{itemdecl} friend constexpr basic_vec& operator<<=(basic_vec& lhs, @\exposid{simd-size-type}@ n) noexcept; friend constexpr basic_vec& operator>>=(basic_vec& lhs, @\exposid{simd-size-type}@ n) noexcept; @@ -18172,6 +18222,12 @@ \rSec3[simd.comparison]{\tcode{basic_vec} compare operators} +\indexlibrarymember{operator==}{basic_vec} +\indexlibrarymember{operator!=}{basic_vec} +\indexlibrarymember{operator>=}{basic_vec} +\indexlibrarymember{operator<=}{basic_vec} +\indexlibrarymember{operator>}{basic_vec} +\indexlibrarymember{operator<}{basic_vec} \begin{itemdecl} 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; @@ -18199,6 +18255,8 @@ \rSec3[simd.complex.access]{\tcode{vec} complex accessors} +\indexlibrarymember{real}{basic_vec} +\indexlibrarymember{imag}{basic_vec} \begin{itemdecl} constexpr auto real() const noexcept; constexpr auto imag() const noexcept; @@ -18218,6 +18276,8 @@ from \libheader{complex}. \end{itemdescr} +\indexlibrarymember{real}{basic_vec} +\indexlibrarymember{imag}{basic_vec} \begin{itemdecl} template<@\exposconcept{simd-floating-point}@ V> constexpr void real(const V& v) noexcept; @@ -18263,6 +18323,7 @@ \rSec3[simd.reductions]{\tcode{basic_vec} reductions} +\indexlibrarymember{reduce}{simd} \begin{itemdecl} template> constexpr T reduce(const basic_vec& x, BinaryOperation binary_op = {}); @@ -18288,6 +18349,7 @@ Any exception thrown from \tcode{binary_op}. \end{itemdescr} +\indexlibrarymember{reduce}{simd} \begin{itemdecl} template> constexpr T reduce( @@ -18344,6 +18406,7 @@ \end{itemize} \end{itemdescr} +\indexlibrarymember{reduce_min}{simd} \begin{itemdecl} template constexpr T reduce_min(const basic_vec& x) noexcept; \end{itemdecl} @@ -18359,6 +18422,7 @@ \tcode{false} for all $i$ in the range of \range{0}{basic_vec::size()}. \end{itemdescr} +\indexlibrarymember{reduce_min}{simd} \begin{itemdecl} template constexpr T reduce_min( @@ -18379,6 +18443,7 @@ \tcode{mask}. \end{itemdescr} +\indexlibrarymember{reduce_max}{simd} \begin{itemdecl} template constexpr T reduce_max(const basic_vec& x) noexcept; \end{itemdecl} @@ -18394,6 +18459,7 @@ \tcode{false} for all $i$ in the range of \range{0}{basic_vec::size()}. \end{itemdescr} +\indexlibrarymember{reduce_max}{simd} \begin{itemdecl} template constexpr T reduce_max( @@ -18416,6 +18482,7 @@ \rSec3[simd.loadstore]{\tcode{basic_vec} load and store functions} +\indexlibrarymember{unchecked_load}{simd} \begin{itemdecl} template requires ranges::@\libconcept{sized_range}@ @@ -18476,6 +18543,7 @@ \tcode{basic_vec>}. \end{itemdescr} +\indexlibrarymember{partial_load}{simd} \begin{itemdecl} template requires ranges::@\libconcept{sized_range}@ @@ -18559,6 +18627,7 @@ \tcode{basic_vec>}. \end{itemdescr} +\indexlibrarymember{unchecked_store}{simd} \begin{itemdecl} template requires ranges::@\libconcept{sized_range}@ && @\libconcept{indirectly_writable}@, T> @@ -18624,6 +18693,7 @@ Equivalent to: \tcode{partial_store(v, r, mask, f)}. \end{itemdescr} +\indexlibrarymember{partial_store}{simd} \begin{itemdecl} template requires ranges::@\libconcept{sized_range}@ && @\libconcept{indirectly_writable}@, T> @@ -18706,6 +18776,7 @@ \rSec3[simd.permute.static]{\tcode{vec} static permute} +\indexlibrarymember{permute}{simd} \begin{itemdecl} template<@\exposid{simd-size-type}@ N = @\seebelow@, @\exposconcept{simd-vec-type}@ V, class IdxMap> constexpr resize_t permute(const V& v, IdxMap&& idxmap); @@ -18762,6 +18833,7 @@ \rSec3[simd.permute.dynamic]{\tcode{vec} dynamic permute} +\indexlibrarymember{permute}{simd} \begin{itemdecl} template<@\exposconcept{simd-vec-type}@ V, @\exposconcept{simd-integral}@ I> constexpr resize_t permute(const V& v, const I& indices); @@ -18783,6 +18855,7 @@ \rSec3[simd.permute.mask]{\tcode{vec} mask permute} +\indexlibrarymember{compress}{simd} \begin{itemdecl} template<@\exposconcept{simd-vec-type}@ V> constexpr V compress(const V& v, const typename V::mask_type& selector); @@ -18814,6 +18887,7 @@ for all $i$ in the range \range{0}{V::size()}. \end{itemdescr} +\indexlibrarymember{compress}{simd} \begin{itemdecl} template<@\exposconcept{simd-vec-type}@ V> constexpr V compress(const V& v, const typename V::mask_type& selector, @@ -18843,6 +18917,7 @@ for all $i$ in the range \range{0}{V::size()}. \end{itemdescr} +\indexlibrarymember{expand}{simd} \begin{itemdecl} template<@\exposconcept{simd-vec-type}@ V> constexpr V expand(const V& v, const typename V::mask_type& selector, const V& original = {}); @@ -18875,6 +18950,7 @@ \rSec3[simd.permute.memory]{\tcode{simd} memory permute} +\indexlibrarymember{unchecked_gather_from}{simd} \begin{itemdecl} template requires ranges::@\libconcept{sized_range}@ @@ -18905,6 +18981,7 @@ \tcode{vec, I::\brk{}size()>}. \end{itemdescr} +\indexlibrarymember{partial_gather_from}{simd} \begin{itemdecl} template requires ranges::@\libconcept{sized_range}@ @@ -18971,6 +19048,7 @@ \tcode{vec, I::\brk{}size()>}. \end{itemdescr} +\indexlibrarymember{unchecked_scatter_to}{simd} \begin{itemdecl} template<@\exposconcept{simd-vec-type}@ V, ranges::@\libconcept{contiguous_range}@ R, @\exposconcept{simd-integral}@ I, class... Flags> requires ranges::@\libconcept{sized_range}@ @@ -18997,6 +19075,7 @@ Equivalent to: \tcode{partial_scatter_to(v, out, mask, indices, f);} \end{itemdescr} +\indexlibrarymember{partial_scatter_to}{simd} \begin{itemdecl} template<@\exposconcept{simd-vec-type}@ V, ranges::@\libconcept{contiguous_range}@ R, @\exposconcept{simd-integral}@ I, class... Flags> requires ranges::@\libconcept{sized_range}@ @@ -19052,6 +19131,7 @@ \rSec3[simd.creation]{\tcode{basic_vec} and \tcode{basic_mask} creation} +\indexlibrarymember{chunk}{simd} \begin{itemdecl} template constexpr auto chunk(const basic_vec& x) noexcept; @@ -19105,6 +19185,7 @@ \end{itemize} \end{itemdescr} +\indexlibrarymember{chunk}{simd} \begin{itemdecl} template<@\exposid{simd-size-type}@ N, class T, class Abi> constexpr auto chunk(const basic_vec& x) noexcept; @@ -19116,6 +19197,7 @@ Equivalent to: \tcode{return chunk>>(x);} \end{itemdescr} +\indexlibrarymember{chunk}{simd} \begin{itemdecl} template<@\exposid{simd-size-type}@ N, size_t Bytes, class Abi> constexpr auto chunk(const basic_mask& x) noexcept; @@ -19127,6 +19209,7 @@ Equivalent to: \tcode{return chunk>>(x);} \end{itemdescr} +\indexlibrarymember{cat}{simd} \begin{itemdecl} template constexpr vec::size() + ...)> @@ -19163,6 +19246,7 @@ \rSec3[simd.alg]{Algorithms} +\indexlibrarymember{min}{simd} \begin{itemdecl} template constexpr basic_vec min(const basic_vec& a, @@ -19180,6 +19264,7 @@ all $i$ in the range of \range{0}{basic_vec::size()}. \end{itemdescr} +\indexlibrarymember{max}{simd} \begin{itemdecl} template constexpr basic_vec max(const basic_vec& a, @@ -19197,6 +19282,7 @@ all $i$ in the range of \range{0}{basic_vec::size()}. \end{itemdescr} +\indexlibrarymember{minmax}{simd} \begin{itemdecl} template constexpr pair, basic_vec> @@ -19209,6 +19295,7 @@ Equivalent to: \tcode{return pair\{min(a, b), max(a, b)\};} \end{itemdescr} +\indexlibrarymember{clamp}{simd} \begin{itemdecl} template constexpr basic_vec clamp( @@ -19231,6 +19318,7 @@ hi[$i$])} for all $i$ in the range of \range{0}{basic_vec::size()}. \end{itemdescr} +\indexlibrarymember{select}{simd} \begin{itemdecl} template constexpr auto select(bool c, const T& a, const U& b) @@ -19243,6 +19331,7 @@ Equivalent to: \tcode{return c ? a : b;} \end{itemdescr} +\indexlibrarymember{select}{simd} \begin{itemdecl} template constexpr auto select(const basic_mask& c, const T& a, const U& b) @@ -19262,6 +19351,43 @@ \rSec3[simd.math]{Mathematical functions} +\indexlibrarymember{ilogb}{simd} +\indexlibrarymember{ldexp}{simd} +\indexlibrarymember{scalbn}{simd} +\indexlibrarymember{scalbln}{simd} +\indexlibrarymember{abs}{simd} +\indexlibrarymember{abs}{simd} +\indexlibrarymember{fabs}{simd} +\indexlibrarymember{ceil}{simd} +\indexlibrarymember{floor}{simd} +\indexlibrarymember{nearbyint}{simd} +\indexlibrarymember{rint}{simd} +\indexlibrarymember{lrint}{simd} +\indexlibrarymember{llrint}{simd} +\indexlibrarymember{round}{simd} +\indexlibrarymember{lround}{simd} +\indexlibrarymember{llround}{simd} +\indexlibrarymember{fmod}{simd} +\indexlibrarymember{trunc}{simd} +\indexlibrarymember{remainder}{simd} +\indexlibrarymember{copysign}{simd} +\indexlibrarymember{nextafter}{simd} +\indexlibrarymember{fdim}{simd} +\indexlibrarymember{fmax}{simd} +\indexlibrarymember{fmin}{simd} +\indexlibrarymember{fma}{simd} +\indexlibrarymember{fpclassify}{simd} +\indexlibrarymember{isfinite}{simd} +\indexlibrarymember{isinf}{simd} +\indexlibrarymember{isnan}{simd} +\indexlibrarymember{isnormal}{simd} +\indexlibrarymember{signbit}{simd} +\indexlibrarymember{isgreater}{simd} +\indexlibrarymember{isgreaterequal}{simd} +\indexlibrarymember{isless}{simd} +\indexlibrarymember{islessequal}{simd} +\indexlibrarymember{islessgreater}{simd} +\indexlibrarymember{isunordered}{simd} \begin{itemdecl} template<@\exposconcept{math-floating-point}@ V> constexpr rebind_t> ilogb(const V& x); @@ -19369,6 +19495,58 @@ It is unspecified whether \tcode{errno}\iref{errno} is accessed. \end{itemdescr} +\indexlibrarymember{acos}{simd} +\indexlibrarymember{asin}{simd} +\indexlibrarymember{atan}{simd} +\indexlibrarymember{atan2}{simd} +\indexlibrarymember{cos}{simd} +\indexlibrarymember{sin}{simd} +\indexlibrarymember{tan}{simd} +\indexlibrarymember{acosh}{simd} +\indexlibrarymember{asinh}{simd} +\indexlibrarymember{atanh}{simd} +\indexlibrarymember{cosh}{simd} +\indexlibrarymember{sinh}{simd} +\indexlibrarymember{tanh}{simd} +\indexlibrarymember{exp}{simd} +\indexlibrarymember{exp2}{simd} +\indexlibrarymember{expm1}{simd} +\indexlibrarymember{log}{simd} +\indexlibrarymember{log10}{simd} +\indexlibrarymember{log1p}{simd} +\indexlibrarymember{log2}{simd} +\indexlibrarymember{logb}{simd} +\indexlibrarymember{cbrt}{simd} +\indexlibrarymember{hypot}{simd} +\indexlibrarymember{hypot}{simd} +\indexlibrarymember{pow}{simd} +\indexlibrarymember{sqrt}{simd} +\indexlibrarymember{erf}{simd} +\indexlibrarymember{erfc}{simd} +\indexlibrarymember{lgamma}{simd} +\indexlibrarymember{tgamma}{simd} +\indexlibrarymember{lerp}{simd} +\indexlibrarymember{assoc_laguerre}{simd} +\indexlibrarymember{assoc_legendre}{simd} +\indexlibrarymember{beta}{simd} +\indexlibrarymember{comp_ellint_1}{simd} +\indexlibrarymember{comp_ellint_2}{simd} +\indexlibrarymember{comp_ellint_3}{simd} +\indexlibrarymember{cyl_bessel_i}{simd} +\indexlibrarymember{cyl_bessel_j}{simd} +\indexlibrarymember{cyl_bessel_k}{simd} +\indexlibrarymember{cyl_neumann}{simd} +\indexlibrarymember{ellint_1}{simd} +\indexlibrarymember{ellint_2}{simd} +\indexlibrarymember{ellint_3}{simd} +\indexlibrarymember{expint}{simd} +\indexlibrarymember{hermite}{simd} +\indexlibrarymember{laguerre}{simd} +\indexlibrarymember{legendre}{simd} +\indexlibrarymember{riemann_zeta}{simd} +\indexlibrarymember{sph_bessel}{simd} +\indexlibrarymember{sph_legendre}{simd} +\indexlibrarymember{sph_neumann}{simd} \begin{itemdecl} template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-vec-t}@ acos(const V& x); template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-vec-t}@ asin(const V& x); @@ -19480,6 +19658,7 @@ It is unspecified whether \tcode{errno}\iref{errno} is accessed. \end{itemdescr} +\indexlibrarymember{frexp}{simd} \begin{itemdecl} template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-vec-t}@ frexp(const V& value, rebind_t>* exp); @@ -19512,6 +19691,7 @@ \tcode{ret.first}. \end{itemdescr} +\indexlibrarymember{remquo}{simd} \begin{itemdecl} template constexpr @\exposid{math-common-simd-t}@ remquo(const V0& x, const V1& y, @@ -19553,6 +19733,7 @@ It is unspecified whether \tcode{errno}\iref{errno} is accessed. \end{itemdescr} +\indexlibrarymember{modf}{simd} \begin{itemdecl} template constexpr basic_vec modf(const type_identity_t>& value, @@ -19586,6 +19767,7 @@ \rSec3[simd.bit]{\tcode{basic_vec} bit library} +\indexlibrarymember{byteswap}{simd} \begin{itemdecl} template<@\exposconcept{simd-vec-type}@ V> constexpr V byteswap(const V& v) noexcept; \end{itemdecl} @@ -19602,6 +19784,7 @@ \range{0}{V::size()}. \end{itemdescr} +\indexlibrarymember{bit_ceil}{simd} \begin{itemdecl} template<@\exposconcept{simd-vec-type}@ V> constexpr V bit_ceil(const V& v) noexcept; \end{itemdecl} @@ -19629,6 +19812,7 @@ element is not a core constant expression\iref{expr.const}. \end{itemdescr} +\indexlibrarymember{bit_floor}{simd} \begin{itemdecl} template<@\exposconcept{simd-vec-type}@ V> constexpr V bit_floor(const V& v) noexcept; \end{itemdecl} @@ -19645,6 +19829,7 @@ \range{0}{V::size()}. \end{itemdescr} +\indexlibrarymember{has_single_bit}{simd} \begin{itemdecl} template<@\exposconcept{simd-vec-type}@ V> constexpr typename V::mask_type has_single_bit(const V& v) noexcept; @@ -19662,6 +19847,8 @@ \range{0}{V::size()}. \end{itemdescr} +\indexlibrarymember{rotl}{simd} +\indexlibrarymember{rotr}{simd} \begin{itemdecl} template<@\exposconcept{simd-vec-type}@ V0, @\exposconcept{simd-vec-type}@ V1> constexpr V0 rotl(const V0& v0, const V1& v1) noexcept; @@ -19691,6 +19878,8 @@ where \placeholder{bit-func} is the corresponding scalar function from \libheader{bit}. \end{itemdescr} +\indexlibrarymember{rotl}{simd} +\indexlibrarymember{rotr}{simd} \begin{itemdecl} template<@\exposconcept{simd-vec-type}@ V> constexpr V rotl(const V& v, int s) noexcept; template<@\exposconcept{simd-vec-type}@ V> constexpr V rotr(const V& v, int s) noexcept; @@ -19709,6 +19898,12 @@ scalar function from \libheader{bit}. \end{itemdescr} +\indexlibrarymember{bit_width}{simd} +\indexlibrarymember{countl_zero}{simd} +\indexlibrarymember{countl_one}{simd} +\indexlibrarymember{countr_zero}{simd} +\indexlibrarymember{countr_one}{simd} +\indexlibrarymember{popcount}{simd} \begin{itemdecl} template<@\exposconcept{simd-vec-type}@ V> constexpr rebind_t, V> bit_width(const V& v) noexcept; @@ -19739,6 +19934,29 @@ \rSec3[simd.complex.math]{\tcode{vec} complex math} +\indexlibrarymember{real}{simd} +\indexlibrarymember{imag}{simd} +\indexlibrarymember{abs}{simd} +\indexlibrarymember{arg}{simd} +\indexlibrarymember{norm}{simd} +\indexlibrarymember{conj}{simd} +\indexlibrarymember{proj}{simd} +\indexlibrarymember{exp}{simd} +\indexlibrarymember{log}{simd} +\indexlibrarymember{log10}{simd} +\indexlibrarymember{sqrt}{simd} +\indexlibrarymember{sin}{simd} +\indexlibrarymember{asin}{simd} +\indexlibrarymember{cos}{simd} +\indexlibrarymember{acos}{simd} +\indexlibrarymember{tan}{simd} +\indexlibrarymember{atan}{simd} +\indexlibrarymember{sinh}{simd} +\indexlibrarymember{asinh}{simd} +\indexlibrarymember{cosh}{simd} +\indexlibrarymember{acosh}{simd} +\indexlibrarymember{tanh}{simd} +\indexlibrarymember{atanh}{simd} \begin{itemdecl} template<@\exposconcept{simd-complex}@ V> constexpr rebind_t<@\exposid{simd-complex-value-type}@, V> real(const V&) noexcept; @@ -19788,6 +20006,8 @@ It is unspecified whether \tcode{errno}\iref{errno} is accessed. \end{itemdescr} +\indexlibrarymember{polar}{simd} +\indexlibrarymember{pow}{simd} \begin{itemdecl} template<@\exposconcept{simd-floating-point}@ V> rebind_t, V> polar(const V& x, const V& y = {}); @@ -19818,8 +20038,8 @@ namespace std::simd { template class basic_mask { public: - using value_type = bool; - using abi_type = Abi; + using @\libmember{value_type}{basic_mask} = bool; + using @\libmember{abi_type}{basic_mask} = Abi; using @\libmember{iterator}{basic_mask}@ = @\exposid{simd-iterator}@; using @\libmember{const_iterator}{basic_mask}@ = @\exposid{simd-iterator}@; @@ -19830,7 +20050,7 @@ constexpr default_sentinel_t @\libmember{cend}{basic_mask}@() const noexcept { return {}; } static constexpr integral_constant<@\exposid{simd-size-type}@, @\exposid{simd-size-v}@<@\exposid{integer-from}@, Abi>> - size {}; + @\libmember{size}{basic_mask}@ {}; constexpr basic_mask() noexcept = default; @@ -19945,6 +20165,7 @@ \rSec3[simd.mask.ctor]{\tcode{basic_mask} constructors} +\indexlibraryctor{basic_mask} \begin{itemdecl} constexpr explicit basic_mask(value_type x) noexcept; \end{itemdecl} @@ -19955,6 +20176,7 @@ Initializes each element with \tcode{x}. \end{itemdescr} +\indexlibraryctor{basic_mask} \begin{itemdecl} template constexpr explicit basic_mask(const basic_mask& x) noexcept; @@ -19972,6 +20194,7 @@ range of \range{0}{size()}. \end{itemdescr} +\indexlibraryctor{basic_mask} \begin{itemdecl} template constexpr explicit basic_mask(G&& gen); \end{itemdecl} @@ -19994,6 +20217,7 @@ \tcode{gen} is invoked exactly once for each $i$, in increasing order of $i$. \end{itemdescr} +\indexlibraryctor{basic_mask} \begin{itemdecl} constexpr basic_mask(const bitset& b) noexcept; \end{itemdecl} @@ -20005,6 +20229,7 @@ range \range{0}{size()}. \end{itemdescr} +\indexlibraryctor{basic_mask} \begin{itemdecl} constexpr explicit basic_mask(@\libconcept{unsigned_integral}@ auto val) noexcept; \end{itemdecl} @@ -20021,6 +20246,7 @@ \rSec3[simd.mask.subscr]{\tcode{basic_mask} subscript operator} +\indexlibrarymember{operator[]}{basic_mask} \begin{itemdecl} constexpr value_type operator[](@\exposid{simd-size-type}@ i) const; \end{itemdecl} @@ -20039,6 +20265,7 @@ Nothing. \end{itemdescr} +\indexlibrarymember{operator[]}{basic_mask} \begin{itemdecl} template<@\exposconcept{simd-integral}@ I> constexpr resize_t operator[](const I& indices) const; @@ -20052,6 +20279,10 @@ \rSec3[simd.mask.unary]{\tcode{basic_mask} unary operators} +\indexlibrarymember{operator!}{basic_mask} +\indexlibrarymember{operator+}{basic_mask} +\indexlibrarymember{operator-}{basic_mask} +\indexlibrarymember{operator~}{basic_mask} \begin{itemdecl} constexpr basic_mask operator!() const noexcept; constexpr basic_vec<@\exposid{integer-from}@, Abi> operator+() const noexcept; @@ -20072,6 +20303,7 @@ \rSec3[simd.mask.conv]{\tcode{basic_mask} conversion operators} +\indexlibrarymember{operator basic_vec}{basic_mask} \begin{itemdecl} template constexpr explicit(sizeof(U) != Bytes) operator basic_vec() const noexcept; @@ -20090,6 +20322,7 @@ \rSec3[simd.mask.namedconv]{\tcode{basic_mask} named conversion operators} +\indexlibrarymember{to_bitset}{basic_mask} \begin{itemdecl} constexpr bitset to_bitset() const noexcept; \end{itemdecl} @@ -20101,6 +20334,7 @@ \tcode{operator[]($i$)} for all $i$ in the range \range{0}{size()}. \end{itemdescr} +\indexlibrarymember{to_ullong}{basic_mask} \begin{itemdecl} constexpr unsigned long long to_ullong() const; \end{itemdecl} @@ -20129,6 +20363,11 @@ \rSec3[simd.mask.binary]{\tcode{basic_mask} binary operators} +\indexlibrarymember{operator\&\&}{basic_mask} +\indexlibrarymember{operator||}{basic_mask} +\indexlibrarymember{operator\&}{basic_mask} +\indexlibrarymember{operator|}{basic_mask} +\indexlibrarymember{operator\caret}{basic_mask} \begin{itemdecl} friend constexpr basic_mask operator&&(const basic_mask& lhs, const basic_mask& rhs) noexcept; @@ -20155,6 +20394,9 @@ \rSec3[simd.mask.cassign]{\tcode{basic_mask} compound assignment} +\indexlibrarymember{operator\&=}{basic_mask} +\indexlibrarymember{operator|=}{basic_mask} +\indexlibrarymember{operator\caret=}{basic_mask} \begin{itemdecl} friend constexpr basic_mask& operator&=(basic_mask& lhs, const basic_mask& rhs) noexcept; @@ -20180,6 +20422,12 @@ \rSec3[simd.mask.comparison]{\tcode{basic_mask} comparisons} +\indexlibrarymember{operator==}{basic_mask} +\indexlibrarymember{operator!=}{basic_mask} +\indexlibrarymember{operator>=}{basic_mask} +\indexlibrarymember{operator<=}{basic_mask} +\indexlibrarymember{operator<}{basic_mask} +\indexlibrarymember{operator>}{basic_mask} \begin{itemdecl} friend constexpr basic_mask operator==(const basic_mask&, const basic_mask&) noexcept; @@ -20259,6 +20507,7 @@ \rSec3[simd.mask.reductions]{\tcode{basic_mask} reductions} +\indexlibrarymember{all_of}{simd} \begin{itemdecl} template constexpr bool all_of(const basic_mask& k) noexcept; @@ -20271,6 +20520,7 @@ \tcode{false}. \end{itemdescr} +\indexlibrarymember{any_of}{simd} \begin{itemdecl} template constexpr bool any_of(const basic_mask& k) noexcept; @@ -20283,6 +20533,7 @@ otherwise \tcode{false}. \end{itemdescr} +\indexlibrarymember{none_of}{simd} \begin{itemdecl} template constexpr bool none_of(const basic_mask& k) noexcept; @@ -20294,6 +20545,7 @@ \tcode{!any_of(k)}. \end{itemdescr} +\indexlibrarymember{reduce_count}{simd} \begin{itemdecl} template constexpr @\exposid{simd-size-type}@ reduce_count(const basic_mask& k) noexcept; @@ -20305,6 +20557,7 @@ The number of boolean elements in \tcode{k} that are \tcode{true}. \end{itemdescr} +\indexlibrarymember{reduce_min_index}{simd} \begin{itemdecl} template constexpr @\exposid{simd-size-type}@ reduce_min_index(const basic_mask& k); @@ -20320,6 +20573,7 @@ The lowest element index $i$ where \tcode{k[$i$]} is \tcode{true}. \end{itemdescr} +\indexlibrarymember{reduce_max_index}{simd} \begin{itemdecl} template constexpr @\exposid{simd-size-type}@ reduce_max_index(const basic_mask& k); @@ -20335,6 +20589,9 @@ The greatest element index $i$ where \tcode{k[$i$]} is \tcode{true}. \end{itemdescr} +\indexlibrarymember{all_of}{simd} +\indexlibrarymember{any_of}{simd} +\indexlibrarymember{reduce_count}{simd} \begin{itemdecl} constexpr bool all_of(@\libconcept{same_as}@ auto x) noexcept; constexpr bool any_of(@\libconcept{same_as}@ auto x) noexcept; @@ -20347,6 +20604,7 @@ \tcode{x}. \end{itemdescr} +\indexlibrarymember{none_of}{simd} \begin{itemdecl} constexpr bool none_of(@\libconcept{same_as}@ auto x) noexcept; \end{itemdecl} @@ -20357,6 +20615,8 @@ \tcode{!x}. \end{itemdescr} +\indexlibrarymember{reduce_min_index}{simd} +\indexlibrarymember{reduce_max_index}{simd} \begin{itemdecl} constexpr @\exposid{simd-size-type}@ reduce_min_index(@\libconcept{same_as}@ auto x); constexpr @\exposid{simd-size-type}@ reduce_max_index(@\libconcept{same_as}@ auto x);