Struct F32x4 

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

Trait Implementations

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

type Output = F32x4

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = F32x4

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add for F32x4

type Output = F32x4

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

Performs the += operation.

impl AddAssign for F32x4

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

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

type Output = F32x4

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd for F32x4

type Output = F32x4

The resulting type after applying the & operator.

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

Performs the & operation.

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

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

Performs the &= operation.

impl BitAndAssign for F32x4

fn bitand_assign(&mut self, rhs: Self)

Performs the &= operation.

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

type Output = F32x4

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr for F32x4

type Output = F32x4

The resulting type after applying the | operator.

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

Performs the | operation.

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

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

Performs the |= operation.

impl BitOrAssign for F32x4

fn bitor_assign(&mut self, rhs: Self)

Performs the |= operation.

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

type Output = F32x4

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor for F32x4

type Output = F32x4

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

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

Performs the ^= operation.

impl BitXorAssign for F32x4

fn bitxor_assign(&mut self, rhs: Self)

Performs the ^= operation.

impl Clone for F32x4

fn clone(&self) -> F32x4

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for F32x4

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

Formats the value using the given formatter.

impl Div<<F32x4 as SimdConsts>::Scalar> for F32x4

type Output = F32x4

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div for F32x4

type Output = F32x4

The resulting type after applying the / operator.

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

Performs the / operation.

impl DivAssign<<F32x4 as SimdConsts>::Scalar> for F32x4

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

Performs the /= operation.

impl DivAssign for F32x4

fn div_assign(&mut self, rhs: Self)

Performs the /= operation.

impl Index<usize> for F32x4

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

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

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

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

type Output = F32x4

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = F32x4

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul for F32x4

type Output = F32x4

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

Performs the *= operation.

impl MulAssign for F32x4

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl Neg for F32x4

type Output = F32x4

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

impl Not for F32x4

type Output = F32x4

The resulting type after applying the ! operator.

fn not(self) -> Self

Performs the unary ! operation.

impl SimdBaseIo for F32x4

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 F32x4

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 F32x4

const WIDTH: usize = 4

type Scalar = f32

type HorizontalAddScalar = f32

type ArrayRepresentation = [f32; 4]

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

The underlying intrinsic SIMD type.

type Engine = Sse2

impl SimdFloat for F32x4

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

Element-wise divide between two vectors

fn ceil(self) -> Self

Element-wise ceilings between two vectors

fn floor(self) -> Self

Element-wise floors between two vectors

fn round(self) -> Self

Element-wise rounds between two vectors

fn fast_ceil(self) -> Self

Alternative element-wise ceilings between two vectors. When using Sse2, this uses a faster version of ceiling that only works on floating point values small enough to fit in an i32. This is a big performance boost if you don’t need a complete ceiling.

fn fast_floor(self) -> Self

Alternative element-wise floors between two vectors. When using Sse2, this uses a faster version of floor that only works on floating point values small enough to fit in an i32. This is a big performance boost if you don’t need a complete floor.

fn fast_round(self) -> Self

Alternative element-wise rounds between two vectors. When using Sse2, this uses a faster version of round that only works on floating point values small enough to fit in an i32. This is a big performance boost if you don’t need a complete round.

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

Element-wise multiply add. This performs Self * A + B

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

Element-wise multiply subtract. This performs Self * A - B

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

Element-wise negative multiply add. This performs -(Self * A) + B

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

Element-wise negative multiply subtract. This performs -(Self * A) - B

fn sqrt(self) -> Self

Element-wise square root

fn rsqrt(self) -> Self

Element-wise approximate inverse square root.

fn from_f64(value: f64) -> Self

impl SimdFloat32 for F32x4

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

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

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

Element-wise cast to i32 (rounded to nearest, ties to even; not floored). Note, this may cause undefined behavior when casting from numbers outside the range of i32. E.g. a very large positive float may become i32::MIN.

fn fast_inverse(self) -> Self

Element-wise fast reciprocal (1.0 / x)

impl SimdTransmuteF32 for F32x4

fn try_transmute_sse2(&self) -> __m128

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

fn try_transmute_from_sse2(val: __m128) -> Self

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

fn try_transmute_scalar(&self) -> f32

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

fn try_transmute_from_scalar(_scalar: f32) -> Self

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

fn try_transmute_sse41(&self) -> __m128

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: __m128) -> 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) -> __m256

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

fn try_transmute_from_avx2(_avx2: __m256) -> Self

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

fn try_transmute_avx512(&self) -> __m512

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

fn try_transmute_from_avx512(_avx512: __m512) -> Self

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

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

type Output = F32x4

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = F32x4

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub for F32x4

type Output = F32x4

The resulting type after applying the - operator.

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

Performs the - operation.

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

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

Performs the -= operation.

impl SubAssign for F32x4

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl Copy for F32x4