Struct I32x1 

pub struct I32x1(pub i32);

Tuple Fields

0: i32

Trait Implementations

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

type Output = I32x1

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = I32x1

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add for I32x1

type Output = I32x1

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

Performs the += operation.

impl AddAssign for I32x1

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

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

type Output = I32x1

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd for I32x1

type Output = I32x1

The resulting type after applying the & operator.

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

Performs the & operation.

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

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

Performs the &= operation.

impl BitAndAssign for I32x1

fn bitand_assign(&mut self, rhs: Self)

Performs the &= operation.

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

type Output = I32x1

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr for I32x1

type Output = I32x1

The resulting type after applying the | operator.

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

Performs the | operation.

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

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

Performs the |= operation.

impl BitOrAssign for I32x1

fn bitor_assign(&mut self, rhs: Self)

Performs the |= operation.

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

type Output = I32x1

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor for I32x1

type Output = I32x1

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

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

Performs the ^= operation.

impl BitXorAssign for I32x1

fn bitxor_assign(&mut self, rhs: Self)

Performs the ^= operation.

impl Clone for I32x1

fn clone(&self) -> I32x1

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for I32x1

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

Formats the value using the given formatter.

impl From<I32x1> for i32

fn from(v: I32x1) -> i32

Converts to this type from the input type.

impl From<i32> for I32x1

fn from(val: i32) -> Self

Converts to this type from the input type.

impl Index<usize> for I32x1

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

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

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

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

type Output = I32x1

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = I32x1

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul for I32x1

type Output = I32x1

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

Performs the *= operation.

impl MulAssign for I32x1

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl Neg for I32x1

type Output = I32x1

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

impl Not for I32x1

type Output = I32x1

The resulting type after applying the ! operator.

fn not(self) -> Self

Performs the unary ! operation.

impl Shl<i32> for I32x1

type Output = I32x1

The resulting type after applying the << operator.

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

Performs the << operation.

impl ShlAssign<i32> for I32x1

fn shl_assign(&mut self, rhs: i32)

Performs the <<= operation.

impl Shr<i32> for I32x1

type Output = I32x1

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl ShrAssign<i32> for I32x1

fn shr_assign(&mut self, rhs: i32)

Performs the >>= operation.

impl SimdBaseIo for I32x1

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 I32x1

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 I32x1

const WIDTH: usize = 1usize

type Scalar = i32

type HorizontalAddScalar = i64

type ArrayRepresentation = [i32; 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 = i32

The underlying intrinsic SIMD type.

type Engine = Scalar

impl SimdInt for I32x1

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 SimdInt32 for I32x1

fn bitcast_f32(self) -> <Self::Engine as Simd>::Vf32

Bit cast to f32. This function is only used for compilation and does not generate any instructions, thus it has zero latency.

fn cast_f32(self) -> <Self::Engine as Simd>::Vf32

Element-wise cast to f32

fn extend_to_i64( self, ) -> (<Self::Engine as Simd>::Vi64, <Self::Engine as Simd>::Vi64)

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

fn unsigned_extend_to_i64( self, ) -> (<Self::Engine as Simd>::Vi64, <Self::Engine as Simd>::Vi64)

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>::Vi64

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

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

Adds (arbitrary) pairs of values in the vector, returning a i64 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 SimdTransmuteI32 for I32x1

fn try_transmute_scalar(&self) -> i32

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

fn try_transmute_from_scalar(val: i32) -> 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<<I32x1 as SimdConsts>::Scalar> for I32x1

type Output = I32x1

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = I32x1

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub for I32x1

type Output = I32x1

The resulting type after applying the - operator.

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

Performs the - operation.

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

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

Performs the -= operation.

impl SubAssign for I32x1

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl Copy for I32x1