Struct u16x32 

pub struct u16x32 { /* private fields */ }

A SIMD vector with 32 elements of type u16.

See the crate level documentation for more information about SIMD vectors.

Implementations

impl u16x32

The following functionality exists for all SIMD vectors.

pub const fn new(array: [u16; 32]) -> Self

Converts an array to a SIMD vector.

pub const fn splat(elem: u16) -> Self

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

pub const fn to_array(self) -> [u16; 32]

Converts a SIMD vector to an array.

pub const fn as_array(&self) -> &[u16; 32]

Returns an array reference containing the entire SIMD vector.

pub const fn as_mut_array(&mut self) -> &mut [u16; 32]

Returns a mutable array reference containing the entire SIMD vector.

pub const fn from_ne_bytes(bytes: [u8; 64]) -> Self

Creates a SIMD vector from a native-endian byte array.

The bytes are interpreted as the raw memory representation of the vector. This is equivalent to the from_ne_bytes functions on the primitive scalar types, but operates on the entire vector at once.

This is the inverse of to_ne_bytes.

pub const fn to_ne_bytes(self) -> [u8; 64]

Returns the raw memory representation of self as a native-endian byte array.

This is the inverse of from_ne_bytes.

pub fn simd_eq<Rhs>(self, other: Rhs) -> <Self as CmpEq<Rhs>>::Output

where Self: CmpEq<Rhs>,

Returns a mask that checks if each element of self is equal to the corresponding element of other.

pub fn simd_ne<Rhs>(self, other: Rhs) -> <Self as CmpNe<Rhs>>::Output

where Self: CmpNe<Rhs>,

Returns a mask that checks if each element of self is not equal to the corresponding element of other.

pub fn simd_lt<Rhs>(self, other: Rhs) -> <Self as CmpLt<Rhs>>::Output

where Self: CmpLt<Rhs>,

Returns a mask that checks if each element of self is less than the corresponding element of other.

pub fn simd_gt<Rhs>(self, other: Rhs) -> <Self as CmpGt<Rhs>>::Output

where Self: CmpGt<Rhs>,

Returns a mask that checks if each element of self is greater than the corresponding element of other.

pub fn simd_le<Rhs>(self, other: Rhs) -> <Self as CmpLe<Rhs>>::Output

where Self: CmpLe<Rhs>,

Returns a mask that checks if each element of self is less than or equal to the corresponding element of other.

pub fn simd_ge<Rhs>(self, other: Rhs) -> <Self as CmpGe<Rhs>>::Output

where Self: CmpGe<Rhs>,

Returns a mask that checks if each element of self is greater than or equal to the corresponding element of other.

pub fn reduce_add(self) -> u16

Reducing addition. Returns the sum of the vector’s elements.

Equivalent to self[0] + self[1] + ....

pub fn reduce_mul(self) -> u16

Reducing multiplication. Returns the product of the vector’s elements.

Equivalent to self[0] * self[1] * ....

pub fn bitselect(self, if_one: Self, if_zero: Self) -> Self

Bitwise selection.

For each bit of self:

• If the bit is one, return the corresponding bit of if_one
• If the bit is zero, return the corresponding bit of if_zero

If you know self is a mask, meaning each element is either all zeros or all ones, consider using select which is faster.

pub fn select<Output>(self, if_true: Output, if_false: Output) -> Output

where Self: Select<Output>,

Lanewise SIMD selection.

For each lane:

• If all bits of self are one, return the corresponding lane of if_true
• If all bits of self are zero, return the corresponding lane of if_false

This function assumes self is a mask, meaning each element is either all zeros or all ones. For bitwise selection use bitselect.

In addition to selecting SIMD vectors, this method can be used to select composite types (e.g., a downstream Vec3<f32x4> structure) if you implement Select<Composite> for Simd.

pub fn to_bitmask(self) -> u32

Converts to a bitmask, where each bit is 1 if the element of self is true or 0 if the element of self is false.

Each bit of the output corresponds to an element of self. The least significant bit corresponds to the lowest element. Remaining bits are 0.

This function assumes self is a mask, meaning each element is either all zeros or all ones. If the input is not a mask, the result is unspecified.

pub fn any(self) -> bool

Returns true if any element of self is true.

This function assumes self is a mask, meaning each element is either all zeros or all ones. If the input is not a mask, the result is unspecified.

pub fn all(self) -> bool

Returns true if all elements of self are true.

This function assumes self is a mask, meaning each element is either all zeros or all ones. If the input is not a mask, the result is unspecified.

pub fn none(self) -> bool

Returns true if none of the elements of self are true.

This function assumes self is a mask, meaning each element is either all zeros or all ones. If the input is not a mask, the result is unspecified.

pub fn shuffle(self, indices: u16x32) -> Self

Returns a SIMD vector whose elements are selected from self using the corresponding runtime indices.

If an index is out of bounds, the corresponding result element is unspecified.

Equivalent to [self[indices[0]], self[indices[1]], ..., self[[indices[N - 1]]]].

Type-specific guarantees

For u8x16 and i8x16, it is guaranteed that for out of bounds indices, if the high bit of an index is set, zero is returned. Otherwise, either zero is returned or the index wraps around, non-deterministically.

For all other 8-bit types, it is guaranteed that for out of bounds indices, either zero is returned or the index wraps around, non-deterministically (unlike other types, which can return arbitrary values).

pub fn shuffle_zeroing(self, indices: u16x32) -> Self

Returns a SIMD vector whose elements are selected from self using the corresponding runtime indices.

If an index is out of bounds, the corresponding result element is the number zero.

Equivalent to [self[indices[0]], self[indices[1]], ..., self[[indices[N - 1]]]] with a zero fallback.

pub fn shuffle_wrapping(self, indices: u16x32) -> Self

Returns a SIMD vector whose elements are selected from self using the corresponding runtime indices.

Indices are wrapped by the number of elements in self.

Equivalent to [self[indices[0] % N], self[indices[1] % N], ..., self[[indices[N - 1] % N]]].

pub fn transpose(data: [Self; 32]) -> [Self; 32]

Transposes an array of SIMD vectors interpreted as a square matrix.

Currently this function is never accelerated.

pub fn blend(self, if_true: Self, if_false: Self) -> Self

👎Deprecated since 1.6.0:

split into select and bitselect functions

Elementwise selection.

For each element of self:

• If all bits are one, return the corresponding element of if_true
• If all bits are zero, return the corresponding element of if_false

Originally this function did not specify whether it supported per-bit selection, or if it assumed self is a mask, meaning each element is either all zeros or all ones (for better performance). Because of this, blend has been split into two new functions: select and bitselect.

impl u16x32

The following functionality exists for all SIMD vectors of unsigned integers.

pub const ONE: Self

A SIMD vector with all elements set to 1.

pub const ZERO: Self

A SIMD vector with all elements set to 0.

pub const MAX: Self

A SIMD vector with all elements set to u16::MAX.

pub const MIN: Self

A SIMD vector with all elements set to u16::MIN.

pub const LANES: u16 = 32

The number of elements in this SIMD vector.

pub const BITS: u16

The size of this SIMD vector in bits.

pub fn max(self, rhs: Self) -> Self

Returns the maximum between each element of self and the corresponding element of other.

pub fn min(self, rhs: Self) -> Self

Returns the minimum between each element of self and the corresponding element of other.

pub fn clamp(self, min: Self, max: Self) -> Self

Clamps each element of self between the corresponding elements of min and max.

If min > max, the result is unspecified. Consider manually checking for that case.

pub fn reduce_max(self) -> u16

Reducing maximum. Returns the maximum of the vector’s elements.

Equivalent to self[0].max(self[1].max(...)).

pub fn reduce_min(self) -> u16

Reducing minimum. Returns the minimum of the vector’s elements.

Equivalent to self[0].min(self[1].min(...)).

pub const fn cast_signed(self) -> i16x32

Returns the bit patterns of self reinterpreted as signed integers of the same size.

pub fn unbounded_shl(self, rhs: Self) -> Self

Shifts left each element of self by the corresponding element of rhs, without bounding rhs.

If rhs is larger than or equal to the number of bits in u16, the entire value is shifted out, and 0 is returned.

This is different from the standard operator, which behaves like wrapping_shl. For most targets, unbounded_shl is faster than the standard operator.

If you intend to shift all elements by the same value, consider using unbounded_shl_scalar which is faster.

pub fn unbounded_shl_scalar(self, rhs: u32) -> Self

Shifts left each element of self by the uniform scalar rhs, without bounding rhs.

If rhs is larger than or equal to the number of bits in u16, the entire value is shifted out, and 0 is returned.

This is different from the standard operator, which behaves like wrapping_shl. For most targets, unbounded_shl_scalar is faster than the standard operator.

This function is faster than self.unbounded_shl(splat(rhs)) because it has special hardware support.

pub fn unbounded_shr(self, rhs: Self) -> Self

Shifts right each element of self by the corresponding element of rhs, without bounding rhs.

If rhs is larger than or equal to the number of bits in u16, the entire value is shifted out, and 0 is returned.

This is different from the standard operator, which behaves like wrapping_shr. For most targets, unbounded_shr is faster than the standard operator.

If you intend to shift all elements by the same value, consider using unbounded_shr_scalar which is faster.

pub fn unbounded_shr_scalar(self, rhs: u32) -> Self

Shifts right each element of self by the uniform scalar rhs, without bounding rhs.

If rhs is larger than or equal to the number of bits in u16, the entire value is shifted out, and 0 is returned.

This is different from the standard operator, which behaves like wrapping_shr. For most targets, unbounded_shr_scalar is faster than the standard operator.

This function is faster than self.unbounded_shr(splat(rhs)) because it has special hardware support.

pub fn saturating_add(self, rhs: Self) -> Self

Saturating integer addition. Computes self + rhs, saturating at the numeric bounds instead of overflowing.

pub fn saturating_sub(self, rhs: Self) -> Self

Saturating integer subtraction. Computes self - rhs, saturating at the numeric bounds instead of overflowing.

pub fn saturating_mul(self, rhs: Self) -> Self

Saturating integer multiplication. Computes self * rhs, saturating at the numeric bounds instead of overflowing.

pub fn saturating_div(self, rhs: Self) -> Self

Saturating integer division. Computes self / rhs, saturating at the numeric bounds instead of overflowing.

Note that for unsigned integers overflow never occurs, so this is identical to regular division. This function only exists for consistency with signed integers.

Note that because division has no hardware support, this operation is very slow and should be avoided if possible.

Panics

Panics if any element of rhs is zero.

pub fn overflowing_add(self, rhs: Self) -> (Self, Self)

Returns self + rhs and whether an overflow occured.

Returns a tuple with:

• The addition (returns the wrapped value if an overflow occured)
• A mask indicating whether an overflow occured

pub fn overflowing_sub(self, rhs: Self) -> (Self, Self)

Returns self - rhs and whether an overflow occured.

Returns a tuple with:

• The subtraction (returns the wrapped value if an overflow occured)
• A mask indicating whether an overflow occured

pub fn overflowing_mul(self, rhs: Self) -> (Self, Self)

Returns self * rhs and whether an overflow occured.

Returns a tuple with:

• The multiplication (returns the wrapped value if an overflow occured)
• A mask indicating whether an overflow occured

pub fn overflowing_div(self, rhs: Self) -> (Self, Self)

Returns self / rhs and whether an overflow occured.

Note that for unsigned integers overflow never occurs, so the second value is always false. This function only exists for consistency with signed integers.

Returns a tuple with:

• The division (returns self if an overflow occured)
• A mask indicating whether an overflow occured (always false)

Note that because division has no hardware support, this operation is very slow and should be avoided if possible.

pub fn overflowing_rem(self, rhs: Self) -> (Self, Self)

Returns self % rhs and whether an overflow occured.

Note that for unsigned integers overflow never occurs, so the second value is always false. This function only exists for consistency with signed integers.

Returns a tuple with:

• The remainder (returns zero if an overflow occured)
• A mask indicating whether an overflow occured (always false)

Note that because division has no hardware support, this operation is very slow and should be avoided if possible.

pub fn mul_keep_low_high(self, rhs: Self) -> (Self, Self)

Computes self * rhs, producing intermediate 32-bit integers, then returns their low 16-bit parts and high 16-bit parts in two seperate SIMD vectors.

This function is different from widening_mul, which returns a single SIMD vector of a larger integer type, instead of two seperate SIMD vectors for low and high parts. Also note that while mul_keep_low_high exists for all types, widening_mul does not exist for types with no wider variant (e.g., for i32x16 because there is no i64x16).

pub fn mul_keep_high(self, rhs: Self) -> Self

Computes self * rhs, producing intermediate 32-bit integers, then returns their high 16-bit parts.

Trait Implementations

impl Add for u16x32

type Output = u16x32

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<&u16> for u16x32

type Output = u16x32

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<&u16> for &u16x32

type Output = u16x32

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<&u16x32> for u16x32

type Output = u16x32

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<&u16x32> for u16

type Output = u16x32

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<&u16x32> for &u16x32

type Output = u16x32

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<&u16x32> for &u16

type Output = u16x32

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<u16> for u16x32

type Output = u16x32

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<u16> for &u16x32

type Output = u16x32

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<u16x32> for u16

type Output = u16x32

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<u16x32> for &u16x32

type Output = u16x32

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<u16x32> for &u16

type Output = u16x32

The resulting type after applying the + operator.

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

Performs the + operation.

impl AddAssign for u16x32

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl AddAssign<&u16> for u16x32

fn add_assign(&mut self, rhs: &u16)

Performs the += operation.

impl AddAssign<&u16x32> for u16x32

fn add_assign(&mut self, rhs: &Self)

Performs the += operation.

impl AddAssign<u16> for u16x32

fn add_assign(&mut self, rhs: u16)

Performs the += operation.

impl AlignTo for u16x32

type Elem = u16

The element type of this SIMD vector.

fn simd_align_to( slice: &[Self::Elem], ) -> (&[Self::Elem], &[Self], &[Self::Elem])

A SIMD variant of align_to.

fn simd_align_to_mut( slice: &mut [Self::Elem], ) -> (&mut [Self::Elem], &mut [Self], &mut [Self::Elem])

A SIMD variant of align_to_mut.

impl Binary for u16x32

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

Formats the value using the given formatter.

impl BitAnd for u16x32

type Output = u16x32

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<&u16> for u16x32

type Output = u16x32

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<&u16> for &u16x32

type Output = u16x32

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<&u16x32> for u16x32

type Output = u16x32

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<&u16x32> for u16

type Output = u16x32

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<&u16x32> for &u16x32

type Output = u16x32

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<&u16x32> for &u16

type Output = u16x32

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<u16> for u16x32

type Output = u16x32

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<u16> for &u16x32

type Output = u16x32

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<u16x32> for u16

type Output = u16x32

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<u16x32> for &u16x32

type Output = u16x32

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<u16x32> for &u16

type Output = u16x32

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAndAssign for u16x32

fn bitand_assign(&mut self, rhs: Self)

Performs the &= operation.

impl BitAndAssign<&u16> for u16x32

fn bitand_assign(&mut self, rhs: &u16)

Performs the &= operation.

impl BitAndAssign<&u16x32> for u16x32

fn bitand_assign(&mut self, rhs: &Self)

Performs the &= operation.

impl BitAndAssign<u16> for u16x32

fn bitand_assign(&mut self, rhs: u16)

Performs the &= operation.

impl BitOr for u16x32

type Output = u16x32

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<&u16> for u16x32

type Output = u16x32

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<&u16> for &u16x32

type Output = u16x32

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<&u16x32> for u16x32

type Output = u16x32

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<&u16x32> for u16

type Output = u16x32

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<&u16x32> for &u16x32

type Output = u16x32

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<&u16x32> for &u16

type Output = u16x32

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<u16> for u16x32

type Output = u16x32

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<u16> for &u16x32

type Output = u16x32

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<u16x32> for u16

type Output = u16x32

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<u16x32> for &u16x32

type Output = u16x32

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<u16x32> for &u16

type Output = u16x32

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOrAssign for u16x32

fn bitor_assign(&mut self, rhs: Self)

Performs the |= operation.

impl BitOrAssign<&u16> for u16x32

fn bitor_assign(&mut self, rhs: &u16)

Performs the |= operation.

impl BitOrAssign<&u16x32> for u16x32

fn bitor_assign(&mut self, rhs: &Self)

Performs the |= operation.

impl BitOrAssign<u16> for u16x32

fn bitor_assign(&mut self, rhs: u16)

Performs the |= operation.

impl BitXor for u16x32

type Output = u16x32

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<&u16> for u16x32

type Output = u16x32

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<&u16> for &u16x32

type Output = u16x32

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<&u16x32> for u16x32

type Output = u16x32

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<&u16x32> for u16

type Output = u16x32

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<&u16x32> for &u16x32

type Output = u16x32

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<&u16x32> for &u16

type Output = u16x32

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<u16> for u16x32

type Output = u16x32

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<u16> for &u16x32

type Output = u16x32

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<u16x32> for u16

type Output = u16x32

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<u16x32> for &u16x32

type Output = u16x32

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<u16x32> for &u16

type Output = u16x32

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXorAssign for u16x32

fn bitxor_assign(&mut self, rhs: Self)

Performs the ^= operation.

impl BitXorAssign<&u16> for u16x32

fn bitxor_assign(&mut self, rhs: &u16)

Performs the ^= operation.

impl BitXorAssign<&u16x32> for u16x32

fn bitxor_assign(&mut self, rhs: &Self)

Performs the ^= operation.

impl BitXorAssign<u16> for u16x32

fn bitxor_assign(&mut self, rhs: u16)

Performs the ^= operation.

impl Clone for u16x32

fn clone(&self) -> u16x32

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl CmpEq for u16x32

type Output = u16x32

👎Deprecated since 1.5.0:

use the inherent function simd_eq instead

The type returned by simd_eq.

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

👎Deprecated since 1.5.0:

use the inherent function simd_eq instead

Returns a mask that checks if each element of self is equal to the corresponding element of rhs.

impl CmpEq<u16> for u16x32

type Output = u16x32

👎Deprecated since 1.5.0:

use the inherent function simd_eq instead

The type returned by simd_eq.

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

👎Deprecated since 1.5.0:

use the inherent function simd_eq instead

Returns a mask that checks if each element of self is equal to the corresponding element of rhs.

impl CmpGe for u16x32

type Output = u16x32

👎Deprecated since 1.5.0:

use the inherent function simd_ge instead

The type returned by simd_ge.

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

👎Deprecated since 1.5.0:

use the inherent function simd_ge instead

Returns a mask that checks if each element of self is greater than or equal to the corresponding element of rhs.

impl CmpGe<u16> for u16x32

type Output = u16x32

👎Deprecated since 1.5.0:

use the inherent function simd_ge instead

The type returned by simd_ge.

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

👎Deprecated since 1.5.0:

use the inherent function simd_ge instead

Returns a mask that checks if each element of self is greater than or equal to the corresponding element of rhs.

impl CmpGt for u16x32

type Output = u16x32

👎Deprecated since 1.5.0:

use the inherent function simd_gt instead

The type returned by simd_gt.

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

👎Deprecated since 1.5.0:

use the inherent function simd_gt instead

Returns a mask that checks if each element of self is greater than the corresponding element of rhs.

impl CmpGt<u16> for u16x32

type Output = u16x32

👎Deprecated since 1.5.0:

use the inherent function simd_gt instead

The type returned by simd_gt.

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

👎Deprecated since 1.5.0:

use the inherent function simd_gt instead

Returns a mask that checks if each element of self is greater than the corresponding element of rhs.

impl CmpLe for u16x32

type Output = u16x32

👎Deprecated since 1.5.0:

use the inherent function simd_le instead

The type returned by simd_le.

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

👎Deprecated since 1.5.0:

use the inherent function simd_le instead

Returns a mask that checks if each element of self is less than or equal to the corresponding element of rhs.

impl CmpLe<u16> for u16x32

type Output = u16x32

👎Deprecated since 1.5.0:

use the inherent function simd_le instead

The type returned by simd_le.

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

👎Deprecated since 1.5.0:

use the inherent function simd_le instead

Returns a mask that checks if each element of self is less than or equal to the corresponding element of rhs.

impl CmpLt for u16x32

type Output = u16x32

👎Deprecated since 1.5.0:

use the inherent function simd_lt instead

The type returned by simd_lt.

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

👎Deprecated since 1.5.0:

use the inherent function simd_lt instead

Returns a mask that checks if each element of self is less than the corresponding element of rhs.

impl CmpLt<u16> for u16x32

type Output = u16x32

👎Deprecated since 1.5.0:

use the inherent function simd_lt instead

The type returned by simd_lt.

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

👎Deprecated since 1.5.0:

use the inherent function simd_lt instead

Returns a mask that checks if each element of self is less than the corresponding element of rhs.

impl CmpNe for u16x32

type Output = u16x32

👎Deprecated since 1.5.0:

use the inherent function simd_ne instead

The type returned by simd_ne.

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

👎Deprecated since 1.5.0:

use the inherent function simd_ne instead

Returns a mask that checks if each element of self is not equal to the corresponding element of rhs.

impl CmpNe<u16> for u16x32

type Output = u16x32

👎Deprecated since 1.5.0:

use the inherent function simd_ne instead

The type returned by simd_ne.

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

👎Deprecated since 1.5.0:

use the inherent function simd_ne instead

Returns a mask that checks if each element of self is not equal to the corresponding element of rhs.

impl Copy for u16x32

impl Debug for u16x32

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

Formats the value using the given formatter.

impl Default for u16x32

fn default() -> u16x32

Returns the “default value” for a type.

impl Display for u16x32

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

Formats the value using the given formatter.

impl Div for u16x32

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

Divides each element of left by the corresponding element right.

Note that because division has no hardware support, this operation is very slow and should be avoided if possible.

Panics

Panics if any element of right is zero.

type Output = u16x32

The resulting type after applying the / operator.

impl Div<&u16> for u16x32

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

Divides each element of left by the scalar right.

Note that because division has no hardware support, this operation is very slow and should be avoided if possible.

Panics

Panics if right is zero.

type Output = u16x32

The resulting type after applying the / operator.

impl Div<&u16> for &u16x32

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

Divides each element of left by the scalar right.

Note that because division has no hardware support, this operation is very slow and should be avoided if possible.

Panics

Panics if right is zero.

type Output = u16x32

The resulting type after applying the / operator.

impl Div<&u16x32> for u16x32

fn div(self, rhs: &Self) -> Self::Output

Divides each element of left by the corresponding element right.

Note that because division has no hardware support, this operation is very slow and should be avoided if possible.

Panics

Panics if any element of right is zero.

type Output = u16x32

The resulting type after applying the / operator.

impl Div<&u16x32> for u16

fn div(self, rhs: &u16x32) -> Self::Output

Divides the scalar left by each element of right.

Note that because division has no hardware support, this operation is very slow and should be avoided if possible.

Panics

Panics if any element of right is zero.

type Output = u16x32

The resulting type after applying the / operator.

impl Div<&u16x32> for &u16x32

fn div(self, rhs: &u16x32) -> Self::Output

Divides each element of left by the corresponding element right.

Note that because division has no hardware support, this operation is very slow and should be avoided if possible.

Panics

Panics if any element of right is zero.

type Output = u16x32

The resulting type after applying the / operator.

impl Div<&u16x32> for &u16

fn div(self, rhs: &u16x32) -> Self::Output

Divides the scalar left by each element of right.

Note that because division has no hardware support, this operation is very slow and should be avoided if possible.

Panics

Panics if any element of right is zero.

type Output = u16x32

The resulting type after applying the / operator.

impl Div<u16> for u16x32

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

Divides each element of left by the scalar right.

Note that because division has no hardware support, this operation is very slow and should be avoided if possible.

Panics

Panics if right is zero.

type Output = u16x32

The resulting type after applying the / operator.

impl Div<u16> for &u16x32

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

Divides each element of left by the scalar right.

Note that because division has no hardware support, this operation is very slow and should be avoided if possible.

Panics

Panics if right is zero.

type Output = u16x32

The resulting type after applying the / operator.

impl Div<u16x32> for u16

fn div(self, rhs: u16x32) -> Self::Output

Divides the scalar left by each element of right.

Note that because division has no hardware support, this operation is very slow and should be avoided if possible.

Panics

Panics if any element of right is zero.

type Output = u16x32

The resulting type after applying the / operator.

impl Div<u16x32> for &u16x32

fn div(self, rhs: u16x32) -> Self::Output

Divides each element of left by the corresponding element right.

Note that because division has no hardware support, this operation is very slow and should be avoided if possible.

Panics

Panics if any element of right is zero.

type Output = u16x32

The resulting type after applying the / operator.

impl Div<u16x32> for &u16

fn div(self, rhs: u16x32) -> Self::Output

Divides the scalar left by each element of right.

Note that because division has no hardware support, this operation is very slow and should be avoided if possible.

Panics

Panics if any element of right is zero.

type Output = u16x32

The resulting type after applying the / operator.

impl DivAssign for u16x32

fn div_assign(&mut self, rhs: Self)

Divides each element of left by the corresponding element right.

Note that because division has no hardware support, this operation is very slow and should be avoided if possible.

Panics

Panics if any element of right is zero.

impl DivAssign<&u16> for u16x32

fn div_assign(&mut self, rhs: &u16)

Divides each element of left by the scalar right.

Note that because division has no hardware support, this operation is very slow and should be avoided if possible.

Panics

Panics if right is zero.

impl DivAssign<&u16x32> for u16x32

fn div_assign(&mut self, rhs: &Self)

Divides each element of left by the corresponding element right.

Note that because division has no hardware support, this operation is very slow and should be avoided if possible.

Panics

Panics if any element of right is zero.

impl DivAssign<u16> for u16x32

fn div_assign(&mut self, rhs: u16)

Divides each element of left by the scalar right.

Note that because division has no hardware support, this operation is very slow and should be avoided if possible.

Panics

Panics if right is zero.

impl Eq for u16x32

impl From<&[u16]> for u16x32

fn from(value: &[u16]) -> Self

Converts a slice to a SIMD vector, filling in zeros if there are not enough elements, and panicking if there are too many elements.

Note that in the future, handling of too many elements may change.

impl From<[u16; 32]> for u16x32

fn from(arr: [u16; 32]) -> Self

Converts an array to a SIMD vector.

impl From<__m512i> for u16x32

Available on x86-64 only.

fn from(value: __m512i) -> Self

Converts a native intrinsics SIMD type to a high-level SIMD type.

impl From<u16> for u16x32

fn from(elem: u16) -> Self

Converts a single value to a SIMD vector by setting all elements to that value.

impl From<u16x32> for [u16; 32]

fn from(simd: u16x32) -> Self

Converts a SIMD vector to an array.

impl From<u16x32> for __m512i

Available on x86-64 only.

fn from(value: u16x32) -> Self

Converts a high-level SIMD type to a native intrinsics SIMD type.

impl LowerExp for u16x32

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

Formats the value using the given formatter.

impl LowerHex for u16x32

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

Formats the value using the given formatter.

impl Mul for u16x32

type Output = u16x32

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<&u16> for u16x32

type Output = u16x32

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<&u16> for &u16x32

type Output = u16x32

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<&u16x32> for u16x32

type Output = u16x32

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<&u16x32> for u16

type Output = u16x32

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<&u16x32> for &u16x32

type Output = u16x32

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<&u16x32> for &u16

type Output = u16x32

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<u16> for u16x32

type Output = u16x32

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<u16> for &u16x32

type Output = u16x32

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<u16x32> for u16

type Output = u16x32

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<u16x32> for &u16x32

type Output = u16x32

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<u16x32> for &u16

type Output = u16x32

The resulting type after applying the * operator.

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

Performs the * operation.

impl MulAssign for u16x32

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl MulAssign<&u16> for u16x32

fn mul_assign(&mut self, rhs: &u16)

Performs the *= operation.

impl MulAssign<&u16x32> for u16x32

fn mul_assign(&mut self, rhs: &Self)

Performs the *= operation.

impl MulAssign<u16> for u16x32

fn mul_assign(&mut self, rhs: u16)

Performs the *= operation.

impl Neg for u16x32

type Output = u16x32

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Neg for &u16x32

type Output = u16x32

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Not for u16x32

type Output = u16x32

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl Not for &u16x32

type Output = u16x32

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl Octal for u16x32

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

Formats the value using the given formatter.

impl PartialEq for u16x32

fn eq(&self, other: &u16x32) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Pod for u16x32

impl<Rhs> Product<Rhs> for u16x32

where u16x32: MulAssign<Rhs>,

fn product<I: Iterator<Item = Rhs>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by multiplying the items.

impl Rem for u16x32

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

Returns the remainder of each element of left divided by the corresponding element right.

Note that because division has no hardware support, this operation is very slow and should be avoided if possible.

Panics

Panics if any element of right is zero.

type Output = u16x32

The resulting type after applying the % operator.

impl Rem<&u16> for u16x32

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

Returns the remainder of each element of left divided by the scalar right.

Note that because division has no hardware support, this operation is very slow and should be avoided if possible.

Panics

Panics if right is zero.

type Output = u16x32

The resulting type after applying the % operator.

impl Rem<&u16> for &u16x32

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

Returns the remainder of each element of left divided by the scalar right.

Note that because division has no hardware support, this operation is very slow and should be avoided if possible.

Panics

Panics if right is zero.

type Output = u16x32

The resulting type after applying the % operator.

impl Rem<&u16x32> for u16x32

fn rem(self, rhs: &Self) -> Self::Output

Returns the remainder of each element of left divided by the corresponding element right.

Note that because division has no hardware support, this operation is very slow and should be avoided if possible.

Panics

Panics if any element of right is zero.

type Output = u16x32

The resulting type after applying the % operator.

impl Rem<&u16x32> for u16

fn rem(self, rhs: &u16x32) -> Self::Output

Returns the remainder of the scalar left divided by each element of right.

Note that because division has no hardware support, this operation is very slow and should be avoided if possible.

Panics

Panics if any element of right is zero.

type Output = u16x32

The resulting type after applying the % operator.

impl Rem<&u16x32> for &u16x32

fn rem(self, rhs: &u16x32) -> Self::Output

Returns the remainder of each element of left divided by the corresponding element right.

Note that because division has no hardware support, this operation is very slow and should be avoided if possible.

Panics

Panics if any element of right is zero.

type Output = u16x32

The resulting type after applying the % operator.

impl Rem<&u16x32> for &u16

fn rem(self, rhs: &u16x32) -> Self::Output

Returns the remainder of the scalar left divided by each element of right.

Note that because division has no hardware support, this operation is very slow and should be avoided if possible.

Panics

Panics if any element of right is zero.

type Output = u16x32

The resulting type after applying the % operator.

impl Rem<u16> for u16x32

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

Returns the remainder of each element of left divided by the scalar right.

Note that because division has no hardware support, this operation is very slow and should be avoided if possible.

Panics

Panics if right is zero.

type Output = u16x32

The resulting type after applying the % operator.

impl Rem<u16> for &u16x32

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

Returns the remainder of each element of left divided by the scalar right.

Note that because division has no hardware support, this operation is very slow and should be avoided if possible.

Panics

Panics if right is zero.

type Output = u16x32

The resulting type after applying the % operator.

impl Rem<u16x32> for u16

fn rem(self, rhs: u16x32) -> Self::Output

Returns the remainder of the scalar left divided by each element of right.

Note that because division has no hardware support, this operation is very slow and should be avoided if possible.

Panics

Panics if any element of right is zero.

type Output = u16x32

The resulting type after applying the % operator.

impl Rem<u16x32> for &u16x32

fn rem(self, rhs: u16x32) -> Self::Output

Returns the remainder of each element of left divided by the corresponding element right.

Note that because division has no hardware support, this operation is very slow and should be avoided if possible.

Panics

Panics if any element of right is zero.

type Output = u16x32

The resulting type after applying the % operator.

impl Rem<u16x32> for &u16

fn rem(self, rhs: u16x32) -> Self::Output

Returns the remainder of the scalar left divided by each element of right.

Note that because division has no hardware support, this operation is very slow and should be avoided if possible.

Panics

Panics if any element of right is zero.

type Output = u16x32

The resulting type after applying the % operator.

impl RemAssign for u16x32

fn rem_assign(&mut self, rhs: Self)

Returns the remainder of each element of left divided by the corresponding element right.

Note that because division has no hardware support, this operation is very slow and should be avoided if possible.

Panics

Panics if any element of right is zero.

impl RemAssign<&u16> for u16x32

fn rem_assign(&mut self, rhs: &u16)

Returns the remainder of each element of left divided by the scalar right.

Note that because division has no hardware support, this operation is very slow and should be avoided if possible.

Panics

Panics if right is zero.

impl RemAssign<&u16x32> for u16x32

fn rem_assign(&mut self, rhs: &Self)

Returns the remainder of each element of left divided by the corresponding element right.

Note that because division has no hardware support, this operation is very slow and should be avoided if possible.

Panics

Panics if any element of right is zero.

impl RemAssign<u16> for u16x32

fn rem_assign(&mut self, rhs: u16)

Returns the remainder of each element of left divided by the scalar right.

Note that because division has no hardware support, this operation is very slow and should be avoided if possible.

Panics

Panics if right is zero.

impl Select<i16x32> for u16x32

fn select(self, if_true: i16x32, if_false: i16x32) -> i16x32

Lanewise SIMD selection.

impl Select<u16x32> for i16x32

fn select(self, if_true: u16x32, if_false: u16x32) -> u16x32

Lanewise SIMD selection.

impl Select<u16x32> for u16x32

fn select(self, if_true: Self, if_false: Self) -> Self

Lanewise SIMD selection.

impl Shl for u16x32

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

Shifts left each element of self by the corresponding element of rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl, so consider using that instead.

type Output = u16x32

The resulting type after applying the << operator.

impl Shl<&i8> for u16x32

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

Shifts left each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the << operator.

impl Shl<&i8> for &u16x32

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

Shifts left each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the << operator.

impl Shl<&i16> for u16x32

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

Shifts left each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the << operator.

impl Shl<&i16> for &u16x32

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

Shifts left each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the << operator.

impl Shl<&i16x32> for u16x32

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

Shifts left each element of self by the corresponding element of rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl, so consider using that instead.

type Output = u16x32

The resulting type after applying the << operator.

impl Shl<&i16x32> for &u16x32

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

Shifts left each element of self by the corresponding element of rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl, so consider using that instead.

type Output = u16x32

The resulting type after applying the << operator.

impl Shl<&i32> for u16x32

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

Shifts left each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the << operator.

impl Shl<&i32> for &u16x32

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

Shifts left each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the << operator.

impl Shl<&i64> for u16x32

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

Shifts left each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the << operator.

impl Shl<&i64> for &u16x32

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

Shifts left each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the << operator.

impl Shl<&i128> for u16x32

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

Shifts left each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the << operator.

impl Shl<&i128> for &u16x32

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

Shifts left each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the << operator.

impl Shl<&isize> for u16x32

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

Shifts left each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the << operator.

impl Shl<&isize> for &u16x32

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

Shifts left each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the << operator.

impl Shl<&u8> for u16x32

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

Shifts left each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the << operator.

impl Shl<&u8> for &u16x32

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

Shifts left each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the << operator.

impl Shl<&u16> for u16x32

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

Shifts left each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the << operator.

impl Shl<&u16> for &u16x32

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

Shifts left each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the << operator.

impl Shl<&u16x32> for i16x32

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

Shifts left each element of self by the corresponding element of rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl, so consider using that instead.

type Output = i16x32

The resulting type after applying the << operator.

impl Shl<&u16x32> for i16

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

Shifts left the scalar self by each element of rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl, so consider using that instead.

type Output = i16x32

The resulting type after applying the << operator.

impl Shl<&u16x32> for &i16x32

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

Shifts left each element of self by the corresponding element of rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl, so consider using that instead.

type Output = i16x32

The resulting type after applying the << operator.

impl Shl<&u16x32> for &i16

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

Shifts left the scalar self by each element of rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl, so consider using that instead.

type Output = i16x32

The resulting type after applying the << operator.

impl Shl<&u16x32> for u16x32

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

Shifts left each element of self by the corresponding element of rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl, so consider using that instead.

type Output = u16x32

The resulting type after applying the << operator.

impl Shl<&u16x32> for u16

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

Shifts left the scalar self by each element of rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl, so consider using that instead.

type Output = u16x32

The resulting type after applying the << operator.

impl Shl<&u16x32> for &u16x32

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

Shifts left each element of self by the corresponding element of rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl, so consider using that instead.

type Output = u16x32

The resulting type after applying the << operator.

impl Shl<&u16x32> for &u16

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

Shifts left the scalar self by each element of rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl, so consider using that instead.

type Output = u16x32

The resulting type after applying the << operator.

impl Shl<&u32> for u16x32

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

Shifts left each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the << operator.

impl Shl<&u32> for &u16x32

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

Shifts left each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the << operator.

impl Shl<&u64> for u16x32

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

Shifts left each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the << operator.

impl Shl<&u64> for &u16x32

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

Shifts left each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the << operator.

impl Shl<&u128> for u16x32

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

Shifts left each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the << operator.

impl Shl<&u128> for &u16x32

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

Shifts left each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the << operator.

impl Shl<&usize> for u16x32

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

Shifts left each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the << operator.

impl Shl<&usize> for &u16x32

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

Shifts left each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the << operator.

impl Shl<i8> for u16x32

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

Shifts left each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the << operator.

impl Shl<i8> for &u16x32

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

Shifts left each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the << operator.

impl Shl<i16> for u16x32

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

Shifts left each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the << operator.

impl Shl<i16> for &u16x32

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

Shifts left each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the << operator.

impl Shl<i16x32> for u16x32

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

Shifts left each element of self by the corresponding element of rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl, so consider using that instead.

type Output = u16x32

The resulting type after applying the << operator.

impl Shl<i16x32> for &u16x32

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

Shifts left each element of self by the corresponding element of rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl, so consider using that instead.

type Output = u16x32

The resulting type after applying the << operator.

impl Shl<i32> for u16x32

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

Shifts left each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the << operator.

impl Shl<i32> for &u16x32

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

Shifts left each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the << operator.

impl Shl<i64> for u16x32

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

Shifts left each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the << operator.

impl Shl<i64> for &u16x32

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

Shifts left each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the << operator.

impl Shl<i128> for u16x32

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

Shifts left each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the << operator.

impl Shl<i128> for &u16x32

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

Shifts left each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the << operator.

impl Shl<isize> for u16x32

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

Shifts left each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the << operator.

impl Shl<isize> for &u16x32

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

Shifts left each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the << operator.

impl Shl<u8> for u16x32

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

Shifts left each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the << operator.

impl Shl<u8> for &u16x32

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

Shifts left each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the << operator.

impl Shl<u16> for u16x32

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

Shifts left each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the << operator.

impl Shl<u16> for &u16x32

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

Shifts left each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the << operator.

impl Shl<u16x32> for i16x32

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

Shifts left each element of self by the corresponding element of rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl, so consider using that instead.

type Output = i16x32

The resulting type after applying the << operator.

impl Shl<u16x32> for i16

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

Shifts left the scalar self by each element of rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl, so consider using that instead.

type Output = i16x32

The resulting type after applying the << operator.

impl Shl<u16x32> for &i16x32

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

Shifts left each element of self by the corresponding element of rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl, so consider using that instead.

type Output = i16x32

The resulting type after applying the << operator.

impl Shl<u16x32> for &i16

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

Shifts left the scalar self by each element of rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl, so consider using that instead.

type Output = i16x32

The resulting type after applying the << operator.

impl Shl<u16x32> for u16

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

Shifts left the scalar self by each element of rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl, so consider using that instead.

type Output = u16x32

The resulting type after applying the << operator.

impl Shl<u16x32> for &u16x32

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

Shifts left each element of self by the corresponding element of rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl, so consider using that instead.

type Output = u16x32

The resulting type after applying the << operator.

impl Shl<u16x32> for &u16

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

Shifts left the scalar self by each element of rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl, so consider using that instead.

type Output = u16x32

The resulting type after applying the << operator.

impl Shl<u32> for u16x32

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

Shifts left each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the << operator.

impl Shl<u32> for &u16x32

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

Shifts left each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the << operator.

impl Shl<u64> for u16x32

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

Shifts left each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the << operator.

impl Shl<u64> for &u16x32

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

Shifts left each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the << operator.

impl Shl<u128> for u16x32

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

Shifts left each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the << operator.

impl Shl<u128> for &u16x32

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

Shifts left each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the << operator.

impl Shl<usize> for u16x32

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

Shifts left each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the << operator.

impl Shl<usize> for &u16x32

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

Shifts left each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the << operator.

impl ShlAssign for u16x32

fn shl_assign(&mut self, rhs: u16x32)

Shifts left each element of self by the corresponding element of rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl, so consider using that instead.

impl ShlAssign<&i8> for u16x32

fn shl_assign(&mut self, rhs: &i8)

Shifts left each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl_scalar, so consider using that instead.

impl ShlAssign<&i16> for u16x32

fn shl_assign(&mut self, rhs: &i16)

Shifts left each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl_scalar, so consider using that instead.

impl ShlAssign<&i16x32> for u16x32

fn shl_assign(&mut self, rhs: &i16x32)

Shifts left each element of self by the corresponding element of rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl, so consider using that instead.

impl ShlAssign<&i32> for u16x32

fn shl_assign(&mut self, rhs: &i32)

Shifts left each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl_scalar, so consider using that instead.

impl ShlAssign<&i64> for u16x32

fn shl_assign(&mut self, rhs: &i64)

Shifts left each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl_scalar, so consider using that instead.

impl ShlAssign<&i128> for u16x32

fn shl_assign(&mut self, rhs: &i128)

Shifts left each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl_scalar, so consider using that instead.

impl ShlAssign<&isize> for u16x32

fn shl_assign(&mut self, rhs: &isize)

Shifts left each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl_scalar, so consider using that instead.

impl ShlAssign<&u8> for u16x32

fn shl_assign(&mut self, rhs: &u8)

Shifts left each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl_scalar, so consider using that instead.

impl ShlAssign<&u16> for u16x32

fn shl_assign(&mut self, rhs: &u16)

Shifts left each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl_scalar, so consider using that instead.

impl ShlAssign<&u16x32> for i16x32

fn shl_assign(&mut self, rhs: &u16x32)

Shifts left each element of self by the corresponding element of rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl, so consider using that instead.

impl ShlAssign<&u16x32> for u16x32

fn shl_assign(&mut self, rhs: &u16x32)

Shifts left each element of self by the corresponding element of rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl, so consider using that instead.

impl ShlAssign<&u32> for u16x32

fn shl_assign(&mut self, rhs: &u32)

Shifts left each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl_scalar, so consider using that instead.

impl ShlAssign<&u64> for u16x32

fn shl_assign(&mut self, rhs: &u64)

Shifts left each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl_scalar, so consider using that instead.

impl ShlAssign<&u128> for u16x32

fn shl_assign(&mut self, rhs: &u128)

Shifts left each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl_scalar, so consider using that instead.

impl ShlAssign<&usize> for u16x32

fn shl_assign(&mut self, rhs: &usize)

Shifts left each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl_scalar, so consider using that instead.

impl ShlAssign<i8> for u16x32

fn shl_assign(&mut self, rhs: i8)

Shifts left each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl_scalar, so consider using that instead.

impl ShlAssign<i16> for u16x32

fn shl_assign(&mut self, rhs: i16)

Shifts left each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl_scalar, so consider using that instead.

impl ShlAssign<i16x32> for u16x32

fn shl_assign(&mut self, rhs: i16x32)

Shifts left each element of self by the corresponding element of rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl, so consider using that instead.

impl ShlAssign<i32> for u16x32

fn shl_assign(&mut self, rhs: i32)

Shifts left each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl_scalar, so consider using that instead.

impl ShlAssign<i64> for u16x32

fn shl_assign(&mut self, rhs: i64)

Shifts left each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl_scalar, so consider using that instead.

impl ShlAssign<i128> for u16x32

fn shl_assign(&mut self, rhs: i128)

Shifts left each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl_scalar, so consider using that instead.

impl ShlAssign<isize> for u16x32

fn shl_assign(&mut self, rhs: isize)

Shifts left each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl_scalar, so consider using that instead.

impl ShlAssign<u8> for u16x32

fn shl_assign(&mut self, rhs: u8)

Shifts left each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl_scalar, so consider using that instead.

impl ShlAssign<u16> for u16x32

fn shl_assign(&mut self, rhs: u16)

Shifts left each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl_scalar, so consider using that instead.

impl ShlAssign<u16x32> for i16x32

fn shl_assign(&mut self, rhs: u16x32)

Shifts left each element of self by the corresponding element of rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl, so consider using that instead.

impl ShlAssign<u32> for u16x32

fn shl_assign(&mut self, rhs: u32)

Shifts left each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl_scalar, so consider using that instead.

impl ShlAssign<u64> for u16x32

fn shl_assign(&mut self, rhs: u64)

Shifts left each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl_scalar, so consider using that instead.

impl ShlAssign<u128> for u16x32

fn shl_assign(&mut self, rhs: u128)

Shifts left each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl_scalar, so consider using that instead.

impl ShlAssign<usize> for u16x32

fn shl_assign(&mut self, rhs: usize)

Shifts left each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shl.

Note that for most targets, this operator is slower than unbounded_shl_scalar, so consider using that instead.

impl Shr for u16x32

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

Shifts right each element of self by the corresponding element of rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr, so consider using that instead.

type Output = u16x32

The resulting type after applying the >> operator.

impl Shr<&i8> for u16x32

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

Shifts right each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the >> operator.

impl Shr<&i8> for &u16x32

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

Shifts right each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the >> operator.

impl Shr<&i16> for u16x32

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

Shifts right each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the >> operator.

impl Shr<&i16> for &u16x32

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

Shifts right each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the >> operator.

impl Shr<&i16x32> for u16x32

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

Shifts right each element of self by the corresponding element of rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr, so consider using that instead.

type Output = u16x32

The resulting type after applying the >> operator.

impl Shr<&i16x32> for &u16x32

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

Shifts right each element of self by the corresponding element of rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr, so consider using that instead.

type Output = u16x32

The resulting type after applying the >> operator.

impl Shr<&i32> for u16x32

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

Shifts right each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the >> operator.

impl Shr<&i32> for &u16x32

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

Shifts right each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the >> operator.

impl Shr<&i64> for u16x32

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

Shifts right each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the >> operator.

impl Shr<&i64> for &u16x32

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

Shifts right each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the >> operator.

impl Shr<&i128> for u16x32

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

Shifts right each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the >> operator.

impl Shr<&i128> for &u16x32

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

Shifts right each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the >> operator.

impl Shr<&isize> for u16x32

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

Shifts right each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the >> operator.

impl Shr<&isize> for &u16x32

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

Shifts right each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the >> operator.

impl Shr<&u8> for u16x32

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

Shifts right each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the >> operator.

impl Shr<&u8> for &u16x32

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

Shifts right each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the >> operator.

impl Shr<&u16> for u16x32

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

Shifts right each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the >> operator.

impl Shr<&u16> for &u16x32

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

Shifts right each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the >> operator.

impl Shr<&u16x32> for i16x32

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

Shifts right each element of self by the corresponding element of rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr, so consider using that instead.

type Output = i16x32

The resulting type after applying the >> operator.

impl Shr<&u16x32> for i16

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

Shifts right the scalar self by each element of rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr, so consider using that instead.

type Output = i16x32

The resulting type after applying the >> operator.

impl Shr<&u16x32> for &i16x32

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

Shifts right each element of self by the corresponding element of rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr, so consider using that instead.

type Output = i16x32

The resulting type after applying the >> operator.

impl Shr<&u16x32> for &i16

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

Shifts right the scalar self by each element of rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr, so consider using that instead.

type Output = i16x32

The resulting type after applying the >> operator.

impl Shr<&u16x32> for u16x32

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

Shifts right each element of self by the corresponding element of rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr, so consider using that instead.

type Output = u16x32

The resulting type after applying the >> operator.

impl Shr<&u16x32> for u16

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

Shifts right the scalar self by each element of rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr, so consider using that instead.

type Output = u16x32

The resulting type after applying the >> operator.

impl Shr<&u16x32> for &u16x32

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

Shifts right each element of self by the corresponding element of rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr, so consider using that instead.

type Output = u16x32

The resulting type after applying the >> operator.

impl Shr<&u16x32> for &u16

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

Shifts right the scalar self by each element of rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr, so consider using that instead.

type Output = u16x32

The resulting type after applying the >> operator.

impl Shr<&u32> for u16x32

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

Shifts right each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the >> operator.

impl Shr<&u32> for &u16x32

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

Shifts right each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the >> operator.

impl Shr<&u64> for u16x32

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

Shifts right each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the >> operator.

impl Shr<&u64> for &u16x32

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

Shifts right each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the >> operator.

impl Shr<&u128> for u16x32

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

Shifts right each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the >> operator.

impl Shr<&u128> for &u16x32

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

Shifts right each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the >> operator.

impl Shr<&usize> for u16x32

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

Shifts right each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the >> operator.

impl Shr<&usize> for &u16x32

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

Shifts right each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the >> operator.

impl Shr<i8> for u16x32

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

Shifts right each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the >> operator.

impl Shr<i8> for &u16x32

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

Shifts right each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the >> operator.

impl Shr<i16> for u16x32

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

Shifts right each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the >> operator.

impl Shr<i16> for &u16x32

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

Shifts right each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the >> operator.

impl Shr<i16x32> for u16x32

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

Shifts right each element of self by the corresponding element of rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr, so consider using that instead.

type Output = u16x32

The resulting type after applying the >> operator.

impl Shr<i16x32> for &u16x32

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

Shifts right each element of self by the corresponding element of rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr, so consider using that instead.

type Output = u16x32

The resulting type after applying the >> operator.

impl Shr<i32> for u16x32

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

Shifts right each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the >> operator.

impl Shr<i32> for &u16x32

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

Shifts right each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the >> operator.

impl Shr<i64> for u16x32

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

Shifts right each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the >> operator.

impl Shr<i64> for &u16x32

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

Shifts right each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the >> operator.

impl Shr<i128> for u16x32

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

Shifts right each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the >> operator.

impl Shr<i128> for &u16x32

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

Shifts right each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the >> operator.

impl Shr<isize> for u16x32

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

Shifts right each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the >> operator.

impl Shr<isize> for &u16x32

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

Shifts right each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the >> operator.

impl Shr<u8> for u16x32

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

Shifts right each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the >> operator.

impl Shr<u8> for &u16x32

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

Shifts right each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the >> operator.

impl Shr<u16> for u16x32

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

Shifts right each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the >> operator.

impl Shr<u16> for &u16x32

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

Shifts right each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the >> operator.

impl Shr<u16x32> for i16x32

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

Shifts right each element of self by the corresponding element of rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr, so consider using that instead.

type Output = i16x32

The resulting type after applying the >> operator.

impl Shr<u16x32> for i16

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

Shifts right the scalar self by each element of rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr, so consider using that instead.

type Output = i16x32

The resulting type after applying the >> operator.

impl Shr<u16x32> for &i16x32

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

Shifts right each element of self by the corresponding element of rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr, so consider using that instead.

type Output = i16x32

The resulting type after applying the >> operator.

impl Shr<u16x32> for &i16

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

Shifts right the scalar self by each element of rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr, so consider using that instead.

type Output = i16x32

The resulting type after applying the >> operator.

impl Shr<u16x32> for u16

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

Shifts right the scalar self by each element of rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr, so consider using that instead.

type Output = u16x32

The resulting type after applying the >> operator.

impl Shr<u16x32> for &u16x32

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

Shifts right each element of self by the corresponding element of rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr, so consider using that instead.

type Output = u16x32

The resulting type after applying the >> operator.

impl Shr<u16x32> for &u16

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

Shifts right the scalar self by each element of rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr, so consider using that instead.

type Output = u16x32

The resulting type after applying the >> operator.

impl Shr<u32> for u16x32

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

Shifts right each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the >> operator.

impl Shr<u32> for &u16x32

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

Shifts right each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the >> operator.

impl Shr<u64> for u16x32

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

Shifts right each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the >> operator.

impl Shr<u64> for &u16x32

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

Shifts right each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the >> operator.

impl Shr<u128> for u16x32

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

Shifts right each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the >> operator.

impl Shr<u128> for &u16x32

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

Shifts right each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the >> operator.

impl Shr<usize> for u16x32

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

Shifts right each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the >> operator.

impl Shr<usize> for &u16x32

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

Shifts right each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr_scalar, so consider using that instead.

type Output = u16x32

The resulting type after applying the >> operator.

impl ShrAssign for u16x32

fn shr_assign(&mut self, rhs: u16x32)

Shifts right each element of self by the corresponding element of rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr, so consider using that instead.

impl ShrAssign<&i8> for u16x32

fn shr_assign(&mut self, rhs: &i8)

Shifts right each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr_scalar, so consider using that instead.

impl ShrAssign<&i16> for u16x32

fn shr_assign(&mut self, rhs: &i16)

Shifts right each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr_scalar, so consider using that instead.

impl ShrAssign<&i16x32> for u16x32

fn shr_assign(&mut self, rhs: &i16x32)

Shifts right each element of self by the corresponding element of rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr, so consider using that instead.

impl ShrAssign<&i32> for u16x32

fn shr_assign(&mut self, rhs: &i32)

Shifts right each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr_scalar, so consider using that instead.

impl ShrAssign<&i64> for u16x32

fn shr_assign(&mut self, rhs: &i64)

Shifts right each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr_scalar, so consider using that instead.

impl ShrAssign<&i128> for u16x32

fn shr_assign(&mut self, rhs: &i128)

Shifts right each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr_scalar, so consider using that instead.

impl ShrAssign<&isize> for u16x32

fn shr_assign(&mut self, rhs: &isize)

Shifts right each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr_scalar, so consider using that instead.

impl ShrAssign<&u8> for u16x32

fn shr_assign(&mut self, rhs: &u8)

Shifts right each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr_scalar, so consider using that instead.

impl ShrAssign<&u16> for u16x32

fn shr_assign(&mut self, rhs: &u16)

Shifts right each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr_scalar, so consider using that instead.

impl ShrAssign<&u16x32> for i16x32

fn shr_assign(&mut self, rhs: &u16x32)

Shifts right each element of self by the corresponding element of rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr, so consider using that instead.

impl ShrAssign<&u16x32> for u16x32

fn shr_assign(&mut self, rhs: &u16x32)

Shifts right each element of self by the corresponding element of rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr, so consider using that instead.

impl ShrAssign<&u32> for u16x32

fn shr_assign(&mut self, rhs: &u32)

Shifts right each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr_scalar, so consider using that instead.

impl ShrAssign<&u64> for u16x32

fn shr_assign(&mut self, rhs: &u64)

Shifts right each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr_scalar, so consider using that instead.

impl ShrAssign<&u128> for u16x32

fn shr_assign(&mut self, rhs: &u128)

Shifts right each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr_scalar, so consider using that instead.

impl ShrAssign<&usize> for u16x32

fn shr_assign(&mut self, rhs: &usize)

Shifts right each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr_scalar, so consider using that instead.

impl ShrAssign<i8> for u16x32

fn shr_assign(&mut self, rhs: i8)

Shifts right each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr_scalar, so consider using that instead.

impl ShrAssign<i16> for u16x32

fn shr_assign(&mut self, rhs: i16)

Shifts right each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr_scalar, so consider using that instead.

impl ShrAssign<i16x32> for u16x32

fn shr_assign(&mut self, rhs: i16x32)

Shifts right each element of self by the corresponding element of rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr, so consider using that instead.

impl ShrAssign<i32> for u16x32

fn shr_assign(&mut self, rhs: i32)

Shifts right each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr_scalar, so consider using that instead.

impl ShrAssign<i64> for u16x32

fn shr_assign(&mut self, rhs: i64)

Shifts right each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr_scalar, so consider using that instead.

impl ShrAssign<i128> for u16x32

fn shr_assign(&mut self, rhs: i128)

Shifts right each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr_scalar, so consider using that instead.

impl ShrAssign<isize> for u16x32

fn shr_assign(&mut self, rhs: isize)

Shifts right each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr_scalar, so consider using that instead.

impl ShrAssign<u8> for u16x32

fn shr_assign(&mut self, rhs: u8)

Shifts right each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr_scalar, so consider using that instead.

impl ShrAssign<u16> for u16x32

fn shr_assign(&mut self, rhs: u16)

Shifts right each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr_scalar, so consider using that instead.

impl ShrAssign<u16x32> for i16x32

fn shr_assign(&mut self, rhs: u16x32)

Shifts right each element of self by the corresponding element of rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr, so consider using that instead.

impl ShrAssign<u32> for u16x32

fn shr_assign(&mut self, rhs: u32)

Shifts right each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr_scalar, so consider using that instead.

impl ShrAssign<u64> for u16x32

fn shr_assign(&mut self, rhs: u64)

Shifts right each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr_scalar, so consider using that instead.

impl ShrAssign<u128> for u16x32

fn shr_assign(&mut self, rhs: u128)

Shifts right each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr_scalar, so consider using that instead.

impl ShrAssign<usize> for u16x32

fn shr_assign(&mut self, rhs: usize)

Shifts right each element of self by the uniform scalar rhs.

This operator behaves like wrapping_shr.

Note that for most targets, this operator is slower than unbounded_shr_scalar, so consider using that instead.

impl StructuralPartialEq for u16x32

impl Sub for u16x32

type Output = u16x32

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<&u16> for u16x32

type Output = u16x32

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<&u16> for &u16x32

type Output = u16x32

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<&u16x32> for u16x32

type Output = u16x32

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<&u16x32> for u16

type Output = u16x32

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<&u16x32> for &u16x32

type Output = u16x32

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<&u16x32> for &u16

type Output = u16x32

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<u16> for u16x32

type Output = u16x32

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<u16> for &u16x32

type Output = u16x32

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<u16x32> for u16

type Output = u16x32

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<u16x32> for &u16x32

type Output = u16x32

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<u16x32> for &u16

type Output = u16x32

The resulting type after applying the - operator.

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

Performs the - operation.

impl SubAssign for u16x32

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl SubAssign<&u16> for u16x32

fn sub_assign(&mut self, rhs: &u16)

Performs the -= operation.

impl SubAssign<&u16x32> for u16x32

fn sub_assign(&mut self, rhs: &Self)

Performs the -= operation.

impl SubAssign<u16> for u16x32

fn sub_assign(&mut self, rhs: u16)

Performs the -= operation.

impl<Rhs> Sum<Rhs> for u16x32

where u16x32: AddAssign<Rhs>,

fn sum<I: Iterator<Item = Rhs>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by “summing up” the items.

impl UpperExp for u16x32

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

Formats the value using the given formatter.

impl UpperHex for u16x32

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

Formats the value using the given formatter.

impl Zeroable for u16x32

fn zeroed() -> Self

Calls zeroed.