Struct u32x4 

pub struct u32x4 { /* private fields */ }

A SIMD vector with four elements of type u32.

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

Implementations

impl u32x4

The following functionality exists for all SIMD vectors.

pub const fn new(array: [u32; 4]) -> Self

Converts an array to a SIMD vector.

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

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

pub const fn to_array(self) -> [u32; 4]

Converts a SIMD vector to an array.

pub const fn as_array(&self) -> &[u32; 4]

Returns an array reference containing the entire SIMD vector.

pub const fn as_mut_array(&mut self) -> &mut [u32; 4]

Returns a mutable array reference containing the entire SIMD vector.

pub const fn from_ne_bytes(bytes: [u8; 16]) -> 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; 16]

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) -> u32

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

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

pub fn reduce_mul(self) -> u32

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: u32x4) -> 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: u32x4) -> 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: u32x4) -> 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; 4]) -> [Self; 4]

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

Currently this function is only accelerated on sse.

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 u32x4

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 u32::MAX.

pub const MIN: Self

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

pub const LANES: u16 = 4

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) -> u32

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

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

pub fn reduce_min(self) -> u32

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

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

pub const fn cast_signed(self) -> i32x4

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 u32, 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 u32, 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 u32, 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 u32, 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 widening_mul(self, rhs: Self) -> u64x4

Widening multiplication. Computes self * rhs, widening to a SIMD vector of a larger integer type.

The returned value is always exact and can never overflow.

This function is different from mul_keep_low_high, which returns two seperate SIMD vectors for low and high parts, instead of a single SIMD vector of a larger integer type. 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_low_high(self, rhs: Self) -> (Self, Self)

Computes self * rhs, producing intermediate 64-bit integers, then returns their low 32-bit parts and high 32-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 64-bit integers, then returns their high 32-bit parts.

impl u32x4

The following functionality exists only for u32x4, or only for particular types inconsistently.

pub fn mul_widen(self, rhs: Self) -> u64x4

👎Deprecated since 1.6.0:

renamed to widening_mul

Widening multiplication. Computes self * rhs, widening to a SIMD vector of larger integers.

The returned value is always exact and can never overflow.

This function has been renamed to widening_mul.

pub fn unpack_lo(self, b: Self) -> Self

Returns [self[0], b[0], self[1], b[1]], interleaving the low two elements of the 128-bit lane.

pub fn unpack_hi(self, b: Self) -> Self

Returns [self[2], b[2], self[3], b[3]], interleaving the high two elements of the 128-bit lane.

pub fn add_mul_lo<const W: u32>(self, a: Self, b: Self) -> Self

self + ((a * b) mod 2^W), reading only the low W bits of each lane of a and b. W must be in 1..=32.

There is no IFMA equivalent at this width, and below 17 bits no widening multiply is needed either: the whole product fits a lane, so the ordinary lane multiply already yields both halves.

pub fn add_mul_hi<const W: u32>(self, a: Self, b: Self) -> Self

self + ((a * b) >> W), reading only the low W bits of each lane of a and b. W must be in 1..=32.

Trait Implementations

impl Add for u32x4

type Output = u32x4

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<&u32> for u32x4

type Output = u32x4

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<&u32> for &u32x4

type Output = u32x4

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<&u32x4> for u32x4

type Output = u32x4

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<&u32x4> for u32

type Output = u32x4

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<&u32x4> for &u32x4

type Output = u32x4

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<&u32x4> for &u32

type Output = u32x4

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<u32> for u32x4

type Output = u32x4

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<u32> for &u32x4

type Output = u32x4

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<u32x4> for u32

type Output = u32x4

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<u32x4> for &u32x4

type Output = u32x4

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<u32x4> for &u32

type Output = u32x4

The resulting type after applying the + operator.

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

Performs the + operation.

impl AddAssign for u32x4

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl AddAssign<&u32> for u32x4

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

Performs the += operation.

impl AddAssign<&u32x4> for u32x4

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

Performs the += operation.

impl AddAssign<u32> for u32x4

fn add_assign(&mut self, rhs: u32)

Performs the += operation.

impl AlignTo for u32x4

type Elem = u32

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 u32x4

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

Formats the value using the given formatter.

impl BitAnd for u32x4

type Output = u32x4

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<&u32> for u32x4

type Output = u32x4

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<&u32> for &u32x4

type Output = u32x4

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<&u32x4> for u32x4

type Output = u32x4

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<&u32x4> for u32

type Output = u32x4

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<&u32x4> for &u32x4

type Output = u32x4

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<&u32x4> for &u32

type Output = u32x4

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<u32> for u32x4

type Output = u32x4

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<u32> for &u32x4

type Output = u32x4

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<u32x4> for u32

type Output = u32x4

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<u32x4> for &u32x4

type Output = u32x4

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<u32x4> for &u32

type Output = u32x4

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAndAssign for u32x4

fn bitand_assign(&mut self, rhs: Self)

Performs the &= operation.

impl BitAndAssign<&u32> for u32x4

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

Performs the &= operation.

impl BitAndAssign<&u32x4> for u32x4

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

Performs the &= operation.

impl BitAndAssign<u32> for u32x4

fn bitand_assign(&mut self, rhs: u32)

Performs the &= operation.

impl BitOr for u32x4

type Output = u32x4

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<&u32> for u32x4

type Output = u32x4

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<&u32> for &u32x4

type Output = u32x4

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<&u32x4> for u32x4

type Output = u32x4

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<&u32x4> for u32

type Output = u32x4

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<&u32x4> for &u32x4

type Output = u32x4

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<&u32x4> for &u32

type Output = u32x4

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<u32> for u32x4

type Output = u32x4

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<u32> for &u32x4

type Output = u32x4

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<u32x4> for u32

type Output = u32x4

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<u32x4> for &u32x4

type Output = u32x4

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<u32x4> for &u32

type Output = u32x4

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOrAssign for u32x4

fn bitor_assign(&mut self, rhs: Self)

Performs the |= operation.

impl BitOrAssign<&u32> for u32x4

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

Performs the |= operation.

impl BitOrAssign<&u32x4> for u32x4

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

Performs the |= operation.

impl BitOrAssign<u32> for u32x4

fn bitor_assign(&mut self, rhs: u32)

Performs the |= operation.

impl BitXor for u32x4

type Output = u32x4

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<&u32> for u32x4

type Output = u32x4

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<&u32> for &u32x4

type Output = u32x4

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<&u32x4> for u32x4

type Output = u32x4

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<&u32x4> for u32

type Output = u32x4

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<&u32x4> for &u32x4

type Output = u32x4

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<&u32x4> for &u32

type Output = u32x4

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<u32> for u32x4

type Output = u32x4

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<u32> for &u32x4

type Output = u32x4

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<u32x4> for u32

type Output = u32x4

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<u32x4> for &u32x4

type Output = u32x4

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<u32x4> for &u32

type Output = u32x4

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXorAssign for u32x4

fn bitxor_assign(&mut self, rhs: Self)

Performs the ^= operation.

impl BitXorAssign<&u32> for u32x4

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

Performs the ^= operation.

impl BitXorAssign<&u32x4> for u32x4

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

Performs the ^= operation.

impl BitXorAssign<u32> for u32x4

fn bitxor_assign(&mut self, rhs: u32)

Performs the ^= operation.

impl Clone for u32x4

fn clone(&self) -> u32x4

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl CmpEq for u32x4

type Output = u32x4

👎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<u32> for u32x4

type Output = u32x4

👎Deprecated since 1.5.0:

use the inherent function simd_eq instead

The type returned by simd_eq.

fn simd_eq(self, rhs: u32) -> 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 u32x4

type Output = u32x4

👎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<u32> for u32x4

type Output = u32x4

👎Deprecated since 1.5.0:

use the inherent function simd_ge instead

The type returned by simd_ge.

fn simd_ge(self, rhs: u32) -> 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 u32x4

type Output = u32x4

👎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<u32> for u32x4

type Output = u32x4

👎Deprecated since 1.5.0:

use the inherent function simd_gt instead

The type returned by simd_gt.

fn simd_gt(self, rhs: u32) -> 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 u32x4

type Output = u32x4

👎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<u32> for u32x4

type Output = u32x4

👎Deprecated since 1.5.0:

use the inherent function simd_le instead

The type returned by simd_le.

fn simd_le(self, rhs: u32) -> 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 u32x4

type Output = u32x4

👎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<u32> for u32x4

type Output = u32x4

👎Deprecated since 1.5.0:

use the inherent function simd_lt instead

The type returned by simd_lt.

fn simd_lt(self, rhs: u32) -> 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 u32x4

type Output = u32x4

👎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<u32> for u32x4

type Output = u32x4

👎Deprecated since 1.5.0:

use the inherent function simd_ne instead

The type returned by simd_ne.

fn simd_ne(self, rhs: u32) -> 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 u32x4

impl Debug for u32x4

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

Formats the value using the given formatter.

impl Default for u32x4

fn default() -> u32x4

Returns the “default value” for a type.

impl Display for u32x4

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

Formats the value using the given formatter.

impl Div for u32x4

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 = u32x4

The resulting type after applying the / operator.

impl Div<&u32> for u32x4

fn div(self, rhs: &u32) -> 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 = u32x4

The resulting type after applying the / operator.

impl Div<&u32> for &u32x4

fn div(self, rhs: &u32) -> 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 = u32x4

The resulting type after applying the / operator.

impl Div<&u32x4> for u32x4

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 = u32x4

The resulting type after applying the / operator.

impl Div<&u32x4> for u32

fn div(self, rhs: &u32x4) -> 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 = u32x4

The resulting type after applying the / operator.

impl Div<&u32x4> for &u32x4

fn div(self, rhs: &u32x4) -> 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 = u32x4

The resulting type after applying the / operator.

impl Div<&u32x4> for &u32

fn div(self, rhs: &u32x4) -> 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 = u32x4

The resulting type after applying the / operator.

impl Div<u32> for u32x4

fn div(self, rhs: u32) -> 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 = u32x4

The resulting type after applying the / operator.

impl Div<u32> for &u32x4

fn div(self, rhs: u32) -> 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 = u32x4

The resulting type after applying the / operator.

impl Div<u32x4> for u32

fn div(self, rhs: u32x4) -> 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 = u32x4

The resulting type after applying the / operator.

impl Div<u32x4> for &u32x4

fn div(self, rhs: u32x4) -> 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 = u32x4

The resulting type after applying the / operator.

impl Div<u32x4> for &u32

fn div(self, rhs: u32x4) -> 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 = u32x4

The resulting type after applying the / operator.

impl DivAssign for u32x4

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<&u32> for u32x4

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

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<&u32x4> for u32x4

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<u32> for u32x4

fn div_assign(&mut self, rhs: u32)

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 u32x4

impl From<&[u32]> for u32x4

fn from(value: &[u32]) -> 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<[u32; 4]> for u32x4

fn from(arr: [u32; 4]) -> Self

Converts an array to a SIMD vector.

impl From<__m128i> for u32x4

Available on x86-64 only.

fn from(value: __m128i) -> Self

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

impl From<u32> for u32x4

fn from(elem: u32) -> Self

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

impl From<u32x4> for [u32; 4]

fn from(simd: u32x4) -> Self

Converts a SIMD vector to an array.

impl From<u32x4> for __m128i

Available on x86-64 only.

fn from(value: u32x4) -> Self

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

impl LowerExp for u32x4

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

Formats the value using the given formatter.

impl LowerHex for u32x4

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

Formats the value using the given formatter.

impl Mul for u32x4

type Output = u32x4

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<&u32> for u32x4

type Output = u32x4

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<&u32> for &u32x4

type Output = u32x4

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<&u32x4> for u32x4

type Output = u32x4

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<&u32x4> for u32

type Output = u32x4

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<&u32x4> for &u32x4

type Output = u32x4

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<&u32x4> for &u32

type Output = u32x4

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<u32> for u32x4

type Output = u32x4

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<u32> for &u32x4

type Output = u32x4

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<u32x4> for u32

type Output = u32x4

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<u32x4> for &u32x4

type Output = u32x4

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<u32x4> for &u32

type Output = u32x4

The resulting type after applying the * operator.

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

Performs the * operation.

impl MulAssign for u32x4

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl MulAssign<&u32> for u32x4

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

Performs the *= operation.

impl MulAssign<&u32x4> for u32x4

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

Performs the *= operation.

impl MulAssign<u32> for u32x4

fn mul_assign(&mut self, rhs: u32)

Performs the *= operation.

impl Neg for u32x4

type Output = u32x4

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Neg for &u32x4

type Output = u32x4

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Not for u32x4

type Output = u32x4

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl Not for &u32x4

type Output = u32x4

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl Octal for u32x4

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

Formats the value using the given formatter.

impl PartialEq for u32x4

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

Equality operator ==.

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

Inequality operator !=.

impl Pod for u32x4

impl<Rhs> Product<Rhs> for u32x4

where u32x4: 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 u32x4

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 = u32x4

The resulting type after applying the % operator.

impl Rem<&u32> for u32x4

fn rem(self, rhs: &u32) -> 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 = u32x4

The resulting type after applying the % operator.

impl Rem<&u32> for &u32x4

fn rem(self, rhs: &u32) -> 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 = u32x4

The resulting type after applying the % operator.

impl Rem<&u32x4> for u32x4

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 = u32x4

The resulting type after applying the % operator.

impl Rem<&u32x4> for u32

fn rem(self, rhs: &u32x4) -> 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 = u32x4

The resulting type after applying the % operator.

impl Rem<&u32x4> for &u32x4

fn rem(self, rhs: &u32x4) -> 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 = u32x4

The resulting type after applying the % operator.

impl Rem<&u32x4> for &u32

fn rem(self, rhs: &u32x4) -> 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 = u32x4

The resulting type after applying the % operator.

impl Rem<u32> for u32x4

fn rem(self, rhs: u32) -> 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 = u32x4

The resulting type after applying the % operator.

impl Rem<u32> for &u32x4

fn rem(self, rhs: u32) -> 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 = u32x4

The resulting type after applying the % operator.

impl Rem<u32x4> for u32

fn rem(self, rhs: u32x4) -> 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 = u32x4

The resulting type after applying the % operator.

impl Rem<u32x4> for &u32x4

fn rem(self, rhs: u32x4) -> 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 = u32x4

The resulting type after applying the % operator.

impl Rem<u32x4> for &u32

fn rem(self, rhs: u32x4) -> 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 = u32x4

The resulting type after applying the % operator.

impl RemAssign for u32x4

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<&u32> for u32x4

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

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<&u32x4> for u32x4

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<u32> for u32x4

fn rem_assign(&mut self, rhs: u32)

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<f32x4> for u32x4

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

Lanewise SIMD selection.

impl Select<i32x4> for u32x4

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

Lanewise SIMD selection.

impl Select<u32x4> for f32x4

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

Lanewise SIMD selection.

impl Select<u32x4> for i32x4

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

Lanewise SIMD selection.

impl Select<u32x4> for u32x4

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

Lanewise SIMD selection.

impl Shl for u32x4

fn shl(self, rhs: u32x4) -> 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 = u32x4

The resulting type after applying the << operator.

impl Shl<&i8> for u32x4

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 = u32x4

The resulting type after applying the << operator.

impl Shl<&i8> for &u32x4

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 = u32x4

The resulting type after applying the << operator.

impl Shl<&i16> for u32x4

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 = u32x4

The resulting type after applying the << operator.

impl Shl<&i16> for &u32x4

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 = u32x4

The resulting type after applying the << operator.

impl Shl<&i32> for u32x4

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 = u32x4

The resulting type after applying the << operator.

impl Shl<&i32> for &u32x4

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 = u32x4

The resulting type after applying the << operator.

impl Shl<&i32x4> for u32x4

fn shl(self, rhs: &i32x4) -> 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 = u32x4

The resulting type after applying the << operator.

impl Shl<&i32x4> for &u32x4

fn shl(self, rhs: &i32x4) -> 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 = u32x4

The resulting type after applying the << operator.

impl Shl<&i64> for u32x4

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 = u32x4

The resulting type after applying the << operator.

impl Shl<&i64> for &u32x4

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 = u32x4

The resulting type after applying the << operator.

impl Shl<&i128> for u32x4

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 = u32x4

The resulting type after applying the << operator.

impl Shl<&i128> for &u32x4

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 = u32x4

The resulting type after applying the << operator.

impl Shl<&isize> for u32x4

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 = u32x4

The resulting type after applying the << operator.

impl Shl<&isize> for &u32x4

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 = u32x4

The resulting type after applying the << operator.

impl Shl<&u8> for u32x4

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 = u32x4

The resulting type after applying the << operator.

impl Shl<&u8> for &u32x4

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 = u32x4

The resulting type after applying the << operator.

impl Shl<&u16> for u32x4

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 = u32x4

The resulting type after applying the << operator.

impl Shl<&u16> for &u32x4

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 = u32x4

The resulting type after applying the << operator.

impl Shl<&u32> for u32x4

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 = u32x4

The resulting type after applying the << operator.

impl Shl<&u32> for &u32x4

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 = u32x4

The resulting type after applying the << operator.

impl Shl<&u32x4> for i32x4

fn shl(self, rhs: &u32x4) -> 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 = i32x4

The resulting type after applying the << operator.

impl Shl<&u32x4> for i32

fn shl(self, rhs: &u32x4) -> 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 = i32x4

The resulting type after applying the << operator.

impl Shl<&u32x4> for &i32x4

fn shl(self, rhs: &u32x4) -> 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 = i32x4

The resulting type after applying the << operator.

impl Shl<&u32x4> for &i32

fn shl(self, rhs: &u32x4) -> 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 = i32x4

The resulting type after applying the << operator.

impl Shl<&u32x4> for u32x4

fn shl(self, rhs: &u32x4) -> 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 = u32x4

The resulting type after applying the << operator.

impl Shl<&u32x4> for u32

fn shl(self, rhs: &u32x4) -> 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 = u32x4

The resulting type after applying the << operator.

impl Shl<&u32x4> for &u32x4

fn shl(self, rhs: &u32x4) -> 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 = u32x4

The resulting type after applying the << operator.

impl Shl<&u32x4> for &u32

fn shl(self, rhs: &u32x4) -> 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 = u32x4

The resulting type after applying the << operator.

impl Shl<&u64> for u32x4

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 = u32x4

The resulting type after applying the << operator.

impl Shl<&u64> for &u32x4

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 = u32x4

The resulting type after applying the << operator.

impl Shl<&u128> for u32x4

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 = u32x4

The resulting type after applying the << operator.

impl Shl<&u128> for &u32x4

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 = u32x4

The resulting type after applying the << operator.

impl Shl<&usize> for u32x4

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 = u32x4

The resulting type after applying the << operator.

impl Shl<&usize> for &u32x4

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 = u32x4

The resulting type after applying the << operator.

impl Shl<i8> for u32x4

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 = u32x4

The resulting type after applying the << operator.

impl Shl<i8> for &u32x4

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 = u32x4

The resulting type after applying the << operator.

impl Shl<i16> for u32x4

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 = u32x4

The resulting type after applying the << operator.

impl Shl<i16> for &u32x4

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 = u32x4

The resulting type after applying the << operator.

impl Shl<i32> for u32x4

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 = u32x4

The resulting type after applying the << operator.

impl Shl<i32> for &u32x4

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 = u32x4

The resulting type after applying the << operator.

impl Shl<i32x4> for u32x4

fn shl(self, rhs: i32x4) -> 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 = u32x4

The resulting type after applying the << operator.

impl Shl<i32x4> for &u32x4

fn shl(self, rhs: i32x4) -> 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 = u32x4

The resulting type after applying the << operator.

impl Shl<i64> for u32x4

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 = u32x4

The resulting type after applying the << operator.

impl Shl<i64> for &u32x4

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 = u32x4

The resulting type after applying the << operator.

impl Shl<i128> for u32x4

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 = u32x4

The resulting type after applying the << operator.

impl Shl<i128> for &u32x4

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 = u32x4

The resulting type after applying the << operator.

impl Shl<isize> for u32x4

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 = u32x4

The resulting type after applying the << operator.

impl Shl<isize> for &u32x4

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 = u32x4

The resulting type after applying the << operator.

impl Shl<u8> for u32x4

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 = u32x4

The resulting type after applying the << operator.

impl Shl<u8> for &u32x4

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 = u32x4

The resulting type after applying the << operator.

impl Shl<u16> for u32x4

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 = u32x4

The resulting type after applying the << operator.

impl Shl<u16> for &u32x4

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 = u32x4

The resulting type after applying the << operator.

impl Shl<u32> for u32x4

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 = u32x4

The resulting type after applying the << operator.

impl Shl<u32> for &u32x4

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 = u32x4

The resulting type after applying the << operator.

impl Shl<u32x4> for i32x4

fn shl(self, rhs: u32x4) -> 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 = i32x4

The resulting type after applying the << operator.

impl Shl<u32x4> for i32

fn shl(self, rhs: u32x4) -> 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 = i32x4

The resulting type after applying the << operator.

impl Shl<u32x4> for &i32x4

fn shl(self, rhs: u32x4) -> 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 = i32x4

The resulting type after applying the << operator.

impl Shl<u32x4> for &i32

fn shl(self, rhs: u32x4) -> 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 = i32x4

The resulting type after applying the << operator.

impl Shl<u32x4> for u32

fn shl(self, rhs: u32x4) -> 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 = u32x4

The resulting type after applying the << operator.

impl Shl<u32x4> for &u32x4

fn shl(self, rhs: u32x4) -> 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 = u32x4

The resulting type after applying the << operator.

impl Shl<u32x4> for &u32

fn shl(self, rhs: u32x4) -> 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 = u32x4

The resulting type after applying the << operator.

impl Shl<u64> for u32x4

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 = u32x4

The resulting type after applying the << operator.

impl Shl<u64> for &u32x4

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 = u32x4

The resulting type after applying the << operator.

impl Shl<u128> for u32x4

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 = u32x4

The resulting type after applying the << operator.

impl Shl<u128> for &u32x4

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 = u32x4

The resulting type after applying the << operator.

impl Shl<usize> for u32x4

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 = u32x4

The resulting type after applying the << operator.

impl Shl<usize> for &u32x4

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 = u32x4

The resulting type after applying the << operator.

impl ShlAssign for u32x4

fn shl_assign(&mut self, rhs: u32x4)

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 u32x4

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 u32x4

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<&i32> for u32x4

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<&i32x4> for u32x4

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

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<&i64> for u32x4

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 u32x4

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 u32x4

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 u32x4

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 u32x4

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<&u32> for u32x4

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<&u32x4> for i32x4

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

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<&u32x4> for u32x4

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

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<&u64> for u32x4

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 u32x4

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 u32x4

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 u32x4

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 u32x4

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<i32> for u32x4

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<i32x4> for u32x4

fn shl_assign(&mut self, rhs: i32x4)

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<i64> for u32x4

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 u32x4

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 u32x4

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 u32x4

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 u32x4

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<u32> for u32x4

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<u32x4> for i32x4

fn shl_assign(&mut self, rhs: u32x4)

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<u64> for u32x4

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 u32x4

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 u32x4

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 u32x4

fn shr(self, rhs: u32x4) -> 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 = u32x4

The resulting type after applying the >> operator.

impl Shr<&i8> for u32x4

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 = u32x4

The resulting type after applying the >> operator.

impl Shr<&i8> for &u32x4

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 = u32x4

The resulting type after applying the >> operator.

impl Shr<&i16> for u32x4

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 = u32x4

The resulting type after applying the >> operator.

impl Shr<&i16> for &u32x4

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 = u32x4

The resulting type after applying the >> operator.

impl Shr<&i32> for u32x4

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 = u32x4

The resulting type after applying the >> operator.

impl Shr<&i32> for &u32x4

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 = u32x4

The resulting type after applying the >> operator.

impl Shr<&i32x4> for u32x4

fn shr(self, rhs: &i32x4) -> 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 = u32x4

The resulting type after applying the >> operator.

impl Shr<&i32x4> for &u32x4

fn shr(self, rhs: &i32x4) -> 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 = u32x4

The resulting type after applying the >> operator.

impl Shr<&i64> for u32x4

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 = u32x4

The resulting type after applying the >> operator.

impl Shr<&i64> for &u32x4

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 = u32x4

The resulting type after applying the >> operator.

impl Shr<&i128> for u32x4

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 = u32x4

The resulting type after applying the >> operator.

impl Shr<&i128> for &u32x4

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 = u32x4

The resulting type after applying the >> operator.

impl Shr<&isize> for u32x4

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 = u32x4

The resulting type after applying the >> operator.

impl Shr<&isize> for &u32x4

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 = u32x4

The resulting type after applying the >> operator.

impl Shr<&u8> for u32x4

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 = u32x4

The resulting type after applying the >> operator.

impl Shr<&u8> for &u32x4

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 = u32x4

The resulting type after applying the >> operator.

impl Shr<&u16> for u32x4

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 = u32x4

The resulting type after applying the >> operator.

impl Shr<&u16> for &u32x4

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 = u32x4

The resulting type after applying the >> operator.

impl Shr<&u32> for u32x4

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 = u32x4

The resulting type after applying the >> operator.

impl Shr<&u32> for &u32x4

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 = u32x4

The resulting type after applying the >> operator.

impl Shr<&u32x4> for i32x4

fn shr(self, rhs: &u32x4) -> 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 = i32x4

The resulting type after applying the >> operator.

impl Shr<&u32x4> for i32

fn shr(self, rhs: &u32x4) -> 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 = i32x4

The resulting type after applying the >> operator.

impl Shr<&u32x4> for &i32x4

fn shr(self, rhs: &u32x4) -> 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 = i32x4

The resulting type after applying the >> operator.

impl Shr<&u32x4> for &i32

fn shr(self, rhs: &u32x4) -> 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 = i32x4

The resulting type after applying the >> operator.

impl Shr<&u32x4> for u32x4

fn shr(self, rhs: &u32x4) -> 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 = u32x4

The resulting type after applying the >> operator.

impl Shr<&u32x4> for u32

fn shr(self, rhs: &u32x4) -> 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 = u32x4

The resulting type after applying the >> operator.

impl Shr<&u32x4> for &u32x4

fn shr(self, rhs: &u32x4) -> 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 = u32x4

The resulting type after applying the >> operator.

impl Shr<&u32x4> for &u32

fn shr(self, rhs: &u32x4) -> 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 = u32x4

The resulting type after applying the >> operator.

impl Shr<&u64> for u32x4

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 = u32x4

The resulting type after applying the >> operator.

impl Shr<&u64> for &u32x4

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 = u32x4

The resulting type after applying the >> operator.

impl Shr<&u128> for u32x4

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 = u32x4

The resulting type after applying the >> operator.

impl Shr<&u128> for &u32x4

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 = u32x4

The resulting type after applying the >> operator.

impl Shr<&usize> for u32x4

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 = u32x4

The resulting type after applying the >> operator.

impl Shr<&usize> for &u32x4

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 = u32x4

The resulting type after applying the >> operator.

impl Shr<i8> for u32x4

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 = u32x4

The resulting type after applying the >> operator.

impl Shr<i8> for &u32x4

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 = u32x4

The resulting type after applying the >> operator.

impl Shr<i16> for u32x4

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 = u32x4

The resulting type after applying the >> operator.

impl Shr<i16> for &u32x4

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 = u32x4

The resulting type after applying the >> operator.

impl Shr<i32> for u32x4

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 = u32x4

The resulting type after applying the >> operator.

impl Shr<i32> for &u32x4

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 = u32x4

The resulting type after applying the >> operator.

impl Shr<i32x4> for u32x4

fn shr(self, rhs: i32x4) -> 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 = u32x4

The resulting type after applying the >> operator.

impl Shr<i32x4> for &u32x4

fn shr(self, rhs: i32x4) -> 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 = u32x4

The resulting type after applying the >> operator.

impl Shr<i64> for u32x4

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 = u32x4

The resulting type after applying the >> operator.

impl Shr<i64> for &u32x4

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 = u32x4

The resulting type after applying the >> operator.

impl Shr<i128> for u32x4

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 = u32x4

The resulting type after applying the >> operator.

impl Shr<i128> for &u32x4

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 = u32x4

The resulting type after applying the >> operator.

impl Shr<isize> for u32x4

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 = u32x4

The resulting type after applying the >> operator.

impl Shr<isize> for &u32x4

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 = u32x4

The resulting type after applying the >> operator.

impl Shr<u8> for u32x4

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 = u32x4

The resulting type after applying the >> operator.

impl Shr<u8> for &u32x4

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 = u32x4

The resulting type after applying the >> operator.

impl Shr<u16> for u32x4

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 = u32x4

The resulting type after applying the >> operator.

impl Shr<u16> for &u32x4

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 = u32x4

The resulting type after applying the >> operator.

impl Shr<u32> for u32x4

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 = u32x4

The resulting type after applying the >> operator.

impl Shr<u32> for &u32x4

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 = u32x4

The resulting type after applying the >> operator.

impl Shr<u32x4> for i32x4

fn shr(self, rhs: u32x4) -> 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 = i32x4

The resulting type after applying the >> operator.

impl Shr<u32x4> for i32

fn shr(self, rhs: u32x4) -> 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 = i32x4

The resulting type after applying the >> operator.

impl Shr<u32x4> for &i32x4

fn shr(self, rhs: u32x4) -> 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 = i32x4

The resulting type after applying the >> operator.

impl Shr<u32x4> for &i32

fn shr(self, rhs: u32x4) -> 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 = i32x4

The resulting type after applying the >> operator.

impl Shr<u32x4> for u32

fn shr(self, rhs: u32x4) -> 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 = u32x4

The resulting type after applying the >> operator.

impl Shr<u32x4> for &u32x4

fn shr(self, rhs: u32x4) -> 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 = u32x4

The resulting type after applying the >> operator.

impl Shr<u32x4> for &u32

fn shr(self, rhs: u32x4) -> 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 = u32x4

The resulting type after applying the >> operator.

impl Shr<u64> for u32x4

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 = u32x4

The resulting type after applying the >> operator.

impl Shr<u64> for &u32x4

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 = u32x4

The resulting type after applying the >> operator.

impl Shr<u128> for u32x4

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 = u32x4

The resulting type after applying the >> operator.

impl Shr<u128> for &u32x4

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 = u32x4

The resulting type after applying the >> operator.

impl Shr<usize> for u32x4

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 = u32x4

The resulting type after applying the >> operator.

impl Shr<usize> for &u32x4

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 = u32x4

The resulting type after applying the >> operator.

impl ShrAssign for u32x4

fn shr_assign(&mut self, rhs: u32x4)

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 u32x4

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 u32x4

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<&i32> for u32x4

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<&i32x4> for u32x4

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

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<&i64> for u32x4

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 u32x4

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 u32x4

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 u32x4

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 u32x4

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<&u32> for u32x4

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<&u32x4> for i32x4

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

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<&u32x4> for u32x4

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

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<&u64> for u32x4

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 u32x4

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 u32x4

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 u32x4

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 u32x4

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<i32> for u32x4

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<i32x4> for u32x4

fn shr_assign(&mut self, rhs: i32x4)

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<i64> for u32x4

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 u32x4

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 u32x4

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 u32x4

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 u32x4

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<u32> for u32x4

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<u32x4> for i32x4

fn shr_assign(&mut self, rhs: u32x4)

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<u64> for u32x4

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 u32x4

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 u32x4

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 u32x4

impl Sub for u32x4

type Output = u32x4

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<&u32> for u32x4

type Output = u32x4

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<&u32> for &u32x4

type Output = u32x4

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<&u32x4> for u32x4

type Output = u32x4

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<&u32x4> for u32

type Output = u32x4

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<&u32x4> for &u32x4

type Output = u32x4

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<&u32x4> for &u32

type Output = u32x4

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<u32> for u32x4

type Output = u32x4

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<u32> for &u32x4

type Output = u32x4

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<u32x4> for u32

type Output = u32x4

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<u32x4> for &u32x4

type Output = u32x4

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<u32x4> for &u32

type Output = u32x4

The resulting type after applying the - operator.

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

Performs the - operation.

impl SubAssign for u32x4

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl SubAssign<&u32> for u32x4

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

Performs the -= operation.

impl SubAssign<&u32x4> for u32x4

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

Performs the -= operation.

impl SubAssign<u32> for u32x4

fn sub_assign(&mut self, rhs: u32)

Performs the -= operation.

impl<Rhs> Sum<Rhs> for u32x4

where u32x4: 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 u32x4

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

Formats the value using the given formatter.

impl UpperHex for u32x4

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

Formats the value using the given formatter.

impl Zeroable for u32x4

fn zeroed() -> Self

Calls zeroed.