Struct i16x16 

pub struct i16x16 { /* private fields */ }

A SIMD vector with 16 elements of type i16.

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

Implementations

impl i16x16

The following functionality exists for all SIMD vectors.

pub const fn new(array: [i16; 16]) -> Self

Converts an array to a SIMD vector.

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

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

pub const fn to_array(self) -> [i16; 16]

Converts a SIMD vector to an array.

pub const fn as_array(&self) -> &[i16; 16]

Returns an array reference containing the entire SIMD vector.

pub const fn as_mut_array(&mut self) -> &mut [i16; 16]

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

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

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

pub fn reduce_mul(self) -> i16

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: u16x16) -> 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: u16x16) -> 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: u16x16) -> 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; 16]) -> [Self; 16]

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 i16x16

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

pub const MIN: Self

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

pub const LANES: u16 = 16

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

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

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

pub fn reduce_min(self) -> i16

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

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

pub const fn cast_unsigned(self) -> u16x16

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

pub fn unbounded_shl(self, rhs: u16x16) -> 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 i16, 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 i16, 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: u16x16) -> 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 i16, 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 i16, 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) -> u16x16

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

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) -> (u16x16, i16x16)

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

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

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

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

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 i16x16

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

pub fn from_i8x16(v: i8x16) -> Self

Converts each element from i8 to i16.

pub fn dot(self, rhs: Self) -> i32x8

Partially computes the dot product.

First this multiplies the input 16-bit integers, producing intermediate 32-bit integers. Then this horizontally adds adjacent pairs, resulting in eight 32-bit integers.

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

Multiply and scale equivalent to ((self * rhs) + 0x4000) >> 15 on each lane, effectively multiplying by a 16 bit fixed point number between -1 and 1. This corresponds to the following instructions:

• vqrdmulhq_n_s16 instruction on neon
• i16x8_q15mulr_sat on simd128
• _mm256_mulhrs_epi16 on avx2
• emulated via mul_i16_* on sse2

pub fn mul_scale_round_n(self, rhs: i16) -> Self

Multiply and scale equivalent to ((self * rhs) + 0x4000) >> 15 on each lane, effectively multiplying by a 16 bit fixed point number between -1 and 1. This corresponds to the following instructions:

• vqrdmulhq_n_s16 instruction on neon
• i16x8_q15mulr_sat on simd128
• _mm256_mulhrs_epi16 on avx2
• emulated via mul_i16_* on sse2

Trait Implementations

impl Add for i16x16

type Output = i16x16

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<&i16> for i16x16

type Output = i16x16

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<&i16> for &i16x16

type Output = i16x16

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<&i16x16> for i16x16

type Output = i16x16

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<&i16x16> for i16

type Output = i16x16

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<&i16x16> for &i16x16

type Output = i16x16

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<&i16x16> for &i16

type Output = i16x16

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<i16> for i16x16

type Output = i16x16

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<i16> for &i16x16

type Output = i16x16

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<i16x16> for i16

type Output = i16x16

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<i16x16> for &i16x16

type Output = i16x16

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<i16x16> for &i16

type Output = i16x16

The resulting type after applying the + operator.

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

Performs the + operation.

impl AddAssign for i16x16

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl AddAssign<&i16> for i16x16

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

Performs the += operation.

impl AddAssign<&i16x16> for i16x16

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

Performs the += operation.

impl AddAssign<i16> for i16x16

fn add_assign(&mut self, rhs: i16)

Performs the += operation.

impl AlignTo for i16x16

type Elem = i16

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 i16x16

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

Formats the value using the given formatter.

impl BitAnd for i16x16

type Output = i16x16

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<&i16> for i16x16

type Output = i16x16

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<&i16> for &i16x16

type Output = i16x16

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<&i16x16> for i16x16

type Output = i16x16

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<&i16x16> for i16

type Output = i16x16

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<&i16x16> for &i16x16

type Output = i16x16

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<&i16x16> for &i16

type Output = i16x16

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<i16> for i16x16

type Output = i16x16

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<i16> for &i16x16

type Output = i16x16

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<i16x16> for i16

type Output = i16x16

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<i16x16> for &i16x16

type Output = i16x16

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<i16x16> for &i16

type Output = i16x16

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAndAssign for i16x16

fn bitand_assign(&mut self, rhs: Self)

Performs the &= operation.

impl BitAndAssign<&i16> for i16x16

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

Performs the &= operation.

impl BitAndAssign<&i16x16> for i16x16

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

Performs the &= operation.

impl BitAndAssign<i16> for i16x16

fn bitand_assign(&mut self, rhs: i16)

Performs the &= operation.

impl BitOr for i16x16

type Output = i16x16

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<&i16> for i16x16

type Output = i16x16

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<&i16> for &i16x16

type Output = i16x16

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<&i16x16> for i16x16

type Output = i16x16

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<&i16x16> for i16

type Output = i16x16

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<&i16x16> for &i16x16

type Output = i16x16

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<&i16x16> for &i16

type Output = i16x16

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<i16> for i16x16

type Output = i16x16

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<i16> for &i16x16

type Output = i16x16

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<i16x16> for i16

type Output = i16x16

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<i16x16> for &i16x16

type Output = i16x16

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<i16x16> for &i16

type Output = i16x16

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOrAssign for i16x16

fn bitor_assign(&mut self, rhs: Self)

Performs the |= operation.

impl BitOrAssign<&i16> for i16x16

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

Performs the |= operation.

impl BitOrAssign<&i16x16> for i16x16

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

Performs the |= operation.

impl BitOrAssign<i16> for i16x16

fn bitor_assign(&mut self, rhs: i16)

Performs the |= operation.

impl BitXor for i16x16

type Output = i16x16

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<&i16> for i16x16

type Output = i16x16

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<&i16> for &i16x16

type Output = i16x16

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<&i16x16> for i16x16

type Output = i16x16

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<&i16x16> for i16

type Output = i16x16

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<&i16x16> for &i16x16

type Output = i16x16

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<&i16x16> for &i16

type Output = i16x16

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<i16> for i16x16

type Output = i16x16

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<i16> for &i16x16

type Output = i16x16

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<i16x16> for i16

type Output = i16x16

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<i16x16> for &i16x16

type Output = i16x16

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<i16x16> for &i16

type Output = i16x16

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXorAssign for i16x16

fn bitxor_assign(&mut self, rhs: Self)

Performs the ^= operation.

impl BitXorAssign<&i16> for i16x16

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

Performs the ^= operation.

impl BitXorAssign<&i16x16> for i16x16

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

Performs the ^= operation.

impl BitXorAssign<i16> for i16x16

fn bitxor_assign(&mut self, rhs: i16)

Performs the ^= operation.

impl Clone for i16x16

fn clone(&self) -> i16x16

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl CmpEq for i16x16

type Output = i16x16

👎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<i16> for i16x16

type Output = i16x16

👎Deprecated since 1.5.0:

use the inherent function simd_eq instead

The type returned by simd_eq.

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

type Output = i16x16

👎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<i16> for i16x16

type Output = i16x16

👎Deprecated since 1.5.0:

use the inherent function simd_ge instead

The type returned by simd_ge.

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

type Output = i16x16

👎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<i16> for i16x16

type Output = i16x16

👎Deprecated since 1.5.0:

use the inherent function simd_gt instead

The type returned by simd_gt.

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

type Output = i16x16

👎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<i16> for i16x16

type Output = i16x16

👎Deprecated since 1.5.0:

use the inherent function simd_le instead

The type returned by simd_le.

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

type Output = i16x16

👎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<i16> for i16x16

type Output = i16x16

👎Deprecated since 1.5.0:

use the inherent function simd_lt instead

The type returned by simd_lt.

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

type Output = i16x16

👎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<i16> for i16x16

type Output = i16x16

👎Deprecated since 1.5.0:

use the inherent function simd_ne instead

The type returned by simd_ne.

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

impl Debug for i16x16

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

Formats the value using the given formatter.

impl Default for i16x16

fn default() -> i16x16

Returns the “default value” for a type.

impl Display for i16x16

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

Formats the value using the given formatter.

impl Div for i16x16

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

The resulting type after applying the / operator.

impl Div<&i16> for i16x16

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

The resulting type after applying the / operator.

impl Div<&i16> for &i16x16

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

The resulting type after applying the / operator.

impl Div<&i16x16> for i16x16

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

The resulting type after applying the / operator.

impl Div<&i16x16> for i16

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

The resulting type after applying the / operator.

impl Div<&i16x16> for &i16x16

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

The resulting type after applying the / operator.

impl Div<&i16x16> for &i16

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

The resulting type after applying the / operator.

impl Div<i16> for i16x16

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

The resulting type after applying the / operator.

impl Div<i16> for &i16x16

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

The resulting type after applying the / operator.

impl Div<i16x16> for i16

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

The resulting type after applying the / operator.

impl Div<i16x16> for &i16x16

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

The resulting type after applying the / operator.

impl Div<i16x16> for &i16

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

The resulting type after applying the / operator.

impl DivAssign for i16x16

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

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

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

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

fn div_assign(&mut self, rhs: i16)

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 i16x16

impl From<&[i16]> for i16x16

fn from(value: &[i16]) -> 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<[i16; 16]> for i16x16

fn from(arr: [i16; 16]) -> Self

Converts an array to a SIMD vector.

impl From<__m256i> for i16x16

Available on x86-64 only.

fn from(value: __m256i) -> Self

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

impl From<i8x16> for i16x16

fn from(i: i8x16) -> Self

widen with sign extend from i8 to i16

impl From<i16> for i16x16

fn from(elem: i16) -> Self

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

impl From<i16x16> for [i16; 16]

fn from(simd: i16x16) -> Self

Converts a SIMD vector to an array.

impl From<i16x16> for __m256i

Available on x86-64 only.

fn from(value: i16x16) -> Self

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

impl From<i16x16> for i32x16

fn from(value: i16x16) -> Self

Converts to this type from the input type.

impl From<u8x16> for i16x16

fn from(i: u8x16) -> Self

widen with zero extend from u8 to i16

impl LowerExp for i16x16

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

Formats the value using the given formatter.

impl LowerHex for i16x16

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

Formats the value using the given formatter.

impl Mul for i16x16

type Output = i16x16

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<&i16> for i16x16

type Output = i16x16

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<&i16> for &i16x16

type Output = i16x16

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<&i16x16> for i16x16

type Output = i16x16

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<&i16x16> for i16

type Output = i16x16

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<&i16x16> for &i16x16

type Output = i16x16

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<&i16x16> for &i16

type Output = i16x16

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<i16> for i16x16

type Output = i16x16

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<i16> for &i16x16

type Output = i16x16

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<i16x16> for i16

type Output = i16x16

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<i16x16> for &i16x16

type Output = i16x16

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<i16x16> for &i16

type Output = i16x16

The resulting type after applying the * operator.

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

Performs the * operation.

impl MulAssign for i16x16

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl MulAssign<&i16> for i16x16

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

Performs the *= operation.

impl MulAssign<&i16x16> for i16x16

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

Performs the *= operation.

impl MulAssign<i16> for i16x16

fn mul_assign(&mut self, rhs: i16)

Performs the *= operation.

impl Neg for i16x16

type Output = i16x16

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Neg for &i16x16

type Output = i16x16

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Not for i16x16

type Output = i16x16

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl Not for &i16x16

type Output = i16x16

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl Octal for i16x16

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

Formats the value using the given formatter.

impl PartialEq for i16x16

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

Equality operator ==.

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

Inequality operator !=.

impl Pod for i16x16

impl<Rhs> Product<Rhs> for i16x16

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

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

The resulting type after applying the % operator.

impl Rem<&i16> for i16x16

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

The resulting type after applying the % operator.

impl Rem<&i16> for &i16x16

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

The resulting type after applying the % operator.

impl Rem<&i16x16> for i16x16

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

The resulting type after applying the % operator.

impl Rem<&i16x16> for i16

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

The resulting type after applying the % operator.

impl Rem<&i16x16> for &i16x16

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

The resulting type after applying the % operator.

impl Rem<&i16x16> for &i16

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

The resulting type after applying the % operator.

impl Rem<i16> for i16x16

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

The resulting type after applying the % operator.

impl Rem<i16> for &i16x16

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

The resulting type after applying the % operator.

impl Rem<i16x16> for i16

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

The resulting type after applying the % operator.

impl Rem<i16x16> for &i16x16

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

The resulting type after applying the % operator.

impl Rem<i16x16> for &i16

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

The resulting type after applying the % operator.

impl RemAssign for i16x16

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

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

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

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

fn rem_assign(&mut self, rhs: i16)

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

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

Lanewise SIMD selection.

impl Select<i16x16> for u16x16

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

Lanewise SIMD selection.

impl Select<u16x16> for i16x16

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

Lanewise SIMD selection.

impl Shl for i16x16

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

The resulting type after applying the << operator.

impl Shl<&i8> for i16x16

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

The resulting type after applying the << operator.

impl Shl<&i8> for &i16x16

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

The resulting type after applying the << operator.

impl Shl<&i16> for i16x16

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

The resulting type after applying the << operator.

impl Shl<&i16> for &i16x16

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

The resulting type after applying the << operator.

impl Shl<&i16x16> for i16x16

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

The resulting type after applying the << operator.

impl Shl<&i16x16> for i16

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

The resulting type after applying the << operator.

impl Shl<&i16x16> for &i16x16

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

The resulting type after applying the << operator.

impl Shl<&i16x16> for &i16

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

The resulting type after applying the << operator.

impl Shl<&i16x16> for u16x16

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

The resulting type after applying the << operator.

impl Shl<&i16x16> for u16

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

The resulting type after applying the << operator.

impl Shl<&i16x16> for &u16x16

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

The resulting type after applying the << operator.

impl Shl<&i16x16> for &u16

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

The resulting type after applying the << operator.

impl Shl<&i32> for i16x16

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

The resulting type after applying the << operator.

impl Shl<&i32> for &i16x16

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

The resulting type after applying the << operator.

impl Shl<&i64> for i16x16

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

The resulting type after applying the << operator.

impl Shl<&i64> for &i16x16

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

The resulting type after applying the << operator.

impl Shl<&i128> for i16x16

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

The resulting type after applying the << operator.

impl Shl<&i128> for &i16x16

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

The resulting type after applying the << operator.

impl Shl<&isize> for i16x16

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

The resulting type after applying the << operator.

impl Shl<&isize> for &i16x16

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

The resulting type after applying the << operator.

impl Shl<&u8> for i16x16

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

The resulting type after applying the << operator.

impl Shl<&u8> for &i16x16

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

The resulting type after applying the << operator.

impl Shl<&u16> for i16x16

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

The resulting type after applying the << operator.

impl Shl<&u16> for &i16x16

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

The resulting type after applying the << operator.

impl Shl<&u16x16> for i16x16

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

The resulting type after applying the << operator.

impl Shl<&u16x16> for &i16x16

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

The resulting type after applying the << operator.

impl Shl<&u32> for i16x16

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

The resulting type after applying the << operator.

impl Shl<&u32> for &i16x16

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

The resulting type after applying the << operator.

impl Shl<&u64> for i16x16

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

The resulting type after applying the << operator.

impl Shl<&u64> for &i16x16

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

The resulting type after applying the << operator.

impl Shl<&u128> for i16x16

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

The resulting type after applying the << operator.

impl Shl<&u128> for &i16x16

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

The resulting type after applying the << operator.

impl Shl<&usize> for i16x16

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

The resulting type after applying the << operator.

impl Shl<&usize> for &i16x16

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

The resulting type after applying the << operator.

impl Shl<i8> for i16x16

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

The resulting type after applying the << operator.

impl Shl<i8> for &i16x16

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

The resulting type after applying the << operator.

impl Shl<i16> for i16x16

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

The resulting type after applying the << operator.

impl Shl<i16> for &i16x16

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

The resulting type after applying the << operator.

impl Shl<i16x16> for i16

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

The resulting type after applying the << operator.

impl Shl<i16x16> for &i16x16

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

The resulting type after applying the << operator.

impl Shl<i16x16> for &i16

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

The resulting type after applying the << operator.

impl Shl<i16x16> for u16x16

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

The resulting type after applying the << operator.

impl Shl<i16x16> for u16

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

The resulting type after applying the << operator.

impl Shl<i16x16> for &u16x16

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

The resulting type after applying the << operator.

impl Shl<i16x16> for &u16

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

The resulting type after applying the << operator.

impl Shl<i32> for i16x16

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

The resulting type after applying the << operator.

impl Shl<i32> for &i16x16

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

The resulting type after applying the << operator.

impl Shl<i64> for i16x16

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

The resulting type after applying the << operator.

impl Shl<i64> for &i16x16

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

The resulting type after applying the << operator.

impl Shl<i128> for i16x16

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

The resulting type after applying the << operator.

impl Shl<i128> for &i16x16

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

The resulting type after applying the << operator.

impl Shl<isize> for i16x16

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

The resulting type after applying the << operator.

impl Shl<isize> for &i16x16

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

The resulting type after applying the << operator.

impl Shl<u8> for i16x16

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

The resulting type after applying the << operator.

impl Shl<u8> for &i16x16

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

The resulting type after applying the << operator.

impl Shl<u16> for i16x16

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

The resulting type after applying the << operator.

impl Shl<u16> for &i16x16

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

The resulting type after applying the << operator.

impl Shl<u16x16> for i16x16

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

The resulting type after applying the << operator.

impl Shl<u16x16> for &i16x16

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

The resulting type after applying the << operator.

impl Shl<u32> for i16x16

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

The resulting type after applying the << operator.

impl Shl<u32> for &i16x16

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

The resulting type after applying the << operator.

impl Shl<u64> for i16x16

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

The resulting type after applying the << operator.

impl Shl<u64> for &i16x16

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

The resulting type after applying the << operator.

impl Shl<u128> for i16x16

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

The resulting type after applying the << operator.

impl Shl<u128> for &i16x16

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

The resulting type after applying the << operator.

impl Shl<usize> for i16x16

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

The resulting type after applying the << operator.

impl Shl<usize> for &i16x16

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

The resulting type after applying the << operator.

impl ShlAssign for i16x16

fn shl_assign(&mut self, rhs: i16x16)

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 i16x16

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

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

This operator behaves like wrapping_shl.

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

impl ShlAssign<&i16> for i16x16

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

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

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<&i16x16> for u16x16

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

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

This operator behaves like wrapping_shl.

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

impl ShlAssign<&i32> for i16x16

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 i16x16

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 i16x16

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 i16x16

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 i16x16

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

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

This operator behaves like wrapping_shl.

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

impl ShlAssign<&u16> for i16x16

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<&u16x16> for i16x16

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

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

This operator behaves like wrapping_shl.

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

impl ShlAssign<&u32> for i16x16

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 i16x16

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 i16x16

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 i16x16

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 i16x16

fn shl_assign(&mut self, rhs: i8)

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

This operator behaves like wrapping_shl.

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

impl ShlAssign<i16> for i16x16

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<i16x16> for u16x16

fn shl_assign(&mut self, rhs: i16x16)

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

This operator behaves like wrapping_shl.

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

impl ShlAssign<i32> for i16x16

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 i16x16

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 i16x16

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 i16x16

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 i16x16

fn shl_assign(&mut self, rhs: u8)

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

This operator behaves like wrapping_shl.

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

impl ShlAssign<u16> for i16x16

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<u16x16> for i16x16

fn shl_assign(&mut self, rhs: u16x16)

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

This operator behaves like wrapping_shl.

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

impl ShlAssign<u32> for i16x16

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 i16x16

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 i16x16

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 i16x16

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 i16x16

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

The resulting type after applying the >> operator.

impl Shr<&i8> for i16x16

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

The resulting type after applying the >> operator.

impl Shr<&i8> for &i16x16

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

The resulting type after applying the >> operator.

impl Shr<&i16> for i16x16

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

The resulting type after applying the >> operator.

impl Shr<&i16> for &i16x16

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

The resulting type after applying the >> operator.

impl Shr<&i16x16> for i16x16

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

The resulting type after applying the >> operator.

impl Shr<&i16x16> for i16

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

The resulting type after applying the >> operator.

impl Shr<&i16x16> for &i16x16

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

The resulting type after applying the >> operator.

impl Shr<&i16x16> for &i16

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

The resulting type after applying the >> operator.

impl Shr<&i16x16> for u16x16

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

The resulting type after applying the >> operator.

impl Shr<&i16x16> for u16

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

The resulting type after applying the >> operator.

impl Shr<&i16x16> for &u16x16

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

The resulting type after applying the >> operator.

impl Shr<&i16x16> for &u16

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

The resulting type after applying the >> operator.

impl Shr<&i32> for i16x16

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

The resulting type after applying the >> operator.

impl Shr<&i32> for &i16x16

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

The resulting type after applying the >> operator.

impl Shr<&i64> for i16x16

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

The resulting type after applying the >> operator.

impl Shr<&i64> for &i16x16

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

The resulting type after applying the >> operator.

impl Shr<&i128> for i16x16

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

The resulting type after applying the >> operator.

impl Shr<&i128> for &i16x16

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

The resulting type after applying the >> operator.

impl Shr<&isize> for i16x16

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

The resulting type after applying the >> operator.

impl Shr<&isize> for &i16x16

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

The resulting type after applying the >> operator.

impl Shr<&u8> for i16x16

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

The resulting type after applying the >> operator.

impl Shr<&u8> for &i16x16

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

The resulting type after applying the >> operator.

impl Shr<&u16> for i16x16

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

The resulting type after applying the >> operator.

impl Shr<&u16> for &i16x16

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

The resulting type after applying the >> operator.

impl Shr<&u16x16> for i16x16

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

The resulting type after applying the >> operator.

impl Shr<&u16x16> for &i16x16

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

The resulting type after applying the >> operator.

impl Shr<&u32> for i16x16

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

The resulting type after applying the >> operator.

impl Shr<&u32> for &i16x16

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

The resulting type after applying the >> operator.

impl Shr<&u64> for i16x16

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

The resulting type after applying the >> operator.

impl Shr<&u64> for &i16x16

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

The resulting type after applying the >> operator.

impl Shr<&u128> for i16x16

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

The resulting type after applying the >> operator.

impl Shr<&u128> for &i16x16

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

The resulting type after applying the >> operator.

impl Shr<&usize> for i16x16

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

The resulting type after applying the >> operator.

impl Shr<&usize> for &i16x16

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

The resulting type after applying the >> operator.

impl Shr<i8> for i16x16

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

The resulting type after applying the >> operator.

impl Shr<i8> for &i16x16

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

The resulting type after applying the >> operator.

impl Shr<i16> for i16x16

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

The resulting type after applying the >> operator.

impl Shr<i16> for &i16x16

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

The resulting type after applying the >> operator.

impl Shr<i16x16> for i16

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

The resulting type after applying the >> operator.

impl Shr<i16x16> for &i16x16

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

The resulting type after applying the >> operator.

impl Shr<i16x16> for &i16

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

The resulting type after applying the >> operator.

impl Shr<i16x16> for u16x16

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

The resulting type after applying the >> operator.

impl Shr<i16x16> for u16

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

The resulting type after applying the >> operator.

impl Shr<i16x16> for &u16x16

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

The resulting type after applying the >> operator.

impl Shr<i16x16> for &u16

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

The resulting type after applying the >> operator.

impl Shr<i32> for i16x16

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

The resulting type after applying the >> operator.

impl Shr<i32> for &i16x16

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

The resulting type after applying the >> operator.

impl Shr<i64> for i16x16

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

The resulting type after applying the >> operator.

impl Shr<i64> for &i16x16

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

The resulting type after applying the >> operator.

impl Shr<i128> for i16x16

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

The resulting type after applying the >> operator.

impl Shr<i128> for &i16x16

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

The resulting type after applying the >> operator.

impl Shr<isize> for i16x16

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

The resulting type after applying the >> operator.

impl Shr<isize> for &i16x16

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

The resulting type after applying the >> operator.

impl Shr<u8> for i16x16

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

The resulting type after applying the >> operator.

impl Shr<u8> for &i16x16

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

The resulting type after applying the >> operator.

impl Shr<u16> for i16x16

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

The resulting type after applying the >> operator.

impl Shr<u16> for &i16x16

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

The resulting type after applying the >> operator.

impl Shr<u16x16> for i16x16

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

The resulting type after applying the >> operator.

impl Shr<u16x16> for &i16x16

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

The resulting type after applying the >> operator.

impl Shr<u32> for i16x16

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

The resulting type after applying the >> operator.

impl Shr<u32> for &i16x16

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

The resulting type after applying the >> operator.

impl Shr<u64> for i16x16

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

The resulting type after applying the >> operator.

impl Shr<u64> for &i16x16

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

The resulting type after applying the >> operator.

impl Shr<u128> for i16x16

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

The resulting type after applying the >> operator.

impl Shr<u128> for &i16x16

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

The resulting type after applying the >> operator.

impl Shr<usize> for i16x16

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

The resulting type after applying the >> operator.

impl Shr<usize> for &i16x16

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

The resulting type after applying the >> operator.

impl ShrAssign for i16x16

fn shr_assign(&mut self, rhs: i16x16)

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 i16x16

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

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

This operator behaves like wrapping_shr.

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

impl ShrAssign<&i16> for i16x16

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

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

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<&i16x16> for u16x16

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

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

This operator behaves like wrapping_shr.

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

impl ShrAssign<&i32> for i16x16

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 i16x16

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 i16x16

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 i16x16

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 i16x16

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

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

This operator behaves like wrapping_shr.

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

impl ShrAssign<&u16> for i16x16

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<&u16x16> for i16x16

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

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

This operator behaves like wrapping_shr.

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

impl ShrAssign<&u32> for i16x16

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 i16x16

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 i16x16

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 i16x16

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 i16x16

fn shr_assign(&mut self, rhs: i8)

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

This operator behaves like wrapping_shr.

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

impl ShrAssign<i16> for i16x16

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<i16x16> for u16x16

fn shr_assign(&mut self, rhs: i16x16)

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

This operator behaves like wrapping_shr.

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

impl ShrAssign<i32> for i16x16

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 i16x16

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 i16x16

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 i16x16

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 i16x16

fn shr_assign(&mut self, rhs: u8)

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

This operator behaves like wrapping_shr.

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

impl ShrAssign<u16> for i16x16

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<u16x16> for i16x16

fn shr_assign(&mut self, rhs: u16x16)

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

This operator behaves like wrapping_shr.

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

impl ShrAssign<u32> for i16x16

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 i16x16

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 i16x16

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 i16x16

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 i16x16

impl Sub for i16x16

type Output = i16x16

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<&i16> for i16x16

type Output = i16x16

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<&i16> for &i16x16

type Output = i16x16

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<&i16x16> for i16x16

type Output = i16x16

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<&i16x16> for i16

type Output = i16x16

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<&i16x16> for &i16x16

type Output = i16x16

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<&i16x16> for &i16

type Output = i16x16

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<i16> for i16x16

type Output = i16x16

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<i16> for &i16x16

type Output = i16x16

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<i16x16> for i16

type Output = i16x16

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<i16x16> for &i16x16

type Output = i16x16

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<i16x16> for &i16

type Output = i16x16

The resulting type after applying the - operator.

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

Performs the - operation.

impl SubAssign for i16x16

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl SubAssign<&i16> for i16x16

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

Performs the -= operation.

impl SubAssign<&i16x16> for i16x16

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

Performs the -= operation.

impl SubAssign<i16> for i16x16

fn sub_assign(&mut self, rhs: i16)

Performs the -= operation.

impl<Rhs> Sum<Rhs> for i16x16

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

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

Formats the value using the given formatter.

impl UpperHex for i16x16

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

Formats the value using the given formatter.

impl Zeroable for i16x16

fn zeroed() -> Self

Calls zeroed.