native 0.0.1
Vectors, masks and wide register packs for C++26
Loading...
Searching...
No Matches
native::simd< T, N, Arch > Struct Template Reference
Vectors and ISA values

#include <simd_family.h>

Inheritance diagram for native::simd< T, N, Arch >:
[legend]
Collaboration diagram for native::simd< T, N, Arch >:
[legend]

Public Member Functions

constexpr simd ()=default
 Default-construct the element customization; its initialization contract is retained.
template<std::size_t A = 1>
constexpr void store_memory (T *p) const noexcept
 Store logical lanes, assuming the template alignment in bytes.
constexpr simd () noexcept=default
 Initialize the stored lane values to zero.
template<simd_integer_element U>
constexpr simd (U input) noexcept
 Broadcast the integral input, retaining its low sizeof(T)*8 bits in each lane.
constexpr simd (native_type x) noexcept
 Adopt native lane storage under its minimal register ABI.
constexpr simd (native_type x) noexcept
 Adopt native lane storage under its minimal register ABI.
constexpr simd (native_type x) noexcept
 Adopt native lane storage under its minimal register ABI.
template<class... U>
requires (sizeof...(U) == N && (simd_integer_element<U> && ...))
constexpr simd (U... xs) noexcept
 Construct logical lanes in argument order. Integral conversion retains the low lane-width bits.
constexpr simd (std::array< T, N > const &data) noexcept
 Copy one value per logical lane in array order.
constexpr operator native_type () const noexcept
 Return the native storage value under its minimal register ABI.
constexpr native_type to_native () const noexcept
 Return the native storage representation under its minimal register ABI.
constexpr operator native_type () const noexcept
 Return the native storage value under its minimal register ABI.
constexpr native_type to_native () const noexcept
 Return the native storage representation under its minimal register ABI.
constexpr operator native_type () const noexcept
 Return the native storage value under its minimal register ABI.
constexpr native_type to_native () const noexcept
 Return the native storage representation under its minimal register ABI.
constexpr simd & operator+= (simd b) noexcept
 Apply the corresponding lane-wise add operation in place and return *this.
template<simd_integer_element U>
constexpr simd & operator+= (U b) noexcept
 Apply the corresponding lane-wise add operation in place and return *this. Scalar operands are reduced to the lane width and broadcast first.
constexpr simd & operator-= (simd b) noexcept
 Apply the corresponding lane-wise subtract operation in place and return *this.
template<simd_integer_element U>
constexpr simd & operator-= (U b) noexcept
 Apply the corresponding lane-wise subtract operation in place and return *this. Scalar operands are reduced to the lane width and broadcast first.
constexpr simd & operator*= (simd b) noexcept
 Apply the corresponding lane-wise multiply operation in place and return *this.
template<simd_integer_element U>
constexpr simd & operator*= (U b) noexcept
 Apply the corresponding lane-wise multiply operation in place and return *this. Scalar operands are reduced to the lane width and broadcast first.
constexpr simd & operator&= (simd b) noexcept
 Apply the corresponding lane-wise AND operation in place and return *this.
template<simd_integer_element U>
constexpr simd & operator&= (U b) noexcept
 Apply the corresponding lane-wise AND operation in place and return *this. Scalar operands are reduced to the lane width and broadcast first.
constexpr simd & operator|= (simd b) noexcept
 Apply the corresponding lane-wise OR operation in place and return *this.
template<simd_integer_element U>
constexpr simd & operator|= (U b) noexcept
 Apply the corresponding lane-wise OR operation in place and return *this. Scalar operands are reduced to the lane width and broadcast first.
constexpr simd & operator^= (simd b) noexcept
 Apply the corresponding lane-wise XOR operation in place and return *this.
template<simd_integer_element U>
constexpr simd & operator^= (U b) noexcept
 Apply the corresponding lane-wise XOR operation in place and return *this. Scalar operands are reduced to the lane width and broadcast first.
template<unsigned K>
requires (K < sizeof(T) * 8)
constexpr simd left () const noexcept
 Shift each lane left by compile-time K, discarding high bits; require K below the lane bit width.
template<unsigned K>
requires (K < sizeof(T) * 8)
constexpr simd right () const noexcept
 Shift each lane right by compile-time K; signed lanes extend their sign. Require K below the lane bit width.
constexpr void store (T *p) const noexcept
 Write all logical lanes to an unaligned element pointer.
constexpr void storeu (T *p) const noexcept
 Write all logical lanes without an extra alignment promise.
constexpr void store_partial (T *p, std::size_t n) const noexcept
 Write exactly n logical lanes; require n <= lanes. For n == 0, p may be null.
constexpr simd ()=default
 Default initialization leaves storage unspecified; value initialization with braces zero-initializes it.
constexpr simd (simd const &)=default
 Copy the stored value without arithmetic or normalization.
constexpr simd & operator= (simd const &)=default
 Copy the stored value and return *this; no numerical conversion is performed.
constexpr simd (T x) noexcept
 Broadcast the supplied value to each logical lane. Unused physical lanes are zero.
constexpr simd (bool x) noexcept
 Broadcast the supplied value to each logical lane. Unused physical lanes are zero.
constexpr simd (native_type x) noexcept
 Adopt native lane storage and clear physical padding. Mask elements must already be canonical.
template<class... X>
requires (sizeof...(X)==N) && (std::convertible_to<X,T> && ...)
constexpr simd (X... x) noexcept((noexcept(static_cast< T >(x)) &&...))
 Construct logical lanes in argument order. Any element conversions determine the exception specification.
constexpr simd (std::array< T, N > const &values) noexcept
 Copy one value per logical lane in array order.
constexpr native_type to_native () const noexcept
 Return the native storage representation, including physical padding when present.
constexpr operator native_type () const noexcept
 Return the native storage value without a numerical conversion.
constexpr storage_type to_storage () const noexcept
 Return the corresponding four-lane storage vector without changing logical lane bits.
template<std::size_t Alignment = 1>
constexpr void store_memory (T *p) const noexcept
 Store exactly the logical lanes; the template alignment is a caller promise, never permission to write padding.
constexpr void store (T *p) const noexcept
 Store exactly the logical lanes; no extra pointer alignment is required.
constexpr void storeu (T *p) const noexcept
 Store exactly the logical lanes without an additional alignment requirement.
constexpr void store_partial (T *p, std::size_t n) const noexcept
 Write exactly n logical lanes; require n <= lanes. For n == 0, p may be null.
constexpr bits_type bits () const noexcept
 Return the exact binary32 lane representations in the unsigned vector.
constexpr bits_type to_bits () const noexcept
 Return the exact binary32 lane representations in the unsigned vector.
constexpr void store_bits (std::uint32_t *p) const noexcept
 Store the exact binary32 words for every logical lane.
constexpr void store_bits_partial (std::uint32_t *p, std::size_t n) const noexcept
 Write n exact representation words; require n <= lanes. A zero count permits null.
constexpr std::uint64_t to_bitset () const noexcept
 Pack each logical lane truth value into bit i; higher bits are zero.
template<unsigned K>
requires (K<32) && simd_integer_element<T>
constexpr simd left () const noexcept
 Shift each lane left by compile-time K, discarding high bits; require K below the lane bit width.
template<unsigned K>
requires (K<32) && simd_integer_element<T>
constexpr simd right () const noexcept
 Shift each lane right by compile-time K; signed lanes extend their sign. Require K below the lane bit width.
constexpr simd & operator+= (simd b) noexcept
 Apply the corresponding lane-wise add operation in place and return *this.
constexpr simd & operator-= (simd b) noexcept
 Apply the corresponding lane-wise subtract operation in place and return *this.
constexpr simd & operator*= (simd b) noexcept
 Apply the corresponding lane-wise multiply operation in place and return *this.
constexpr simd & operator/= (simd b) noexcept
 Apply the corresponding lane-wise divide operation in place and return *this.
constexpr simd & operator&= (simd b) noexcept
 Apply the corresponding lane-wise AND operation in place and return *this.
constexpr simd & operator|= (simd b) noexcept
 Apply the corresponding lane-wise OR operation in place and return *this.
constexpr simd & operator^= (simd b) noexcept
 Apply the corresponding lane-wise XOR operation in place and return *this.

Static Public Member Functions

template<std::size_t A = 1>
static constexpr simd load_memory (T const *p) noexcept
 Load logical lanes, assuming the template alignment in bytes.
static constexpr simd from_native (native_type x) noexcept
 Adopt native storage without numerical conversion.
static constexpr simd from_native (native_type x) noexcept
 Adopt native storage without numerical conversion.
static constexpr simd from_native (native_type x) noexcept
 Adopt native storage without numerical conversion.
static constexpr simd load (T const *p) noexcept
 Read all logical lanes from an unaligned element pointer.
static constexpr simd loadu (T const *p) noexcept
 Read all logical lanes without an extra alignment promise.
static constexpr simd load_partial (T const *p, std::size_t n, T fill=T(0)) noexcept
 Read exactly n logical lanes and fill the remainder; require n <= lanes. For n == 0, p may be null.
static constexpr simd from_native (native_type x) noexcept
 Import native lanes, normalizing mask elements; other elements retain their bits. Clear physical padding.
static constexpr simd unsafe_from_native (native_type x) noexcept
 Adopt native bits and clear physical padding. If T is a mask element, every logical lane must already be canonical.
static constexpr simd from_storage (storage_type x) noexcept
 Copy the first N lanes from a four-lane storage value and clear physical padding.
template<std::size_t Alignment = 1>
static constexpr simd load_memory (T const *p) noexcept
 Load exactly the logical lanes; the template alignment is a caller promise, never permission to read padding.
static constexpr simd load (T const *p) noexcept
 Load exactly the logical lanes; no extra pointer alignment is required.
static constexpr simd loadu (T const *p) noexcept
 Load exactly the logical lanes without an additional alignment requirement.
static constexpr simd load_partial (T const *p, std::size_t n, T fill={}) noexcept
 Read exactly n logical lanes and fill the remainder; require n <= lanes. For n == 0, p may be null.
static constexpr simd from_bits (bits_type x) noexcept
 Reinterpret binary32 words as lane values without normalization; a scalar word is broadcast.
static constexpr simd from_bits (std::uint32_t x) noexcept
 Reinterpret binary32 words as lane values without normalization; a scalar word is broadcast.
static constexpr simd from_float (float x) noexcept
 Broadcast the float value without adding an FTZ or other normalization policy.
static constexpr simd unsafe_from_float32 (native_type x) noexcept
 Adopt raw float storage without numerical conversion or normalization.
static constexpr simd load_bits (std::uint32_t const *p) noexcept
 Load exactly the logical count of binary32 words without normalizing their representations.
static constexpr simd load_bits_partial (std::uint32_t const *p, std::size_t n, std::uint32_t fill=0) noexcept
 Read n representation words and fill the remaining logical lanes; require n <= lanes. A zero count permits null.
static constexpr simd from_bitset (std::uint64_t bits) noexcept
 Import lane i from bit i, clearing bits above the logical lane count.

Friends

constexpr simd operator+ (simd a, simd b) noexcept
 Add corresponding lanes modulo 2^(sizeof(T)*8).
constexpr simd operator- (simd a, simd b) noexcept
 Subtract corresponding lanes modulo 2^(sizeof(T)*8).
constexpr simd operator* (simd a, simd b) noexcept
 Multiply corresponding lanes modulo 2^(sizeof(T)*8).
constexpr simd operator& (simd a, simd b) noexcept
 Bitwise AND of corresponding lane representations.
constexpr simd operator| (simd a, simd b) noexcept
 Bitwise OR of corresponding lane representations.
constexpr simd operator^ (simd a, simd b) noexcept
 Bitwise XOR of corresponding lane representations.
constexpr simd operator~ (simd a) noexcept
 Complement every bit in every lane.
constexpr simd operator- (simd a) noexcept
 Negate each lane modulo 2^(sizeof(T)*8).
constexpr simd operator+ (simd a) noexcept
 Return the unchanged vector value.
constexpr mask_type operator== (simd a, simd b) noexcept
 Return a mask whose lanes are true where a == b holds. Ordering follows the signedness of T.
constexpr mask_type operator> (simd a, simd b) noexcept
 Return a mask whose lanes are true where a > b holds. Ordering follows the signedness of T.
constexpr mask_type operator!= (simd a, simd b) noexcept
 Return a mask whose lanes are true where a != b holds. Ordering follows the signedness of T.
constexpr mask_type operator< (simd a, simd b) noexcept
 Return a mask whose lanes are true where a < b holds. Ordering follows the signedness of T.
constexpr mask_type operator<= (simd a, simd b) noexcept
 Return a mask whose lanes are true where a <= b holds. Ordering follows the signedness of T.
constexpr mask_type operator>= (simd a, simd b) noexcept
 Return a mask whose lanes are true where a >= b holds. Ordering follows the signedness of T.
template<simd_integer_element U>
constexpr simd operator+ (simd a, U b) noexcept
 Add corresponding lanes modulo 2^(sizeof(T)*8). Scalar operands are reduced to the lane width and broadcast first.
template<simd_integer_element U>
constexpr simd operator+ (U a, simd b) noexcept
 Add corresponding lanes modulo 2^(sizeof(T)*8). Scalar operands are reduced to the lane width and broadcast first.
template<simd_integer_element U>
constexpr simd operator- (simd a, U b) noexcept
 Subtract corresponding lanes modulo 2^(sizeof(T)*8). Scalar operands are reduced to the lane width and broadcast first.
template<simd_integer_element U>
constexpr simd operator- (U a, simd b) noexcept
 Subtract corresponding lanes modulo 2^(sizeof(T)*8). Scalar operands are reduced to the lane width and broadcast first.
template<simd_integer_element U>
constexpr simd operator* (simd a, U b) noexcept
 Multiply corresponding lanes modulo 2^(sizeof(T)*8). Scalar operands are reduced to the lane width and broadcast first.
template<simd_integer_element U>
constexpr simd operator* (U a, simd b) noexcept
 Multiply corresponding lanes modulo 2^(sizeof(T)*8). Scalar operands are reduced to the lane width and broadcast first.
template<simd_integer_element U>
constexpr simd operator& (simd a, U b) noexcept
 Bitwise AND of corresponding lane representations. Scalar operands are reduced to the lane width and broadcast first.
template<simd_integer_element U>
constexpr simd operator& (U a, simd b) noexcept
 Bitwise AND of corresponding lane representations. Scalar operands are reduced to the lane width and broadcast first.
template<simd_integer_element U>
constexpr simd operator| (simd a, U b) noexcept
 Bitwise OR of corresponding lane representations. Scalar operands are reduced to the lane width and broadcast first.
template<simd_integer_element U>
constexpr simd operator| (U a, simd b) noexcept
 Bitwise OR of corresponding lane representations. Scalar operands are reduced to the lane width and broadcast first.
template<simd_integer_element U>
constexpr simd operator^ (simd a, U b) noexcept
 Bitwise XOR of corresponding lane representations. Scalar operands are reduced to the lane width and broadcast first.
template<simd_integer_element U>
constexpr simd operator^ (U a, simd b) noexcept
 Bitwise XOR of corresponding lane representations. Scalar operands are reduced to the lane width and broadcast first.
template<simd_integer_element U>
constexpr mask_type operator== (simd a, U b) noexcept
 Return a mask whose lanes are true where a == b holds. Ordering follows the signedness of T. Scalar operands are reduced to the lane width and broadcast first.
template<simd_integer_element U>
constexpr mask_type operator== (U a, simd b) noexcept
 Return a mask whose lanes are true where a == b holds. Ordering follows the signedness of T. Scalar operands are reduced to the lane width and broadcast first.
template<simd_integer_element U>
constexpr mask_type operator!= (simd a, U b) noexcept
 Return a mask whose lanes are true where a != b holds. Ordering follows the signedness of T. Scalar operands are reduced to the lane width and broadcast first.
template<simd_integer_element U>
constexpr mask_type operator!= (U a, simd b) noexcept
 Return a mask whose lanes are true where a != b holds. Ordering follows the signedness of T. Scalar operands are reduced to the lane width and broadcast first.
template<simd_integer_element U>
constexpr mask_type operator< (simd a, U b) noexcept
 Return a mask whose lanes are true where a < b holds. Ordering follows the signedness of T. Scalar operands are reduced to the lane width and broadcast first.
template<simd_integer_element U>
constexpr mask_type operator< (U a, simd b) noexcept
 Return a mask whose lanes are true where a < b holds. Ordering follows the signedness of T. Scalar operands are reduced to the lane width and broadcast first.
template<simd_integer_element U>
constexpr mask_type operator> (simd a, U b) noexcept
 Return a mask whose lanes are true where a > b holds. Ordering follows the signedness of T. Scalar operands are reduced to the lane width and broadcast first.
template<simd_integer_element U>
constexpr mask_type operator> (U a, simd b) noexcept
 Return a mask whose lanes are true where a > b holds. Ordering follows the signedness of T. Scalar operands are reduced to the lane width and broadcast first.
template<simd_integer_element U>
constexpr mask_type operator<= (simd a, U b) noexcept
 Return a mask whose lanes are true where a <= b holds. Ordering follows the signedness of T. Scalar operands are reduced to the lane width and broadcast first.
template<simd_integer_element U>
constexpr mask_type operator<= (U a, simd b) noexcept
 Return a mask whose lanes are true where a <= b holds. Ordering follows the signedness of T. Scalar operands are reduced to the lane width and broadcast first.
template<simd_integer_element U>
constexpr mask_type operator>= (simd a, U b) noexcept
 Return a mask whose lanes are true where a >= b holds. Ordering follows the signedness of T. Scalar operands are reduced to the lane width and broadcast first.
template<simd_integer_element U>
constexpr mask_type operator>= (U a, simd b) noexcept
 Return a mask whose lanes are true where a >= b holds. Ordering follows the signedness of T. Scalar operands are reduced to the lane width and broadcast first.
template<std::size_t K>
requires (K < sizeof(T) * 8)
constexpr simd operator<< (simd a, imm_t< K >)
 Shift every lane left by K bits, discarding high bits. Require K smaller than the lane bit width.
constexpr simd operator<< (simd a, simd counts) noexcept
 Shift each unsigned 32-bit lane by its corresponding count, which must be less than 32.
template<std::size_t K>
requires (K < sizeof(T) * 8)
constexpr simd operator>> (simd a, imm_t< K >)
 Shift every lane right by K; signed lanes extend the sign, unsigned lanes shift in zero. Require K smaller than the lane bit width.
template<class U>
requires (std::is_arithmetic_v<U> && !simd_integer_element<U>)
void operator+ (simd, U)=delete
 Reject this unsupported operand combination instead of converting implicitly to a native register.
template<class U>
requires (std::is_arithmetic_v<U> && !simd_integer_element<U>)
void operator+ (U, simd)=delete
 Reject this unsupported operand combination instead of converting implicitly to a native register.
template<simd_integer_element U, std::size_t M>
requires (!std::same_as<simd, ::native::simd<U, M,Arch>>)
void operator+ (simd, ::native::simd< U, M, Arch >)=delete
 Reject this unsupported operand combination instead of converting implicitly to a native register.
template<class U>
requires (std::is_arithmetic_v<U> && !simd_integer_element<U>)
void operator- (simd, U)=delete
 Reject this unsupported operand combination instead of converting implicitly to a native register.
template<class U>
requires (std::is_arithmetic_v<U> && !simd_integer_element<U>)
void operator- (U, simd)=delete
 Reject this unsupported operand combination instead of converting implicitly to a native register.
template<simd_integer_element U, std::size_t M>
requires (!std::same_as<simd, ::native::simd<U, M,Arch>>)
void operator- (simd, ::native::simd< U, M, Arch >)=delete
 Reject this unsupported operand combination instead of converting implicitly to a native register.
template<class U>
requires (std::is_arithmetic_v<U> && !simd_integer_element<U>)
void operator* (simd, U)=delete
 Reject this unsupported operand combination instead of converting implicitly to a native register.
template<class U>
requires (std::is_arithmetic_v<U> && !simd_integer_element<U>)
void operator* (U, simd)=delete
 Reject this unsupported operand combination instead of converting implicitly to a native register.
template<simd_integer_element U, std::size_t M>
requires (!std::same_as<simd, ::native::simd<U, M,Arch>>)
void operator* (simd, ::native::simd< U, M, Arch >)=delete
 Reject this unsupported operand combination instead of converting implicitly to a native register.
template<class U>
requires (std::is_arithmetic_v<U> && !simd_integer_element<U>)
void operator/ (simd, U)=delete
 Integer division and remainder are not provided; do not fall back to native-register conversions.
template<class U>
requires (std::is_arithmetic_v<U> && !simd_integer_element<U>)
void operator/ (U, simd)=delete
 Integer division and remainder are not provided; do not fall back to native-register conversions.
template<simd_integer_element U, std::size_t M>
requires (!std::same_as<simd, ::native::simd<U, M,Arch>>)
void operator/ (simd, ::native::simd< U, M, Arch >)=delete
 Integer division and remainder are not provided; do not fall back to native-register conversions.
template<class U>
requires (std::is_arithmetic_v<U> && !simd_integer_element<U>)
void operator% (simd, U)=delete
 Integer division and remainder are not provided; do not fall back to native-register conversions.
template<class U>
requires (std::is_arithmetic_v<U> && !simd_integer_element<U>)
void operator% (U, simd)=delete
 Integer division and remainder are not provided; do not fall back to native-register conversions.
template<simd_integer_element U, std::size_t M>
requires (!std::same_as<simd, ::native::simd<U, M,Arch>>)
void operator% (simd, ::native::simd< U, M, Arch >)=delete
 Integer division and remainder are not provided; do not fall back to native-register conversions.
template<class U>
requires (std::is_arithmetic_v<U> && !simd_integer_element<U>)
void operator& (simd, U)=delete
 Reject this unsupported operand combination instead of converting implicitly to a native register.
template<class U>
requires (std::is_arithmetic_v<U> && !simd_integer_element<U>)
void operator& (U, simd)=delete
 Reject this unsupported operand combination instead of converting implicitly to a native register.
template<simd_integer_element U, std::size_t M>
requires (!std::same_as<simd, ::native::simd<U, M,Arch>>)
void operator& (simd, ::native::simd< U, M, Arch >)=delete
 Reject this unsupported operand combination instead of converting implicitly to a native register.
template<class U>
requires (std::is_arithmetic_v<U> && !simd_integer_element<U>)
void operator| (simd, U)=delete
 Reject this unsupported operand combination instead of converting implicitly to a native register.
template<class U>
requires (std::is_arithmetic_v<U> && !simd_integer_element<U>)
void operator| (U, simd)=delete
 Reject this unsupported operand combination instead of converting implicitly to a native register.
template<simd_integer_element U, std::size_t M>
requires (!std::same_as<simd, ::native::simd<U, M,Arch>>)
void operator| (simd, ::native::simd< U, M, Arch >)=delete
 Reject this unsupported operand combination instead of converting implicitly to a native register.
template<class U>
requires (std::is_arithmetic_v<U> && !simd_integer_element<U>)
void operator^ (simd, U)=delete
 Reject this unsupported operand combination instead of converting implicitly to a native register.
template<class U>
requires (std::is_arithmetic_v<U> && !simd_integer_element<U>)
void operator^ (U, simd)=delete
 Reject this unsupported operand combination instead of converting implicitly to a native register.
template<simd_integer_element U, std::size_t M>
requires (!std::same_as<simd, ::native::simd<U, M,Arch>>)
void operator^ (simd, ::native::simd< U, M, Arch >)=delete
 Reject this unsupported operand combination instead of converting implicitly to a native register.
template<class U>
requires (std::is_arithmetic_v<U> && !simd_integer_element<U>)
void operator== (simd, U)=delete
 Reject this unsupported operand combination instead of converting implicitly to a native register.
template<class U>
requires (std::is_arithmetic_v<U> && !simd_integer_element<U>)
void operator== (U, simd)=delete
 Reject this unsupported operand combination instead of converting implicitly to a native register.
template<simd_integer_element U, std::size_t M>
requires (!std::same_as<simd, ::native::simd<U, M,Arch>>)
void operator== (simd, ::native::simd< U, M, Arch >)=delete
 Reject this unsupported operand combination instead of converting implicitly to a native register.
template<class U>
requires (std::is_arithmetic_v<U> && !simd_integer_element<U>)
void operator!= (simd, U)=delete
 Reject this unsupported operand combination instead of converting implicitly to a native register.
template<class U>
requires (std::is_arithmetic_v<U> && !simd_integer_element<U>)
void operator!= (U, simd)=delete
 Reject this unsupported operand combination instead of converting implicitly to a native register.
template<simd_integer_element U, std::size_t M>
requires (!std::same_as<simd, ::native::simd<U, M,Arch>>)
void operator!= (simd, ::native::simd< U, M, Arch >)=delete
 Reject this unsupported operand combination instead of converting implicitly to a native register.
template<class U>
requires (std::is_arithmetic_v<U> && !simd_integer_element<U>)
void operator< (simd, U)=delete
 Reject this unsupported operand combination instead of converting implicitly to a native register.
template<class U>
requires (std::is_arithmetic_v<U> && !simd_integer_element<U>)
void operator< (U, simd)=delete
 Reject this unsupported operand combination instead of converting implicitly to a native register.
template<simd_integer_element U, std::size_t M>
requires (!std::same_as<simd, ::native::simd<U, M,Arch>>)
void operator< (simd, ::native::simd< U, M, Arch >)=delete
 Reject this unsupported operand combination instead of converting implicitly to a native register.
template<class U>
requires (std::is_arithmetic_v<U> && !simd_integer_element<U>)
void operator> (simd, U)=delete
 Reject this unsupported operand combination instead of converting implicitly to a native register.
template<class U>
requires (std::is_arithmetic_v<U> && !simd_integer_element<U>)
void operator> (U, simd)=delete
 Reject this unsupported operand combination instead of converting implicitly to a native register.
template<simd_integer_element U, std::size_t M>
requires (!std::same_as<simd, ::native::simd<U, M,Arch>>)
void operator> (simd, ::native::simd< U, M, Arch >)=delete
 Reject this unsupported operand combination instead of converting implicitly to a native register.
template<class U>
requires (std::is_arithmetic_v<U> && !simd_integer_element<U>)
void operator<= (simd, U)=delete
 Reject this unsupported operand combination instead of converting implicitly to a native register.
template<class U>
requires (std::is_arithmetic_v<U> && !simd_integer_element<U>)
void operator<= (U, simd)=delete
 Reject this unsupported operand combination instead of converting implicitly to a native register.
template<simd_integer_element U, std::size_t M>
requires (!std::same_as<simd, ::native::simd<U, M,Arch>>)
void operator<= (simd, ::native::simd< U, M, Arch >)=delete
 Reject this unsupported operand combination instead of converting implicitly to a native register.
template<class U>
requires (std::is_arithmetic_v<U> && !simd_integer_element<U>)
void operator>= (simd, U)=delete
 Reject this unsupported operand combination instead of converting implicitly to a native register.
template<class U>
requires (std::is_arithmetic_v<U> && !simd_integer_element<U>)
void operator>= (U, simd)=delete
 Reject this unsupported operand combination instead of converting implicitly to a native register.
template<simd_integer_element U, std::size_t M>
requires (!std::same_as<simd, ::native::simd<U, M,Arch>>)
void operator>= (simd, ::native::simd< U, M, Arch >)=delete
 Reject this unsupported operand combination instead of converting implicitly to a native register.
simd operator/ (simd, simd)=delete
 Integer division and remainder are not provided; do not fall back to native-register conversions.
simd operator% (simd, simd)=delete
 Integer division and remainder are not provided; do not fall back to native-register conversions.
template<simd_integer_element U>
simd operator/ (simd, U)=delete
 Integer division and remainder are not provided; do not fall back to native-register conversions.
template<simd_integer_element U>
simd operator/ (U, simd)=delete
 Integer division and remainder are not provided; do not fall back to native-register conversions.
template<simd_integer_element U>
simd operator% (simd, U)=delete
 Integer division and remainder are not provided; do not fall back to native-register conversions.
template<simd_integer_element U>
simd operator% (U, simd)=delete
 Integer division and remainder are not provided; do not fall back to native-register conversions.
template<simd_integer_element U>
simd operator<< (simd, U)=delete
 Reject runtime shift counts; use a compile-time imm<K> within the lane width.
template<simd_integer_element U>
simd operator>> (simd, U)=delete
 Reject runtime shift counts; use a compile-time imm<K> within the lane width.
constexpr bool any (simd x) noexcept
 Return true when at least one logical lane is true.
constexpr bool all (simd x) noexcept
 Return true exactly when every logical lane is true.
constexpr bool none (simd x) noexcept
 Return true exactly when no logical lane is true.
constexpr simd operator+ (simd a, simd b) noexcept
constexpr simd operator- (simd a, simd b) noexcept
constexpr simd operator* (simd a, simd b) noexcept
constexpr simd operator/ (simd a, simd b) noexcept
constexpr simd operator- (simd a) noexcept
 Negate every logical lane; floating-point lanes change sign.
constexpr simd operator& (simd a, simd b) noexcept
 Bitwise AND of corresponding lane representations.
constexpr simd operator| (simd a, simd b) noexcept
 Bitwise OR of corresponding lane representations.
constexpr simd operator^ (simd a, simd b) noexcept
 Bitwise XOR of corresponding lane representations.
constexpr simd operator~ (simd a) noexcept
 Complement every bit in every lane.
constexpr simd operator! (simd a) noexcept
 Return the lane-wise logical complement, retaining this mask type.
constexpr mask_type operator== (simd a, simd b) noexcept
 Return a mask whose lanes are true where a == b holds.
constexpr mask_type operator!= (simd a, simd b) noexcept
 Return a mask whose lanes are true where a != b holds.
constexpr mask_type operator< (simd a, simd b) noexcept
 Return a mask whose lanes are true where a < b holds.
constexpr mask_type operator> (simd a, simd b) noexcept
 Return a mask whose lanes are true where a > b holds.
constexpr mask_type operator<= (simd a, simd b) noexcept
 Return a mask whose lanes are true where a <= b holds.
constexpr mask_type operator>= (simd a, simd b) noexcept
 Return a mask whose lanes are true where a >= b holds.
template<class M>
requires (std::same_as<M,mask_type> || std::same_as<M,vector_mask_type>)
constexpr simd select (M mask, simd a, simd b)
 Choose a in true mask lanes and b in false lanes; both values are already evaluated.
constexpr simd fma (simd a, simd b, simd c) noexcept
 Compute a*b+c with one fused rounding per logical lane in the caller's floating-point environment.
constexpr simd sqrt (simd a) noexcept
 Compute the native square root of each logical lane in the caller's floating-point environment.
constexpr simd round_even (simd a) noexcept
 Round each logical lane to an integral value, ties to even, independently of the ambient rounding direction.
constexpr simd normal_pow2 (simd a) noexcept
 Construct normal powers of two; require each input to be an integral exponent in [-126,127].
template<std::size_t K>
requires (K<32) && simd_integer_element<T>
constexpr simd operator<< (simd a, imm_t< K >)
 Shift every lane left by K bits, discarding high bits. Require K smaller than the lane bit width.
template<std::size_t K>
requires (K<32) && simd_integer_element<T>
constexpr simd operator>> (simd a, imm_t< K >)
 Shift every lane right by K; signed lanes extend the sign, unsigned lanes shift in zero. Require K smaller than the lane bit width.
simd operator<< (simd, simd)=delete
 Reject runtime shift counts; use a compile-time imm<K> within the lane width.
simd operator>> (simd, simd)=delete
 Reject runtime shift counts; use a compile-time imm<K> within the lane width.
simd operator/ (simd, simd)=delete
 Integer division and remainder are not provided; do not fall back to native-register conversions.
simd operator% (simd, simd)=delete
 Integer division and remainder are not provided; do not fall back to native-register conversions.
template<simd_integer_element U>
requires simd_integer_element<T>
simd operator<< (simd, U)=delete
 Reject runtime shift counts; use a compile-time imm<K> within the lane width.
template<simd_integer_element U>
requires simd_integer_element<T>
simd operator>> (simd, U)=delete
 Reject runtime shift counts; use a compile-time imm<K> within the lane width.
template<simd_integer_element U>
requires simd_integer_element<T>
simd operator/ (simd, U)=delete
 Integer division and remainder are not provided; do not fall back to native-register conversions.
template<simd_integer_element U>
requires simd_integer_element<T>
simd operator/ (U, simd)=delete
 Integer division and remainder are not provided; do not fall back to native-register conversions.
template<simd_integer_element U>
requires simd_integer_element<T>
simd operator% (simd, U)=delete
 Integer division and remainder are not provided; do not fall back to native-register conversions.
template<simd_integer_element U>
requires simd_integer_element<T>
simd operator% (U, simd)=delete
 Integer division and remainder are not provided; do not fall back to native-register conversions.

Detailed Description

template<simd_custom_element T, std::size_t N, isa<> Arch>
requires NATIVE_COMMON_ARCH(Arch)
struct native::simd< T, N, Arch >

Two or three logical lanes in the corresponding four-lane native storage. Loads and stores touch only logical lanes; mask reductions ignore padding. Division supplies harmless inactive operands before using the full register.

template<native::isa<> Arch>
void swizzles() {
using V = native::simd<float, 3, Arch>;
V position{1.f, 2.f, 3.f};
auto saved = position.xy; // an owning two-lane value
position.xyz = position.zyx; // snapshot, then scatter
position.x = 4.f;
check(all(saved == native::simd<float, 2, Arch>{1.f, 2.f}));
check(all(position == V{4.f, 2.f, 1.f}));
}

Definition at line 22 of file common_body.h.

◆ operator*

template<simd_custom_element T, std::size_t N, isa<> Arch>
simd operator* ( simd< T, N, Arch > a,
simd< T, N, Arch > b )
friend

Multiply corresponding logical lanes using the full-register operation. Integer results wrap at the lane width; floating results follow the caller's environment.

Definition at line 4961 of file simd_family.h.

◆ operator+

template<simd_custom_element T, std::size_t N, isa<> Arch>
simd operator+ ( simd< T, N, Arch > a,
simd< T, N, Arch > b )
friend

Add corresponding logical lanes using the full-register operation. Integer results wrap at the lane width; floating results follow the caller's environment.

Definition at line 4955 of file simd_family.h.

◆ operator-

template<simd_custom_element T, std::size_t N, isa<> Arch>
simd operator- ( simd< T, N, Arch > a,
simd< T, N, Arch > b )
friend

Subtract corresponding logical lanes using the full-register operation. Integer results wrap at the lane width; floating results follow the caller's environment.

Definition at line 4958 of file simd_family.h.

◆ operator/

template<simd_custom_element T, std::size_t N, isa<> Arch>
simd operator/ ( simd< T, N, Arch > a,
simd< T, N, Arch > b )
friend

Divide corresponding logical lanes using the full-register operation. Inactive denominator lanes are set to one so padding does not introduce division by zero.

Definition at line 4964 of file simd_family.h.

◆ operator<< [1/2]

template<simd_custom_element T, std::size_t N, isa<> Arch>
template<std::size_t K>
requires (K<32) && simd_integer_element<T>
simd operator<< ( simd< T, N, Arch > a,
imm_t< K >  )
friend

Shift every lane left by K bits, discarding high bits. Require K smaller than the lane bit width.

Shift every lane left by K bits, discarding high bits. Require K smaller than the lane bit width.

Definition at line 5009 of file simd_family.h.

◆ operator<< [2/2]

template<simd_custom_element T, std::size_t N, isa<> Arch>
template<std::size_t K>
requires (K < sizeof(T) * 8)
simd operator<< ( simd< T, N, Arch > a,
imm_t< K >  )
friend

Shift every lane left by K bits, discarding high bits. Require K smaller than the lane bit width.

Shift every lane left by K bits, discarding high bits. Require K smaller than the lane bit width.

Definition at line 2906 of file simd_family.h.

◆ operator>> [1/2]

template<simd_custom_element T, std::size_t N, isa<> Arch>
template<std::size_t K>
requires (K<32) && simd_integer_element<T>
simd operator>> ( simd< T, N, Arch > a,
imm_t< K >  )
friend

Shift every lane right by K; signed lanes extend the sign, unsigned lanes shift in zero. Require K smaller than the lane bit width.

Shift every lane right by K; signed lanes extend the sign, unsigned lanes shift in zero. Require K smaller than the lane bit width.

Definition at line 5012 of file simd_family.h.

◆ operator>> [2/2]

template<simd_custom_element T, std::size_t N, isa<> Arch>
template<std::size_t K>
requires (K < sizeof(T) * 8)
simd operator>> ( simd< T, N, Arch > a,
imm_t< K >  )
friend

Shift every lane right by K; signed lanes extend the sign, unsigned lanes shift in zero. Require K smaller than the lane bit width.

Shift every lane right by K; signed lanes extend the sign, unsigned lanes shift in zero. Require K smaller than the lane bit width.

Definition at line 2926 of file simd_family.h.

◆ select

template<simd_custom_element T, std::size_t N, isa<> Arch>
template<class M>
requires (std::same_as<M,mask_type> || std::same_as<M,vector_mask_type>)
simd select ( M mask,
simd< T, N, Arch > a,
simd< T, N, Arch > b )
friend

Choose a in true mask lanes and b in false lanes; both values are already evaluated.

Choose a in true lanes and b in false lanes; both operands are evaluated.

Definition at line 4995 of file simd_family.h.

The documentation for this struct was generated from the following files: