29 Numerics library [numerics]

29.10 Data-parallel types [simd]

29.10.8 basic_vec non-member operations [simd.nonmembers]

29.10.8.14 Bit manipulation [simd.bit]

template<simd-vec-type V> constexpr V byteswap(const V& v) noexcept;

Constraints: The type V::value_type models integral .

Returns: A basic_vec object where the

i^{th}

element is initialized to the result of std::byteswap(v[i]) for all i in the range [0, V::size()).

🔗

template<simd-integral V> constexpr V bit_reverse(const V& v) noexcept;

Constraints: The type V::value_type is an unsigned integer type ([basic.fundamental]).

Returns: A basic_vec object where the

i^{th}

element is initialized to the result of std::bit_reverse(v[i]) for all i in the range [0, V::size()).

🔗

template<simd-vec-type V> constexpr V bit_ceil(const V& v);

Constraints: The type V::value_type is an unsigned integer type ([basic.fundamental]).

Preconditions: For every i in the range [0, V::size()), the smallest power of 2 greater than or equal to v[i] is representable as a value of type V::value_type.

Returns: A basic_vec object where the

i^{th}

element is initialized to the result of std::bit_ceil(v[i]) for all i in the range [0, V::size()).

Remarks: A function call expression that violates the precondition in the Preconditions: element is not a core constant expression ([expr.const.core]).

🔗

template<simd-vec-type V> constexpr V bit_floor(const V& v) noexcept;

Constraints: The type V::value_type is an unsigned integer type ([basic.fundamental]).

Returns: A basic_vec object where the

i^{th}

element is initialized to the result of std::bit_floor(v[i]) for all i in the range [0, V::size()).

🔗

template<simd-vec-type V>
  constexpr typename V::mask_type has_single_bit(const V& v) noexcept;

Constraints: The type V::value_type is an unsigned integer type ([basic.fundamental]).

Returns: A basic_mask object where the

i^{th}

element is initialized to the result of std::has_single_bit(v[i]) for all i in the range [0, V::size()).

🔗

template<simd-integral VX, simd-integral VS>
  constexpr VX shl(const VX& x, const VS& s) noexcept;
template<simd-integral VX, simd-integral VS>
  constexpr VX shr(const VX& x, const VS& s) noexcept;

Constraints:

(13.1)
Each of VX::value_type and VS::value_type is a signed or unsigned integer type ([basic.fundamental]),
(13.2)
VX::size() == VS::size() is true, and
(13.3)
sizeof(typename VX::value_type) == sizeof(typename VS::value_type) is true.

Returns: A basic_vec object where the

i^{th}

element is initialized to the result of bit-func(x[i], s[i]) for all i in the range [0, VX::size()), where bit-func is the corresponding scalar function from <bit>.

🔗

template<simd-integral V, class S>
  constexpr V shl(const V& x, S s) noexcept;
template<simd-integral V, class S>
  constexpr V shr(const V& x, S s) noexcept;

Constraints: Each of VX::value_type and S is a signed or unsigned integer type ([basic.fundamental]).

Returns: A basic_vec object where the

i^{th}

element is initialized to the result of bit-func(x[i], s) for all i in the range [0, VX::size()), where bit-func is the corresponding scalar function from <bit>.

🔗

template<simd-vec-type V0, simd-vec-type V1>
  constexpr V0 rotl(const V0& v0, const V1& v1) noexcept;
template<simd-vec-type V0, simd-vec-type V1>
  constexpr V0 rotr(const V0& v0, const V1& v1) noexcept;
template<simd-integral V0, simd-integral V1>
  constexpr V0 bit_repeat(const V0& v0, const V1& v1);

Constraints:

(17.1)
The type V0::value_type is an unsigned integer type ([basic.fundamental]),
(17.2)
the type V1::value_type models integral,
(17.3)
V0::size() == V1::size() is true, and
(17.4)
sizeof(typename V0::value_type) == sizeof(typename V1::value_type) is true.

Preconditions: For bit_repeat, v1[i] > 0 is true for all i in the range [0, V0::size()).

Returns: A basic_vec object where the

i^{th}

element is initialized to the result of bit-func(v0[i], static_cast<int>(v1[i])) for all i in the range [0, V0::size()), where bit-func is the corresponding scalar function from <bit>.

Remarks: A function call expression that violates the precondition in the Preconditions: element is not a core constant expression ([expr.const.core]).

🔗

template<simd-vec-type V> constexpr V rotl(const V& v, int s) noexcept;
template<simd-vec-type V> constexpr V rotr(const V& v, int s) noexcept;
template<simd-integral V> constexpr V bit_repeat(const V& v, int l);

Constraints: The type V::value_type is an unsigned integer type ([basic.fundamental]).

Preconditions: For bit_repeat, l > 0 is true.

Returns: A basic_vec object where the

i^{th}

element is initialized to the result of bit-func(v[i], s) for all i in the range [0, V::size()), where bit-func is the corresponding scalar function from <bit>.

Remarks: A function call expression that violates the precondition in the Preconditions: element is not a core constant expression ([expr.const.core]).

🔗

template<simd-vec-type V>
  constexpr rebind_t<make_signed_t<typename V::value_type>, V> bit_width(const V& v) noexcept;
template<simd-vec-type V>
  constexpr rebind_t<make_signed_t<typename V::value_type>, V> countl_zero(const V& v) noexcept;
template<simd-vec-type V>
  constexpr rebind_t<make_signed_t<typename V::value_type>, V> countl_one(const V& v) noexcept;
template<simd-vec-type V>
  constexpr rebind_t<make_signed_t<typename V::value_type>, V> countr_zero(const V& v) noexcept;
template<simd-vec-type V>
  constexpr rebind_t<make_signed_t<typename V::value_type>, V> countr_one(const V& v) noexcept;
template<simd-vec-type V>
  constexpr rebind_t<make_signed_t<typename V::value_type>, V> popcount(const V& v) noexcept;

Constraints: The type V::value_type is an unsigned integer type ([basic.fundamental]).

Returns: A basic_vec object where the

i^{th}

element is initialized to the result of bit-func(v[i]) for all i in the range [0, V::size()), where bit-func is the corresponding scalar function from <bit>.

🔗

template<simd-integral V>
  constexpr V bit_compress(const V& v, const V& m) noexcept;
template<simd-integral V>
  constexpr V bit_expand(const V& v, const V& m) noexcept;

Constraints: The type V::value_type is an unsigned integer type ([basic.fundamental]).

Returns: A basic_vec object where the

i^{th}

element is initialized to the result of bit-func(v[i], m[i]) for all i in the range [0, V::size()), where bit-func is the corresponding scalar function from <bit>.

🔗

template<simd-integral V>
  constexpr V bit_compress(const V& v, typename V::value_type m) noexcept;
template<simd-integral V>
  constexpr V bit_expand(const V& v, typename V::value_type m) noexcept;

Constraints: The type V::value_type is an unsigned integer type ([basic.fundamental]).

Returns: A basic_vec object where the

i^{th}

element is initialized to the result of bit-func(v[i], m) for all i in the range [0, V::size()), where bit-func is the corresponding scalar function from <bit>.