Struct I64x1 

pub struct I64x1(pub i64);

Tuple Fields

0: i64

Trait Implementations

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

type Output = I64x1

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = I64x1

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add for I64x1

type Output = I64x1

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

Performs the += operation.

impl AddAssign for I64x1

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

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

type Output = I64x1

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd for I64x1

type Output = I64x1

The resulting type after applying the & operator.

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

Performs the & operation.

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

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

Performs the &= operation.

impl BitAndAssign for I64x1

fn bitand_assign(&mut self, rhs: Self)

Performs the &= operation.

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

type Output = I64x1

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr for I64x1

type Output = I64x1

The resulting type after applying the | operator.

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

Performs the | operation.

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

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

Performs the |= operation.

impl BitOrAssign for I64x1

fn bitor_assign(&mut self, rhs: Self)

Performs the |= operation.

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

type Output = I64x1

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor for I64x1

type Output = I64x1

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

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

Performs the ^= operation.

impl BitXorAssign for I64x1

fn bitxor_assign(&mut self, rhs: Self)

Performs the ^= operation.

impl Clone for I64x1

fn clone(&self) -> I64x1

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for I64x1

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

Formats the value using the given formatter.

impl From<I64x1> for i64

fn from(v: I64x1) -> i64

Converts to this type from the input type.

impl From<i64> for I64x1

fn from(val: i64) -> Self

Converts to this type from the input type.

impl Index<usize> for I64x1

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

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

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

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

type Output = I64x1

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = I64x1

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul for I64x1

type Output = I64x1

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

Performs the *= operation.

impl MulAssign for I64x1

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl Neg for I64x1

type Output = I64x1

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

impl Not for I64x1

type Output = I64x1

The resulting type after applying the ! operator.

fn not(self) -> Self

Performs the unary ! operation.

impl Shl<i32> for I64x1

type Output = I64x1

The resulting type after applying the << operator.

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

Performs the << operation.

impl ShlAssign<i32> for I64x1

fn shl_assign(&mut self, rhs: i32)

Performs the <<= operation.

impl Shr<i32> for I64x1

type Output = I64x1

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl ShrAssign<i32> for I64x1

fn shr_assign(&mut self, rhs: i32)

Performs the >>= operation.

impl SimdBaseIo for I64x1

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 I64x1

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 I64x1

const WIDTH: usize = 1

type Scalar = i64

type HorizontalAddScalar = i64

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

The underlying intrinsic SIMD type.

type Engine = Scalar

impl SimdInt for I64x1

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 SimdInt64 for I64x1

fn bitcast_f64(self) -> <Self::Engine as Simd>::Vf64

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

fn cast_f64(self) -> <Self::Engine as Simd>::Vf64

Element-wise cast to f64

fn partial_horizontal_add(self) -> i64

impl SimdTransmuteI64 for I64x1

fn try_transmute_scalar(&self) -> i64

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

fn try_transmute_from_scalar(val: i64) -> 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.

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<<I64x1 as SimdConsts>::Scalar> for I64x1

type Output = I64x1

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = I64x1

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub for I64x1

type Output = I64x1

The resulting type after applying the - operator.

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

Performs the - operation.

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

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

Performs the -= operation.

impl SubAssign for I64x1

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl Copy for I64x1