Struct u16x16 

#[repr(C, align(32))]
pub struct u16x16<S: Simd> {
    pub(crate) val: S::u16x16,
    pub simd: S,
}

A SIMD vector of 16 u16 elements.

You may construct this vector type using the Self::splat, Self::from_slice, Self::simd_from, Self::from_fn, and Self::block_splat methods.

fn construct_simd<S: Simd>(simd: S) {
    // From a single scalar value:
    let a = u16x16::splat(simd, 1);
    let b = u16x16::simd_from(simd, 1);

    // From a slice:
    let c = u16x16::from_slice(simd, &[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]);

    // From an array:
    let d = u16x16::simd_from(simd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]);

    // From an element-wise function:
    let e = u16x16::from_fn(simd, |i| i as u16);
    // From `Self::Block`:
    let f = u16x16::block_splat(u16x8::simd_from(simd, [1, 2, 3, 4, 5, 6, 7, 8]));
}

Fields

val: S::u16x16

simd: S

Trait Implementations

impl<S: Simd> Add<u16> for u16x16<S>

type Output = u16x16<S>

The resulting type after applying the + operator.

fn add(self, rhs: u16) -> Self::Output

Performs the + operation.

impl<S: Simd> Add<u16x16<S>> for u16

type Output = u16x16<S>

The resulting type after applying the + operator.

fn add(self, rhs: u16x16<S>) -> Self::Output

Performs the + operation.

impl<S: Simd> Add for u16x16<S>

fn add(self, rhs: Self) -> Self::Output

Add two vectors element-wise, wrapping on overflow.

type Output = u16x16<S>

The resulting type after applying the + operator.

impl<S: Simd> AddAssign<u16> for u16x16<S>

fn add_assign(&mut self, rhs: u16)

Performs the += operation.

impl<S: Simd> AddAssign for u16x16<S>

fn add_assign(&mut self, rhs: Self)

Add two vectors element-wise, wrapping on overflow.

impl<S: Simd> BitAnd<u16> for u16x16<S>

type Output = u16x16<S>

The resulting type after applying the & operator.

fn bitand(self, rhs: u16) -> Self::Output

Performs the & operation.

impl<S: Simd> BitAnd<u16x16<S>> for u16

type Output = u16x16<S>

The resulting type after applying the & operator.

fn bitand(self, rhs: u16x16<S>) -> Self::Output

Performs the & operation.

impl<S: Simd> BitAnd for u16x16<S>

fn bitand(self, rhs: Self) -> Self::Output

Compute the bitwise AND of two vectors.

type Output = u16x16<S>

The resulting type after applying the & operator.

impl<S: Simd> BitAndAssign<u16> for u16x16<S>

fn bitand_assign(&mut self, rhs: u16)

Performs the &= operation.

impl<S: Simd> BitAndAssign for u16x16<S>

fn bitand_assign(&mut self, rhs: Self)

Compute the bitwise AND of two vectors.

impl<S: Simd> BitOr<u16> for u16x16<S>

type Output = u16x16<S>

The resulting type after applying the | operator.

fn bitor(self, rhs: u16) -> Self::Output

Performs the | operation.

impl<S: Simd> BitOr<u16x16<S>> for u16

type Output = u16x16<S>

The resulting type after applying the | operator.

fn bitor(self, rhs: u16x16<S>) -> Self::Output

Performs the | operation.

impl<S: Simd> BitOr for u16x16<S>

fn bitor(self, rhs: Self) -> Self::Output

Compute the bitwise OR of two vectors.

type Output = u16x16<S>

The resulting type after applying the | operator.

impl<S: Simd> BitOrAssign<u16> for u16x16<S>

fn bitor_assign(&mut self, rhs: u16)

Performs the |= operation.

impl<S: Simd> BitOrAssign for u16x16<S>

fn bitor_assign(&mut self, rhs: Self)

Compute the bitwise OR of two vectors.

impl<S: Simd> BitXor<u16> for u16x16<S>

type Output = u16x16<S>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: u16) -> Self::Output

Performs the ^ operation.

impl<S: Simd> BitXor<u16x16<S>> for u16

type Output = u16x16<S>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: u16x16<S>) -> Self::Output

Performs the ^ operation.

impl<S: Simd> BitXor for u16x16<S>

fn bitxor(self, rhs: Self) -> Self::Output

Compute the bitwise XOR of two vectors.

type Output = u16x16<S>

The resulting type after applying the ^ operator.

impl<S: Simd> BitXorAssign<u16> for u16x16<S>

fn bitxor_assign(&mut self, rhs: u16)

Performs the ^= operation.

impl<S: Simd> BitXorAssign for u16x16<S>

fn bitxor_assign(&mut self, rhs: Self)

Compute the bitwise XOR of two vectors.

impl<S: Simd> Bytes for u16x16<S>

type Bytes = u8x32<S>

fn to_bytes(self) -> Self::Bytes

Convert this type to an array of bytes.

fn from_bytes(value: Self::Bytes) -> Self

Create an instance of this type from an array of bytes.

fn bitcast<U: Bytes<Bytes = Self::Bytes>>(self) -> U

Bitcast directly from this type to another one of the same size.

impl<S: Clone + Simd> Clone for u16x16<S>

where S::u16x16: Clone,

fn clone(&self) -> u16x16<S>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<S: Simd + Debug> Debug for u16x16<S>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<S: Simd> Deref for u16x16<S>

type Target = [u16; 16]

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<S: Simd> DerefMut for u16x16<S>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<S: Simd> From<u16x16<S>> for [u16; 16]

fn from(value: u16x16<S>) -> Self

Converts to this type from the input type.

impl<S: Simd> From<u16x16<S>> for __m256i

fn from(value: u16x16<S>) -> Self

Converts to this type from the input type.

impl<S: Simd> Index<usize> for u16x16<S>

type Output = u16

The returned type after indexing.

fn index(&self, i: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<S: Simd> IndexMut<usize> for u16x16<S>

fn index_mut(&mut self, i: usize) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<S: Simd> Mul<u16> for u16x16<S>

type Output = u16x16<S>

The resulting type after applying the * operator.

fn mul(self, rhs: u16) -> Self::Output

Performs the * operation.

impl<S: Simd> Mul<u16x16<S>> for u16

type Output = u16x16<S>

The resulting type after applying the * operator.

fn mul(self, rhs: u16x16<S>) -> Self::Output

Performs the * operation.

impl<S: Simd> Mul for u16x16<S>

fn mul(self, rhs: Self) -> Self::Output

Multiply two vectors element-wise, wrapping on overflow.

type Output = u16x16<S>

The resulting type after applying the * operator.

impl<S: Simd> MulAssign<u16> for u16x16<S>

fn mul_assign(&mut self, rhs: u16)

Performs the *= operation.

impl<S: Simd> MulAssign for u16x16<S>

fn mul_assign(&mut self, rhs: Self)

Multiply two vectors element-wise, wrapping on overflow.

impl<S: Simd> Not for u16x16<S>

fn not(self) -> Self::Output

Compute the bitwise NOT of the vector.

type Output = u16x16<S>

The resulting type after applying the ! operator.

impl<S: Simd> Select<u16x16<S>> for mask16x16<S>

fn select(self, if_true: u16x16<S>, if_false: u16x16<S>) -> u16x16<S>

For each element of this mask, select the first operand if the element is all ones, and select the second operand if the element is all zeroes.

impl<S: Simd> Shl<u32> for u16x16<S>

fn shl(self, rhs: u32) -> Self::Output

Shift each element left by the given number of bits.

Bits shifted out of the left side are discarded, and zeros are shifted in on the right.

type Output = u16x16<S>

The resulting type after applying the << operator.

impl<S: Simd> Shl for u16x16<S>

fn shl(self, rhs: Self) -> Self::Output

Shift each element left by the given number of bits.

Bits shifted out of the left side are discarded, and zeros are shifted in on the right.

This operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation.

type Output = u16x16<S>

The resulting type after applying the << operator.

impl<S: Simd> ShlAssign<u32> for u16x16<S>

fn shl_assign(&mut self, rhs: u32)

Performs the <<= operation.

impl<S: Simd> ShlAssign for u16x16<S>

fn shl_assign(&mut self, rhs: Self)

Shift each element left by the given number of bits.

Bits shifted out of the left side are discarded, and zeros are shifted in on the right.

This operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation.

impl<S: Simd> Shr<u32> for u16x16<S>

fn shr(self, rhs: u32) -> Self::Output

Shift each element right by the given number of bits.

For unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.

type Output = u16x16<S>

The resulting type after applying the >> operator.

impl<S: Simd> Shr for u16x16<S>

fn shr(self, rhs: Self) -> Self::Output

Shift each element right by the corresponding element in another vector.

For unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.

This operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation.

type Output = u16x16<S>

The resulting type after applying the >> operator.

impl<S: Simd> ShrAssign<u32> for u16x16<S>

fn shr_assign(&mut self, rhs: u32)

Performs the >>= operation.

impl<S: Simd> ShrAssign for u16x16<S>

fn shr_assign(&mut self, rhs: Self)

Shift each element right by the corresponding element in another vector.

For unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.

This operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation.

impl<S: Simd> SimdBase<S> for u16x16<S>

const N: usize = 16

This vector type’s lane count. This is useful when you’re working with a native-width vector (e.g. Simd::f32s) and want to process data in native-width chunks.

type Element = u16

The type of this vector’s elements.

type Mask = mask16x16<S>

A SIMD vector mask with the same number of elements.

type Block = u16x8<S>

A 128-bit SIMD vector of the same scalar type.

type Array = [u16; 16]

The array type that this vector type corresponds to, which will always be [Self::Element; Self::N]. It has the same layout as this vector type, but likely has a lower alignment.

fn witness(&self) -> S

Get the Simd implementation associated with this type.

fn as_slice(&self) -> &[u16]

fn as_mut_slice(&mut self) -> &mut [u16]

fn from_slice(simd: S, slice: &[u16]) -> Self

Create a SIMD vector from a slice.

fn store_slice(&self, slice: &mut [u16])

Store a SIMD vector into a slice.

fn splat(simd: S, val: u16) -> Self

Create a SIMD vector with all elements set to the given value.

fn block_splat(block: Self::Block) -> Self

Create a SIMD vector from a 128-bit vector of the same scalar type, repeated.

fn from_fn(simd: S, f: impl FnMut(usize) -> u16) -> Self

Create a SIMD vector where each element is produced by calling f with that element’s lane index (from 0 to SimdBase::N - 1).

fn slide<const SHIFT: usize>(self, rhs: impl SimdInto<Self, S>) -> Self

Concatenate [self, rhs] and extract Self::N elements starting at index SHIFT.

fn slide_within_blocks<const SHIFT: usize>( self, rhs: impl SimdInto<Self, S>, ) -> Self

Like slide, but operates independently on each 128-bit block.

impl<S: Simd> SimdCombine<S> for u16x16<S>

type Combined = u16x32<S>

fn combine(self, rhs: impl SimdInto<Self, S>) -> Self::Combined

Concatenate two vectors into a new one that’s twice as long.

impl<S: Simd> SimdFrom<[u16; 16], S> for u16x16<S>

fn simd_from(simd: S, val: [u16; 16]) -> Self

impl<S: Simd> SimdFrom<__m256i, S> for u16x16<S>

fn simd_from(simd: S, arch: __m256i) -> Self

impl<S: Simd> SimdFrom<u16, S> for u16x16<S>

fn simd_from(simd: S, value: u16) -> Self

impl<S: Simd> SimdInt<S> for u16x16<S>

fn simd_eq(self, rhs: impl SimdInto<Self, S>) -> Self::Mask

Compare two vectors element-wise for equality.

fn simd_lt(self, rhs: impl SimdInto<Self, S>) -> Self::Mask

Compare two vectors element-wise for less than.

fn simd_le(self, rhs: impl SimdInto<Self, S>) -> Self::Mask

Compare two vectors element-wise for less than or equal.

fn simd_ge(self, rhs: impl SimdInto<Self, S>) -> Self::Mask

Compare two vectors element-wise for greater than or equal.

fn simd_gt(self, rhs: impl SimdInto<Self, S>) -> Self::Mask

Compare two vectors element-wise for greater than.

fn zip_low(self, rhs: impl SimdInto<Self, S>) -> Self

Interleave the lower half elements of two vectors.

fn zip_high(self, rhs: impl SimdInto<Self, S>) -> Self

Interleave the upper half elements of two vectors.

fn unzip_low(self, rhs: impl SimdInto<Self, S>) -> Self

Extract even-indexed elements from two vectors.

fn unzip_high(self, rhs: impl SimdInto<Self, S>) -> Self

Extract odd-indexed elements from two vectors.

fn interleave(self, rhs: impl SimdInto<Self, S>) -> (Self, Self)

Interleave two vectors.

fn deinterleave(self, rhs: impl SimdInto<Self, S>) -> (Self, Self)

Deinterleave two vectors.

fn min(self, rhs: impl SimdInto<Self, S>) -> Self

Return the element-wise minimum of two vectors.

fn max(self, rhs: impl SimdInto<Self, S>) -> Self

Return the element-wise maximum of two vectors.

fn to_float<T: SimdCvtFloat<Self>>(self) -> T

Convert this integer type to a floating-point type. This is a convenience method that delegates to SimdCvtFloat::float_from, and can only be called if there actually exists a target type of the same bit width (currently, only f32).

impl<S: Simd> SimdSplit<S> for u16x16<S>

type Split = u16x8<S>

fn split(self) -> (Self::Split, Self::Split)

Split this vector into left and right halves.

impl<S: Simd> Sub<u16> for u16x16<S>

type Output = u16x16<S>

The resulting type after applying the - operator.

fn sub(self, rhs: u16) -> Self::Output

Performs the - operation.

impl<S: Simd> Sub<u16x16<S>> for u16

type Output = u16x16<S>

The resulting type after applying the - operator.

fn sub(self, rhs: u16x16<S>) -> Self::Output

Performs the - operation.

impl<S: Simd> Sub for u16x16<S>

fn sub(self, rhs: Self) -> Self::Output

Subtract two vectors element-wise, wrapping on overflow.

type Output = u16x16<S>

The resulting type after applying the - operator.

impl<S: Simd> SubAssign<u16> for u16x16<S>

fn sub_assign(&mut self, rhs: u16)

Performs the -= operation.

impl<S: Simd> SubAssign for u16x16<S>

fn sub_assign(&mut self, rhs: Self)

Subtract two vectors element-wise, wrapping on overflow.

impl<S: Copy + Simd> Copy for u16x16<S>

where S::u16x16: Copy,