Struct I8x1 

pub struct I8x1(pub i8);

Tuple Fields

0: i8

Trait Implementations

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

type Output = I8x1

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = I8x1

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add for I8x1

type Output = I8x1

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

Performs the += operation.

impl AddAssign for I8x1

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

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

type Output = I8x1

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd for I8x1

type Output = I8x1

The resulting type after applying the & operator.

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

Performs the & operation.

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

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

Performs the &= operation.

impl BitAndAssign for I8x1

fn bitand_assign(&mut self, rhs: Self)

Performs the &= operation.

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

type Output = I8x1

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr for I8x1

type Output = I8x1

The resulting type after applying the | operator.

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

Performs the | operation.

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

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

Performs the |= operation.

impl BitOrAssign for I8x1

fn bitor_assign(&mut self, rhs: Self)

Performs the |= operation.

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

type Output = I8x1

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor for I8x1

type Output = I8x1

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

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

Performs the ^= operation.

impl BitXorAssign for I8x1

fn bitxor_assign(&mut self, rhs: Self)

Performs the ^= operation.

impl Clone for I8x1

fn clone(&self) -> I8x1

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for I8x1

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

Formats the value using the given formatter.

impl From<I8x1> for i8

fn from(v: I8x1) -> i8

Converts to this type from the input type.

impl From<i8> for I8x1

fn from(val: i8) -> Self

Converts to this type from the input type.

impl Index<usize> for I8x1

type Output = <I8x1 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 I8x1

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

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

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

type Output = I8x1

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = I8x1

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul for I8x1

type Output = I8x1

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

Performs the *= operation.

impl MulAssign for I8x1

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl Neg for I8x1

type Output = I8x1

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

impl Not for I8x1

type Output = I8x1

The resulting type after applying the ! operator.

fn not(self) -> Self

Performs the unary ! operation.

impl Shl<i32> for I8x1

type Output = I8x1

The resulting type after applying the << operator.

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

Performs the << operation.

impl ShlAssign<i32> for I8x1

fn shl_assign(&mut self, rhs: i32)

Performs the <<= operation.

impl Shr<i32> for I8x1

type Output = I8x1

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl ShrAssign<i32> for I8x1

fn shr_assign(&mut self, rhs: i32)

Performs the >>= operation.

impl SimdBaseIo for I8x1

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 I8x1

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 I8x1

const WIDTH: usize = 1usize

type Scalar = i8

type HorizontalAddScalar = i64

type ArrayRepresentation = [i8; 1]

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

The underlying intrinsic SIMD type.

type Engine = Scalar

impl SimdInt for I8x1

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 SimdInt8 for I8x1

fn extend_to_i16( self, ) -> (<Self::Engine as Simd>::Vi16, <Self::Engine as Simd>::Vi16)

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

fn unsigned_extend_to_i16( self, ) -> (<Self::Engine as Simd>::Vi16, <Self::Engine as Simd>::Vi16)

Splits the vector into two halves, then extends them both to be i16. 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 get_mask(self) -> u32

Gets the “mask” of a vector, where each bit in the u32 represents whether the value at that location is truthy. A value is truthy either if the highest bit is one, or if any bit is one, depending on the instruction set being used. Please always make sure at least the highest bit is set to 1.

fn is_truthy(self) -> bool

Checks if all elements in the vector are truthy. A value is truthy either if the highest bit is one, or if any bit is one, depending on the instruction set being used. Please always make sure at least the highest bit is set to 1.

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

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

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

Adds (arbitrary) pairs of values in the vector, returning a i16 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.

fn is_any_truthy(self) -> bool

Checks if any element in the vector is truthy. A value is truthy either if the highest bit is one, or if any bit is one, depending on the instruction set being used. Please always make sure at least the highest bit is set to 1.

fn index_of_last_truthy(self) -> Option<usize>

Grabs the index of the last value that matches the given value. If no value matches, returns None. Index will always be smaller than Self::WIDTH.

fn index_of_last_falsy(self) -> Option<usize>

Grabs the index of the last value that matches the given value. If no value matches, returns None. Index will always be smaller than Self::WIDTH.

fn index_of_first_truthy(self) -> Option<usize>

Grabs the index of the first value that matches the given value. If no value matches, returns None. Index will always be smaller than Self::WIDTH.

fn index_of_first_falsy(self) -> Option<usize>

Grabs the index of the first value that matches the given value. If no value matches, returns None. Index will always be smaller than Self::WIDTH.

fn index_of_first_eq(self, value: i8) -> Option<usize>

Grabs the index of the first value that matches the given value. If no value matches, returns None. Index will always be smaller than Self::WIDTH.

impl SimdTransmuteI8 for I8x1

fn try_transmute_scalar(&self) -> i8

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

fn try_transmute_from_scalar(val: i8) -> 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_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(_avx2: __m256i) -> Self

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

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

type Output = I8x1

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = I8x1

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub for I8x1

type Output = I8x1

The resulting type after applying the - operator.

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

Performs the - operation.

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

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

Performs the -= operation.

impl SubAssign for I8x1

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl Copy for I8x1