Struct I16x16 

pub struct I16x16(/* private fields */);

Trait Implementations

impl Add<<I16x16 as SimdConsts>::Scalar> for I16x16

type Output = I16x16

The resulting type after applying the + operator.

fn add(self, rhs: <Self as SimdConsts>::Scalar) -> Self

Performs the + operation.

impl Add<I16x16> for <I16x16 as SimdConsts>::Scalar

type Output = I16x16

The resulting type after applying the + operator.

fn add(self, rhs: I16x16) -> I16x16

Performs the + operation.

impl Add for I16x16

type Output = I16x16

The resulting type after applying the + operator.

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

Performs the + operation.

impl AddAssign<<I16x16 as SimdConsts>::Scalar> for I16x16

fn add_assign(&mut self, rhs: <Self as SimdConsts>::Scalar)

Performs the += operation.

impl AddAssign for I16x16

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl BitAnd<<I16x16 as SimdConsts>::Scalar> for I16x16

type Output = I16x16

The resulting type after applying the & operator.

fn bitand(self, rhs: <Self as SimdConsts>::Scalar) -> Self

Performs the & operation.

impl BitAnd for I16x16

type Output = I16x16

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAndAssign<<I16x16 as SimdConsts>::Scalar> for I16x16

fn bitand_assign(&mut self, rhs: <Self as SimdConsts>::Scalar)

Performs the &= operation.

impl BitAndAssign for I16x16

fn bitand_assign(&mut self, rhs: Self)

Performs the &= operation.

impl BitOr<<I16x16 as SimdConsts>::Scalar> for I16x16

type Output = I16x16

The resulting type after applying the | operator.

fn bitor(self, rhs: <Self as SimdConsts>::Scalar) -> Self

Performs the | operation.

impl BitOr for I16x16

type Output = I16x16

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOrAssign<<I16x16 as SimdConsts>::Scalar> for I16x16

fn bitor_assign(&mut self, rhs: <Self as SimdConsts>::Scalar)

Performs the |= operation.

impl BitOrAssign for I16x16

fn bitor_assign(&mut self, rhs: Self)

Performs the |= operation.

impl BitXor<<I16x16 as SimdConsts>::Scalar> for I16x16

type Output = I16x16

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: <Self as SimdConsts>::Scalar) -> Self

Performs the ^ operation.

impl BitXor for I16x16

type Output = I16x16

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXorAssign<<I16x16 as SimdConsts>::Scalar> for I16x16

fn bitxor_assign(&mut self, rhs: <Self as SimdConsts>::Scalar)

Performs the ^= operation.

impl BitXorAssign for I16x16

fn bitxor_assign(&mut self, rhs: Self)

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 Debug for I16x16

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

Formats the value using the given formatter.

impl Index<usize> for I16x16

type Output = <I16x16 as SimdConsts>::Scalar

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl IndexMut<usize> for I16x16

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

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

impl Mul<<I16x16 as SimdConsts>::Scalar> for I16x16

type Output = I16x16

The resulting type after applying the * operator.

fn mul(self, rhs: <Self as SimdConsts>::Scalar) -> Self

Performs the * operation.

impl Mul<I16x16> for <I16x16 as SimdConsts>::Scalar

type Output = I16x16

The resulting type after applying the * operator.

fn mul(self, rhs: I16x16) -> I16x16

Performs the * operation.

impl Mul for I16x16

type Output = I16x16

The resulting type after applying the * operator.

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

Performs the * operation.

impl MulAssign<<I16x16 as SimdConsts>::Scalar> for I16x16

fn mul_assign(&mut self, rhs: <Self as SimdConsts>::Scalar)

Performs the *= operation.

impl MulAssign for I16x16

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl Neg for I16x16

type Output = I16x16

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

impl Not for I16x16

type Output = I16x16

The resulting type after applying the ! operator.

fn not(self) -> Self

Performs the unary ! operation.

impl Shl<i32> for I16x16

type Output = I16x16

The resulting type after applying the << operator.

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

Performs the << operation.

impl ShlAssign<i32> for I16x16

fn shl_assign(&mut self, rhs: i32)

Performs the <<= operation.

impl Shr<i32> for I16x16

type Output = I16x16

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl ShrAssign<i32> for I16x16

fn shr_assign(&mut self, rhs: i32)

Performs the >>= operation.

impl SimdBaseIo for I16x16

fn zeroes() -> Self

Initialize a vector with all elements set to zero

fn set1(x: Self::Scalar) -> Self

Initialize a vector with all elements set to the same value

unsafe fn load_from_array(array: Self::ArrayRepresentation) -> Self

unsafe fn load_from_ptr_unaligned(ptr: *const Self::Scalar) -> Self

Load a vector from an unaligned raw pointer.

unsafe fn copy_to_ptr_unaligned(self, ptr: *mut Self::Scalar)

Store a vector to an unaligned raw pointer.

unsafe fn load_from_ptr_aligned(ptr: *const Self::Scalar) -> Self

Load a vector from a 32 bit aligned raw pointer.

unsafe fn copy_to_ptr_aligned(self, ptr: *mut Self::Scalar)

Store a vector to a 32 bit aligned raw pointer.

unsafe fn underlying_value(self) -> Self::UnderlyingType

unsafe fn underlying_value_mut(&mut self) -> &mut Self::UnderlyingType

unsafe fn from_underlying_value(value: Self::UnderlyingType) -> Self

unsafe fn transmute_into_array_ref(&self) -> &Self::ArrayRepresentation

Transmutes the vector into a array representation defined by Self::ArrayRepresentation. Please don’t use this function directly unless necessary.

unsafe fn transmute_into_array_mut(&mut self) -> &mut Self::ArrayRepresentation

Transmutes the vector into a mutable array representation defined by Self::ArrayRepresentation. Please don’t use this function directly unless necessary.

unsafe fn as_array(&self) -> Self::ArrayRepresentation

unsafe fn get_unchecked(&self, index: usize) -> Self::Scalar

Gets the value at the specified index, without a bounds check.

unsafe fn get_unchecked_mut<'a>(&mut self, index: usize) -> &'a mut Self::Scalar

Gets the value at the specified index, without a bounds check.

fn load_from_slice_exact(slice: &[Self::Scalar]) -> Result<Self, usize>

Tries to load from a slice. If the slice is too short, it returns the length of the slice.

fn load_from_slice(slice: &[Self::Scalar]) -> Self

Tries to load from a slice. If the slice is too short, it uses zeroes for the remaining values.

fn copy_to_slice_exact(self, slice: &mut [Self::Scalar]) -> Result<(), usize>

Tries to copy to a slice. If the slice is too short, it returns the length of the slice.

fn copy_to_slice(self, slice: &mut [Self::Scalar])

Tries to copy to a slice. If the slice is too short, it copies as much as possible until the end of the slice.

impl SimdBaseOps for I16x16

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

Element-wise add between two vectors

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

Element-wise subtract between two vectors

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

Element-wise multiply between two vectors

fn bit_and(self, rhs: Self) -> Self

Binary and between two vectors

fn bit_or(self, rhs: Self) -> Self

Binary or between two vectors

fn bit_xor(self, rhs: Self) -> Self

Binary xor between two vectors

fn bit_not(self) -> Self

Binary not operation for a vector

fn abs(self) -> Self

Element-wise absolute value.

fn and_not(self, rhs: Self) -> Self

Binary and not between two vectors self & (!rhs)

fn blendv(self, a: Self, b: Self) -> Self

Element-wise “blend” between two vectors. A is selected if the mask value is zero, and B is selected if the mask value is all 1’s. undefined behavior if it’s anything in between. See note below.

fn cmp_eq(self, rhs: Self) -> Self

Element-wise equality between two vectors. If two elements are equal, it returns all 1’s in the corresponding element of the result, otherwise it returns all 0’s.

fn cmp_neq(self, rhs: Self) -> Self

Element-wise inequality between two vectors. If two elements are not equal, it returns all 1’s in the corresponding element of the result, otherwise it returns all 0’s.

fn cmp_lt(self, rhs: Self) -> Self

Element-wise less than between two vectors. If the first element is less than the second element, it returns all 1’s in the corresponding element of the result, otherwise it returns all 0’s.

fn cmp_lte(self, rhs: Self) -> Self

Element-wise less than or equal to between two vectors. If the first element is less than or equal to the second element, it returns all 1’s in the corresponding element of the result, otherwise it returns all 0’s.

fn cmp_gt(self, rhs: Self) -> Self

Element-wise greater than between two vectors. If the first element is greater than the second element, it returns all 1’s in the corresponding element of the result, otherwise it returns all 0’s.

fn cmp_gte(self, rhs: Self) -> Self

Element-wise greater than or equal to between two vectors. If the first element is greater than or equal to the second element, it returns all 1’s in the corresponding element of the result, otherwise it returns all 0’s.

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

Element-wise maximum between two vectors.

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

Element-wise minimum between two vectors.

fn horizontal_add(self) -> Self::HorizontalAddScalar

Add every number in the vector together

fn neg(self) -> Self

Element-wise negative of all elements

impl SimdConsts for I16x16

const WIDTH: usize = 16

type Scalar = i16

type HorizontalAddScalar = i64

type ArrayRepresentation = [i16; 16]

The type of the transmuted array representation. This is to make indexing operations easier. We are unable to use &[Self::Scalar; Self::WIDTH] because constants are not allowed.

type UnderlyingType = __m256i

The underlying intrinsic SIMD type.

type Engine = Avx2

impl SimdInt for I16x16

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

Shift each value left by n bits.

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

Shift each value right by n bits.

fn shl_const<const BY: i32>(self) -> Self

Shift each value left by a constant n bits. This operation is faster in some instruction sets.

fn shr_const<const BY: i32>(self) -> Self

Shift each value right by a constant n bits. This operation is faster in some instruction sets.

fn horizontal_unsigned_add(self) -> Self::HorizontalAddScalar

Add every number in the vector together in unsigned arithmetic. When expanding the size of each number, it treats the numbers as unsigned, meaning the sign bit doesn’t get moved around.

fn from_i64(value: i64) -> Self

impl SimdInt16 for I16x16

fn extend_to_i32( self, ) -> (<Self::Engine as Simd>::Vi32, <Self::Engine as Simd>::Vi32)

Splits the vector into two halves, then extends them both to be i32. This is useful for horizontal adding.

fn unsigned_extend_to_i32( self, ) -> (<Self::Engine as Simd>::Vi32, <Self::Engine as Simd>::Vi32)

Splits the vector into two halves, then extends them both to be i32. This is useful for horizontal adding. The numbers are treated as unsigned, so the sign bit isn’t moved. This is more efficient on some instruction sets.

fn partial_horizontal_add(self) -> <Self::Engine as Simd>::Vi32

Adds (arbitrary) pairs of values in the vector, returning a i32 version of the vector. The way the pairs are chosen is implementation-defined.

fn partial_horizontal_unsigned_add(self) -> <Self::Engine as Simd>::Vi32

Adds (arbitrary) pairs of values in the vector, returning a i32 version of the vector. When extending the numbers, they’re treated as unsigned wich performs more efficiently on some instruction sets. The way the pairs are chosen is implementation-defined.

impl SimdTransmuteI16 for I16x16

fn try_transmute_avx2(&self) -> __m256i

Tries to transmute the value into its underlying Avx2 type. Panics if the value is not a Avx2.

fn try_transmute_from_avx2(val: __m256i) -> Self

Tries to create the value from its underlying Avx2 type. Panics if the value is not a Avx2.

fn try_transmute_scalar(&self) -> i16

Tries to transmute the value into its underlying scalar type. Panics if the value is not a scalar.

fn try_transmute_from_scalar(_scalar: i16) -> Self

Tries to create the value from its underlying scalar type. Panics if the value is not a scalar.

fn try_transmute_sse2(&self) -> __m128i

Tries to transmute the value into its underlying Sse2 type. Panics if the value is not a Sse2.

fn try_transmute_from_sse2(_sse2: __m128i) -> Self

Tries to create the value from its underlying Sse2 type. Panics if the value is not a Sse2.

fn try_transmute_sse41(&self) -> __m128i

Tries to transmute the value into its underlying Sse4.1 type. Panics if the value is not a Sse4.1.

fn try_transmute_from_sse41(_sse41: __m128i) -> Self

Tries to create the value from its underlying Sse4.1 type. Panics if the value is not a Sse4.1.

fn try_transmute_avx512(&self) -> __m512i

Tries to transmute the value into its underlying Avx512 type. Panics if the value is not a Avx512.

fn try_transmute_from_avx512(_avx512: __m512i) -> Self

Tries to create the value from its underlying Avx512 type. Panics if the value is not a Avx512.

impl Sub<<I16x16 as SimdConsts>::Scalar> for I16x16

type Output = I16x16

The resulting type after applying the - operator.

fn sub(self, rhs: <Self as SimdConsts>::Scalar) -> Self

Performs the - operation.

impl Sub<I16x16> for <I16x16 as SimdConsts>::Scalar

type Output = I16x16

The resulting type after applying the - operator.

fn sub(self, rhs: I16x16) -> I16x16

Performs the - operation.

impl Sub for I16x16

type Output = I16x16

The resulting type after applying the - operator.

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

Performs the - operation.

impl SubAssign<<I16x16 as SimdConsts>::Scalar> for I16x16

fn sub_assign(&mut self, rhs: <Self as SimdConsts>::Scalar)

Performs the -= operation.

impl SubAssign for I16x16

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl Copy for I16x16