Struct i8x32 

pub struct i8x32 { /* private fields */ }

A SIMD vector with 32 elements of type i8.

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

Implementations

impl i8x32

The following functionality exists for all SIMD vectors.

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

Converts an array to a SIMD vector.

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

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

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

Converts a SIMD vector to an array.

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

Returns an array reference containing the entire SIMD vector.

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

Returns a mutable array reference containing the entire SIMD vector.

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

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

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

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

pub fn reduce_mul(self) -> i8

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: u8x32) -> 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: u8x32) -> 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: u8x32) -> Self

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

Indices are wrapped by the number of elements in self.

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

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

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

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 i8x32

The following functionality exists for all SIMD vectors of signed 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 i8::MAX.

pub const MIN: Self

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

pub const LANES: u16 = 32

The number of elements in this SIMD vector.

pub const BITS: u16

The size of this SIMD vector in bits.

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

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

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

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

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

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

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

pub fn reduce_max(self) -> i8

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

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

pub fn reduce_min(self) -> i8

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

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

pub const fn cast_unsigned(self) -> u8x32

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

pub fn unbounded_shl(self, rhs: u8x32) -> 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 i8, 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 i8, 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: u8x32) -> 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 i8, the entire value is shifted out, which yields 0 for a positive number, and -1 for a negative number.

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 i8, the entire value is shifted out, which yields 0 for a positive number, and -1 for a negative number.

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 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 unsigned_abs(self) -> u8x32

Computes the absolute value of each input element, returned as an unsigned integer in order to avoid wrapping.

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.

Returns a tuple with:

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

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.

Returns a tuple with:

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

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

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) -> (u8x32, i8x32)

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

pub fn abs(self) -> Self

Returns the absolute value of each input element.

pub fn signum(self) -> Self

Returns numbers representing the sign of each element.

• 0 if the element is zero
• 1 if the element is positive
• -1 if the element is negative

pub fn is_positive(self) -> Self

Returns a mask that is true for each positive element, and false if it is zero or negative.

pub fn is_negative(self) -> Self

Returns a mask that is true for each negative element, and false if it is zero or positive.

impl i8x32

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

pub fn swizzle_half(self, rhs: i8x32) -> i8x32

Returns a new vector with lanes selected from the lanes of the first input vector a specified in the second input vector rhs. The indices i in range [0, 15] select the i-th element of self. For indices outside of the range the resulting lane is 0.

This note that is the equivalent of two parallel swizzle operations on the two halves of the vector, and the indexes each refer to the corresponding half.

pub fn swizzle_half_relaxed(self, rhs: i8x32) -> i8x32

Indices in the range [0, 15] will select the i-th element of self. If the high bit of any element of rhs is set (negative) then the corresponding output lane is guaranteed to be zero. Otherwise if the element of rhs is within the range [32, 127] then the output lane is either 0 or self[rhs[i] % 16] depending on the implementation.

This is the equivalent to two parallel swizzle operations on the two halves of the vector, and the indexes each refer to their corresponding half.

pub fn swizzle(self, rhs: i8x32) -> i8x32

👎Deprecated since 1.7.0:

replaced with shuffle_zeroing

Full 32-entry byte table lookup.

• An index (interpreted as unsigned) in [0, 31] selects self[index].
• Any index >= 32 (including negative i8 values) yields 0.

Unlike swizzle_half, indices address the entire 32-byte vector, not just their own 16-byte half.

This function has been deprecated and replaced with shuffle_zeroing.

pub fn swizzle_relaxed(self, rhs: i8x32) -> i8x32

👎Deprecated since 1.7.0:

replaced with shuffle

Like swizzle, but out-of-range indices (unsigned >= 32) yield an implementation-defined result (0 or self[index % 32]). Prefer this when you know all indices are in range; it can be cheaper.

This function has been deprecated and replaced with shuffle.

Trait Implementations

impl Add for i8x32

type Output = i8x32

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<&i8> for i8x32

type Output = i8x32

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<&i8> for &i8x32

type Output = i8x32

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<&i8x32> for i8x32

type Output = i8x32

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<&i8x32> for i8

type Output = i8x32

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<&i8x32> for &i8x32

type Output = i8x32

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<&i8x32> for &i8

type Output = i8x32

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<i8> for i8x32

type Output = i8x32

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<i8> for &i8x32

type Output = i8x32

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<i8x32> for i8

type Output = i8x32

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<i8x32> for &i8x32

type Output = i8x32

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<i8x32> for &i8

type Output = i8x32

The resulting type after applying the + operator.

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

Performs the + operation.

impl AddAssign for i8x32

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl AddAssign<&i8> for i8x32

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

Performs the += operation.

impl AddAssign<&i8x32> for i8x32

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

Performs the += operation.

impl AddAssign<i8> for i8x32

fn add_assign(&mut self, rhs: i8)

Performs the += operation.

impl AlignTo for i8x32

type Elem = i8

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 i8x32

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

Formats the value using the given formatter.

impl BitAnd for i8x32

type Output = i8x32

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<&i8> for i8x32

type Output = i8x32

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<&i8> for &i8x32

type Output = i8x32

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<&i8x32> for i8x32

type Output = i8x32

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<&i8x32> for i8

type Output = i8x32

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<&i8x32> for &i8x32

type Output = i8x32

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<&i8x32> for &i8

type Output = i8x32

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<i8> for i8x32

type Output = i8x32

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<i8> for &i8x32

type Output = i8x32

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<i8x32> for i8

type Output = i8x32

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<i8x32> for &i8x32

type Output = i8x32

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<i8x32> for &i8

type Output = i8x32

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAndAssign for i8x32

fn bitand_assign(&mut self, rhs: Self)

Performs the &= operation.

impl BitAndAssign<&i8> for i8x32

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

Performs the &= operation.

impl BitAndAssign<&i8x32> for i8x32

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

Performs the &= operation.

impl BitAndAssign<i8> for i8x32

fn bitand_assign(&mut self, rhs: i8)

Performs the &= operation.

impl BitOr for i8x32

type Output = i8x32

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<&i8> for i8x32

type Output = i8x32

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<&i8> for &i8x32

type Output = i8x32

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<&i8x32> for i8x32

type Output = i8x32

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<&i8x32> for i8

type Output = i8x32

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<&i8x32> for &i8x32

type Output = i8x32

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<&i8x32> for &i8

type Output = i8x32

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<i8> for i8x32

type Output = i8x32

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<i8> for &i8x32

type Output = i8x32

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<i8x32> for i8

type Output = i8x32

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<i8x32> for &i8x32

type Output = i8x32

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<i8x32> for &i8

type Output = i8x32

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOrAssign for i8x32

fn bitor_assign(&mut self, rhs: Self)

Performs the |= operation.

impl BitOrAssign<&i8> for i8x32

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

Performs the |= operation.

impl BitOrAssign<&i8x32> for i8x32

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

Performs the |= operation.

impl BitOrAssign<i8> for i8x32

fn bitor_assign(&mut self, rhs: i8)

Performs the |= operation.

impl BitXor for i8x32

type Output = i8x32

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<&i8> for i8x32

type Output = i8x32

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<&i8> for &i8x32

type Output = i8x32

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<&i8x32> for i8x32

type Output = i8x32

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<&i8x32> for i8

type Output = i8x32

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<&i8x32> for &i8x32

type Output = i8x32

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<&i8x32> for &i8

type Output = i8x32

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<i8> for i8x32

type Output = i8x32

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<i8> for &i8x32

type Output = i8x32

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<i8x32> for i8

type Output = i8x32

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<i8x32> for &i8x32

type Output = i8x32

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<i8x32> for &i8

type Output = i8x32

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXorAssign for i8x32

fn bitxor_assign(&mut self, rhs: Self)

Performs the ^= operation.

impl BitXorAssign<&i8> for i8x32

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

Performs the ^= operation.

impl BitXorAssign<&i8x32> for i8x32

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

Performs the ^= operation.

impl BitXorAssign<i8> for i8x32

fn bitxor_assign(&mut self, rhs: i8)

Performs the ^= operation.

impl Clone for i8x32

fn clone(&self) -> i8x32

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl CmpEq for i8x32

type Output = i8x32

👎Deprecated since 1.5.0:

use the inherent function simd_eq instead

The type returned by simd_eq.

fn simd_eq(self, other: Self) -> Self

👎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<i8> for i8x32

type Output = i8x32

👎Deprecated since 1.5.0:

use the inherent function simd_eq instead

The type returned by simd_eq.

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

type Output = i8x32

👎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<i8> for i8x32

type Output = i8x32

👎Deprecated since 1.5.0:

use the inherent function simd_ge instead

The type returned by simd_ge.

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

type Output = i8x32

👎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<i8> for i8x32

type Output = i8x32

👎Deprecated since 1.5.0:

use the inherent function simd_gt instead

The type returned by simd_gt.

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

type Output = i8x32

👎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<i8> for i8x32

type Output = i8x32

👎Deprecated since 1.5.0:

use the inherent function simd_le instead

The type returned by simd_le.

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

type Output = i8x32

👎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<i8> for i8x32

type Output = i8x32

👎Deprecated since 1.5.0:

use the inherent function simd_lt instead

The type returned by simd_lt.

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

type Output = i8x32

👎Deprecated since 1.5.0:

use the inherent function simd_ne instead

The type returned by simd_ne.

fn simd_ne(self, other: Self) -> Self

👎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<i8> for i8x32

type Output = i8x32

👎Deprecated since 1.5.0:

use the inherent function simd_ne instead

The type returned by simd_ne.

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

impl Debug for i8x32

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

Formats the value using the given formatter.

impl Default for i8x32

fn default() -> i8x32

Returns the “default value” for a type.

impl Display for i8x32

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

Formats the value using the given formatter.

impl Div for i8x32

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

The resulting type after applying the / operator.

impl Div<&i8> for i8x32

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

The resulting type after applying the / operator.

impl Div<&i8> for &i8x32

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

The resulting type after applying the / operator.

impl Div<&i8x32> for i8x32

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

The resulting type after applying the / operator.

impl Div<&i8x32> for i8

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

The resulting type after applying the / operator.

impl Div<&i8x32> for &i8x32

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

The resulting type after applying the / operator.

impl Div<&i8x32> for &i8

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

The resulting type after applying the / operator.

impl Div<i8> for i8x32

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

The resulting type after applying the / operator.

impl Div<i8> for &i8x32

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

The resulting type after applying the / operator.

impl Div<i8x32> for i8

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

The resulting type after applying the / operator.

impl Div<i8x32> for &i8x32

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

The resulting type after applying the / operator.

impl Div<i8x32> for &i8

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

The resulting type after applying the / operator.

impl DivAssign for i8x32

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<&i8> for i8x32

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

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

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<i8> for i8x32

fn div_assign(&mut self, rhs: i8)

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 i8x32

impl From<&[i8]> for i8x32

fn from(value: &[i8]) -> 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<[i8; 32]> for i8x32

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

Converts an array to a SIMD vector.

impl From<__m256i> for i8x32

Available on x86-64 only.

fn from(value: __m256i) -> Self

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

impl From<i8> for i8x32

fn from(elem: i8) -> Self

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

impl From<i8x32> for i16x32

fn from(i: i8x32) -> Self

widen with sign extend from i8 to i16

impl From<i8x32> for [i8; 32]

fn from(simd: i8x32) -> Self

Converts a SIMD vector to an array.

impl From<i8x32> for __m256i

Available on x86-64 only.

fn from(value: i8x32) -> Self

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

impl LowerExp for i8x32

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

Formats the value using the given formatter.

impl LowerHex for i8x32

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

Formats the value using the given formatter.

impl Mul for i8x32

type Output = i8x32

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<&i8> for i8x32

type Output = i8x32

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<&i8> for &i8x32

type Output = i8x32

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<&i8x32> for i8x32

type Output = i8x32

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<&i8x32> for i8

type Output = i8x32

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<&i8x32> for &i8x32

type Output = i8x32

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<&i8x32> for &i8

type Output = i8x32

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<i8> for i8x32

type Output = i8x32

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<i8> for &i8x32

type Output = i8x32

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<i8x32> for i8

type Output = i8x32

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<i8x32> for &i8x32

type Output = i8x32

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<i8x32> for &i8

type Output = i8x32

The resulting type after applying the * operator.

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

Performs the * operation.

impl MulAssign for i8x32

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl MulAssign<&i8> for i8x32

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

Performs the *= operation.

impl MulAssign<&i8x32> for i8x32

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

Performs the *= operation.

impl MulAssign<i8> for i8x32

fn mul_assign(&mut self, rhs: i8)

Performs the *= operation.

impl Neg for i8x32

type Output = i8x32

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Neg for &i8x32

type Output = i8x32

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Not for i8x32

type Output = i8x32

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl Not for &i8x32

type Output = i8x32

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl Octal for i8x32

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

Formats the value using the given formatter.

impl PartialEq for i8x32

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

Equality operator ==.

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

Inequality operator !=.

impl Pod for i8x32

impl<Rhs> Product<Rhs> for i8x32

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

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

The resulting type after applying the % operator.

impl Rem<&i8> for i8x32

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

The resulting type after applying the % operator.

impl Rem<&i8> for &i8x32

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

The resulting type after applying the % operator.

impl Rem<&i8x32> for i8x32

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

The resulting type after applying the % operator.

impl Rem<&i8x32> for i8

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

The resulting type after applying the % operator.

impl Rem<&i8x32> for &i8x32

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

The resulting type after applying the % operator.

impl Rem<&i8x32> for &i8

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

The resulting type after applying the % operator.

impl Rem<i8> for i8x32

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

The resulting type after applying the % operator.

impl Rem<i8> for &i8x32

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

The resulting type after applying the % operator.

impl Rem<i8x32> for i8

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

The resulting type after applying the % operator.

impl Rem<i8x32> for &i8x32

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

The resulting type after applying the % operator.

impl Rem<i8x32> for &i8

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

The resulting type after applying the % operator.

impl RemAssign for i8x32

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<&i8> for i8x32

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

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

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<i8> for i8x32

fn rem_assign(&mut self, rhs: i8)

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<i8x32> for i8x32

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

Lanewise SIMD selection.

impl Select<i8x32> for u8x32

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

Lanewise SIMD selection.

impl Select<u8x32> for i8x32

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

Lanewise SIMD selection.

impl Shl for i8x32

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

The resulting type after applying the << operator.

impl Shl<&i8> for i8x32

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

The resulting type after applying the << operator.

impl Shl<&i8> for &i8x32

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

The resulting type after applying the << operator.

impl Shl<&i8x32> for i8x32

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

The resulting type after applying the << operator.

impl Shl<&i8x32> for i8

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

The resulting type after applying the << operator.

impl Shl<&i8x32> for &i8x32

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

The resulting type after applying the << operator.

impl Shl<&i8x32> for &i8

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

The resulting type after applying the << operator.

impl Shl<&i8x32> for u8x32

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

The resulting type after applying the << operator.

impl Shl<&i8x32> for u8

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

The resulting type after applying the << operator.

impl Shl<&i8x32> for &u8x32

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

The resulting type after applying the << operator.

impl Shl<&i8x32> for &u8

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

The resulting type after applying the << operator.

impl Shl<&i16> for i8x32

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

The resulting type after applying the << operator.

impl Shl<&i16> for &i8x32

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

The resulting type after applying the << operator.

impl Shl<&i32> for i8x32

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

The resulting type after applying the << operator.

impl Shl<&i32> for &i8x32

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

The resulting type after applying the << operator.

impl Shl<&i64> for i8x32

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

The resulting type after applying the << operator.

impl Shl<&i64> for &i8x32

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

The resulting type after applying the << operator.

impl Shl<&i128> for i8x32

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

The resulting type after applying the << operator.

impl Shl<&i128> for &i8x32

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

The resulting type after applying the << operator.

impl Shl<&isize> for i8x32

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

The resulting type after applying the << operator.

impl Shl<&isize> for &i8x32

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

The resulting type after applying the << operator.

impl Shl<&u8> for i8x32

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

The resulting type after applying the << operator.

impl Shl<&u8> for &i8x32

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

The resulting type after applying the << operator.

impl Shl<&u8x32> for i8x32

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

The resulting type after applying the << operator.

impl Shl<&u8x32> for &i8x32

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

The resulting type after applying the << operator.

impl Shl<&u16> for i8x32

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

The resulting type after applying the << operator.

impl Shl<&u16> for &i8x32

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

The resulting type after applying the << operator.

impl Shl<&u32> for i8x32

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

The resulting type after applying the << operator.

impl Shl<&u32> for &i8x32

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

The resulting type after applying the << operator.

impl Shl<&u64> for i8x32

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

The resulting type after applying the << operator.

impl Shl<&u64> for &i8x32

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

The resulting type after applying the << operator.

impl Shl<&u128> for i8x32

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

The resulting type after applying the << operator.

impl Shl<&u128> for &i8x32

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

The resulting type after applying the << operator.

impl Shl<&usize> for i8x32

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

The resulting type after applying the << operator.

impl Shl<&usize> for &i8x32

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

The resulting type after applying the << operator.

impl Shl<i8> for i8x32

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

The resulting type after applying the << operator.

impl Shl<i8> for &i8x32

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

The resulting type after applying the << operator.

impl Shl<i8x32> for i8

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

The resulting type after applying the << operator.

impl Shl<i8x32> for &i8x32

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

The resulting type after applying the << operator.

impl Shl<i8x32> for &i8

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

The resulting type after applying the << operator.

impl Shl<i8x32> for u8x32

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

The resulting type after applying the << operator.

impl Shl<i8x32> for u8

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

The resulting type after applying the << operator.

impl Shl<i8x32> for &u8x32

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

The resulting type after applying the << operator.

impl Shl<i8x32> for &u8

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

The resulting type after applying the << operator.

impl Shl<i16> for i8x32

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

The resulting type after applying the << operator.

impl Shl<i16> for &i8x32

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

The resulting type after applying the << operator.

impl Shl<i32> for i8x32

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

The resulting type after applying the << operator.

impl Shl<i32> for &i8x32

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

The resulting type after applying the << operator.

impl Shl<i64> for i8x32

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

The resulting type after applying the << operator.

impl Shl<i64> for &i8x32

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

The resulting type after applying the << operator.

impl Shl<i128> for i8x32

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

The resulting type after applying the << operator.

impl Shl<i128> for &i8x32

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

The resulting type after applying the << operator.

impl Shl<isize> for i8x32

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

The resulting type after applying the << operator.

impl Shl<isize> for &i8x32

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

The resulting type after applying the << operator.

impl Shl<u8> for i8x32

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

The resulting type after applying the << operator.

impl Shl<u8> for &i8x32

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

The resulting type after applying the << operator.

impl Shl<u8x32> for i8x32

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

The resulting type after applying the << operator.

impl Shl<u8x32> for &i8x32

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

The resulting type after applying the << operator.

impl Shl<u16> for i8x32

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

The resulting type after applying the << operator.

impl Shl<u16> for &i8x32

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

The resulting type after applying the << operator.

impl Shl<u32> for i8x32

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

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

The resulting type after applying the << operator.

impl Shl<u32> for &i8x32

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

The resulting type after applying the << operator.

impl Shl<u64> for i8x32

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

The resulting type after applying the << operator.

impl Shl<u64> for &i8x32

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

The resulting type after applying the << operator.

impl Shl<u128> for i8x32

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

The resulting type after applying the << operator.

impl Shl<u128> for &i8x32

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

The resulting type after applying the << operator.

impl Shl<usize> for i8x32

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

The resulting type after applying the << operator.

impl Shl<usize> for &i8x32

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

The resulting type after applying the << operator.

impl ShlAssign for i8x32

fn shl_assign(&mut self, rhs: i8x32)

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 i8x32

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

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

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<&i8x32> for u8x32

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

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<&i16> for i8x32

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 i8x32

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

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

This operator behaves like wrapping_shl.

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

impl ShlAssign<&i64> for i8x32

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 i8x32

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 i8x32

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 i8x32

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<&u8x32> for i8x32

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

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<&u16> for i8x32

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 i8x32

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

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

This operator behaves like wrapping_shl.

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

impl ShlAssign<&u64> for i8x32

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 i8x32

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 i8x32

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 i8x32

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<i8x32> for u8x32

fn shl_assign(&mut self, rhs: i8x32)

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<i16> for i8x32

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 i8x32

fn shl_assign(&mut self, rhs: i32)

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

This operator behaves like wrapping_shl.

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

impl ShlAssign<i64> for i8x32

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 i8x32

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 i8x32

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 i8x32

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<u8x32> for i8x32

fn shl_assign(&mut self, rhs: u8x32)

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<u16> for i8x32

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 i8x32

fn shl_assign(&mut self, rhs: u32)

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

This operator behaves like wrapping_shl.

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

impl ShlAssign<u64> for i8x32

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 i8x32

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 i8x32

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 i8x32

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

The resulting type after applying the >> operator.

impl Shr<&i8> for i8x32

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

The resulting type after applying the >> operator.

impl Shr<&i8> for &i8x32

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

The resulting type after applying the >> operator.

impl Shr<&i8x32> for i8x32

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

The resulting type after applying the >> operator.

impl Shr<&i8x32> for i8

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

The resulting type after applying the >> operator.

impl Shr<&i8x32> for &i8x32

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

The resulting type after applying the >> operator.

impl Shr<&i8x32> for &i8

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

The resulting type after applying the >> operator.

impl Shr<&i8x32> for u8x32

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

The resulting type after applying the >> operator.

impl Shr<&i8x32> for u8

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

The resulting type after applying the >> operator.

impl Shr<&i8x32> for &u8x32

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

The resulting type after applying the >> operator.

impl Shr<&i8x32> for &u8

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

The resulting type after applying the >> operator.

impl Shr<&i16> for i8x32

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

The resulting type after applying the >> operator.

impl Shr<&i16> for &i8x32

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

The resulting type after applying the >> operator.

impl Shr<&i32> for i8x32

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

The resulting type after applying the >> operator.

impl Shr<&i32> for &i8x32

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

The resulting type after applying the >> operator.

impl Shr<&i64> for i8x32

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

The resulting type after applying the >> operator.

impl Shr<&i64> for &i8x32

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

The resulting type after applying the >> operator.

impl Shr<&i128> for i8x32

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

The resulting type after applying the >> operator.

impl Shr<&i128> for &i8x32

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

The resulting type after applying the >> operator.

impl Shr<&isize> for i8x32

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

The resulting type after applying the >> operator.

impl Shr<&isize> for &i8x32

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

The resulting type after applying the >> operator.

impl Shr<&u8> for i8x32

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

The resulting type after applying the >> operator.

impl Shr<&u8> for &i8x32

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

The resulting type after applying the >> operator.

impl Shr<&u8x32> for i8x32

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

The resulting type after applying the >> operator.

impl Shr<&u8x32> for &i8x32

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

The resulting type after applying the >> operator.

impl Shr<&u16> for i8x32

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

The resulting type after applying the >> operator.

impl Shr<&u16> for &i8x32

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

The resulting type after applying the >> operator.

impl Shr<&u32> for i8x32

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

The resulting type after applying the >> operator.

impl Shr<&u32> for &i8x32

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

The resulting type after applying the >> operator.

impl Shr<&u64> for i8x32

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

The resulting type after applying the >> operator.

impl Shr<&u64> for &i8x32

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

The resulting type after applying the >> operator.

impl Shr<&u128> for i8x32

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

The resulting type after applying the >> operator.

impl Shr<&u128> for &i8x32

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

The resulting type after applying the >> operator.

impl Shr<&usize> for i8x32

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

The resulting type after applying the >> operator.

impl Shr<&usize> for &i8x32

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

The resulting type after applying the >> operator.

impl Shr<i8> for i8x32

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

The resulting type after applying the >> operator.

impl Shr<i8> for &i8x32

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

The resulting type after applying the >> operator.

impl Shr<i8x32> for i8

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

The resulting type after applying the >> operator.

impl Shr<i8x32> for &i8x32

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

The resulting type after applying the >> operator.

impl Shr<i8x32> for &i8

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

The resulting type after applying the >> operator.

impl Shr<i8x32> for u8x32

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

The resulting type after applying the >> operator.

impl Shr<i8x32> for u8

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

The resulting type after applying the >> operator.

impl Shr<i8x32> for &u8x32

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

The resulting type after applying the >> operator.

impl Shr<i8x32> for &u8

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

The resulting type after applying the >> operator.

impl Shr<i16> for i8x32

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

The resulting type after applying the >> operator.

impl Shr<i16> for &i8x32

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

The resulting type after applying the >> operator.

impl Shr<i32> for i8x32

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

The resulting type after applying the >> operator.

impl Shr<i32> for &i8x32

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

The resulting type after applying the >> operator.

impl Shr<i64> for i8x32

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

The resulting type after applying the >> operator.

impl Shr<i64> for &i8x32

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

The resulting type after applying the >> operator.

impl Shr<i128> for i8x32

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

The resulting type after applying the >> operator.

impl Shr<i128> for &i8x32

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

The resulting type after applying the >> operator.

impl Shr<isize> for i8x32

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

The resulting type after applying the >> operator.

impl Shr<isize> for &i8x32

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

The resulting type after applying the >> operator.

impl Shr<u8> for i8x32

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

The resulting type after applying the >> operator.

impl Shr<u8> for &i8x32

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

The resulting type after applying the >> operator.

impl Shr<u8x32> for i8x32

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

The resulting type after applying the >> operator.

impl Shr<u8x32> for &i8x32

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

The resulting type after applying the >> operator.

impl Shr<u16> for i8x32

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

The resulting type after applying the >> operator.

impl Shr<u16> for &i8x32

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

The resulting type after applying the >> operator.

impl Shr<u32> for i8x32

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

The resulting type after applying the >> operator.

impl Shr<u32> for &i8x32

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

The resulting type after applying the >> operator.

impl Shr<u64> for i8x32

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

The resulting type after applying the >> operator.

impl Shr<u64> for &i8x32

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

The resulting type after applying the >> operator.

impl Shr<u128> for i8x32

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

The resulting type after applying the >> operator.

impl Shr<u128> for &i8x32

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

The resulting type after applying the >> operator.

impl Shr<usize> for i8x32

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

The resulting type after applying the >> operator.

impl Shr<usize> for &i8x32

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

The resulting type after applying the >> operator.

impl ShrAssign for i8x32

fn shr_assign(&mut self, rhs: i8x32)

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 i8x32

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

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

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<&i8x32> for u8x32

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

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<&i16> for i8x32

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 i8x32

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

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

This operator behaves like wrapping_shr.

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

impl ShrAssign<&i64> for i8x32

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 i8x32

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 i8x32

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 i8x32

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<&u8x32> for i8x32

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

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<&u16> for i8x32

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 i8x32

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

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

This operator behaves like wrapping_shr.

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

impl ShrAssign<&u64> for i8x32

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 i8x32

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 i8x32

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 i8x32

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<i8x32> for u8x32

fn shr_assign(&mut self, rhs: i8x32)

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<i16> for i8x32

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 i8x32

fn shr_assign(&mut self, rhs: i32)

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

This operator behaves like wrapping_shr.

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

impl ShrAssign<i64> for i8x32

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 i8x32

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 i8x32

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 i8x32

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<u8x32> for i8x32

fn shr_assign(&mut self, rhs: u8x32)

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<u16> for i8x32

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 i8x32

fn shr_assign(&mut self, rhs: u32)

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

This operator behaves like wrapping_shr.

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

impl ShrAssign<u64> for i8x32

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 i8x32

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 i8x32

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 i8x32

impl Sub for i8x32

type Output = i8x32

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<&i8> for i8x32

type Output = i8x32

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<&i8> for &i8x32

type Output = i8x32

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<&i8x32> for i8x32

type Output = i8x32

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<&i8x32> for i8

type Output = i8x32

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<&i8x32> for &i8x32

type Output = i8x32

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<&i8x32> for &i8

type Output = i8x32

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<i8> for i8x32

type Output = i8x32

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<i8> for &i8x32

type Output = i8x32

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<i8x32> for i8

type Output = i8x32

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<i8x32> for &i8x32

type Output = i8x32

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<i8x32> for &i8

type Output = i8x32

The resulting type after applying the - operator.

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

Performs the - operation.

impl SubAssign for i8x32

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl SubAssign<&i8> for i8x32

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

Performs the -= operation.

impl SubAssign<&i8x32> for i8x32

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

Performs the -= operation.

impl SubAssign<i8> for i8x32

fn sub_assign(&mut self, rhs: i8)

Performs the -= operation.

impl<Rhs> Sum<Rhs> for i8x32

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

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

Formats the value using the given formatter.

impl UpperHex for i8x32

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

Formats the value using the given formatter.

impl Zeroable for i8x32

fn zeroed() -> Self

Calls zeroed.