Struct f32x4 

pub struct f32x4<S: Simd> {
    pub simd: S,
    /* private fields */
}

A SIMD vector of 4 f32 elements.

This type’s memory layout is identical to that of [f32; 4], except that it is aligned to 16 bytes.

You may construct this vector type using the Self::splat, Self::from_slice, Self::simd_from, Self::from_fn, and Self::block_splat methods.

fn construct_simd<S: Simd>(simd: S) {
    // From a single scalar value:
    let a = f32x4::splat(simd, 1.0);
    let b = f32x4::simd_from(simd, 1.0);

    // From a slice:
    let c = f32x4::from_slice(simd, &[1.0, 2.0, 3.0, 4.0]);

    // From an array:
    let d = f32x4::simd_from(simd, [1.0, 2.0, 3.0, 4.0]);

    // From an element-wise function:
    let e = f32x4::from_fn(simd, |i| i as f32);
}

Fields

simd: S

Trait Implementations

impl<S: Simd> Add for f32x4<S>

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

Add two vectors element-wise.

type Output = f32x4<S>

The resulting type after applying the + operator.

impl<S: Simd> Add<f32> for f32x4<S>

type Output = f32x4<S>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<S: Simd> Add<f32x4<S>> for f32

type Output = f32x4<S>

The resulting type after applying the + operator.

fn add(self, rhs: f32x4<S>) -> Self::Output

Performs the + operation.

impl<S: Simd> AddAssign for f32x4<S>

fn add_assign(&mut self, rhs: Self)

Add two vectors element-wise.

impl<S: Simd> AddAssign<f32> for f32x4<S>

fn add_assign(&mut self, rhs: f32)

Performs the += operation.

impl<S: Simd> Bytes for f32x4<S>

type Bytes = u8x16<S>

The same-width SIMD vector of u8 lanes used as the byte representation.

fn to_bytes(self) -> Self::Bytes

Reinterpret this vector as a same-width vector of u8 lanes.

fn from_bytes(value: Self::Bytes) -> Self

Reinterpret a same-width vector of u8 lanes as this vector type.

fn bitcast<U: Bytes<Bytes = Self::Bytes>>(self) -> U

Bitcast directly to another SIMD vector with the same byte representation. This is effectively a safe transmute for SIMD types.

impl<S: Clone + Simd> Clone for f32x4<S>

where S::f32x4: Clone,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S: Copy + Simd> Copy for f32x4<S>

where S::f32x4: Copy,

impl<S: Simd + Debug> Debug for f32x4<S>

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

Formats the value using the given formatter.

impl<S: Simd> Deref for f32x4<S>

type Target = [f32; 4]

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<S: Simd> DerefMut for f32x4<S>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<S: Simd> Div for f32x4<S>

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

Divide two vectors element-wise.

type Output = f32x4<S>

The resulting type after applying the / operator.

impl<S: Simd> Div<f32> for f32x4<S>

type Output = f32x4<S>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<S: Simd> Div<f32x4<S>> for f32

type Output = f32x4<S>

The resulting type after applying the / operator.

fn div(self, rhs: f32x4<S>) -> Self::Output

Performs the / operation.

impl<S: Simd> DivAssign for f32x4<S>

fn div_assign(&mut self, rhs: Self)

Divide two vectors element-wise.

impl<S: Simd> DivAssign<f32> for f32x4<S>

fn div_assign(&mut self, rhs: f32)

Performs the /= operation.

impl<S: Simd> ExtractToken for f32x4<S>

type S = S

The SIMD implementation associated with this value.

fn token(&self) -> S

Get the SIMD token associated with this value.

impl<S: Simd> From<f32x4<S>> for [f32; 4]

fn from(value: f32x4<S>) -> Self

Converts to this type from the input type.

impl<S: Simd> From<f32x4<S>> for __m128

Available on x86 or x86-64 only.

fn from(value: f32x4<S>) -> Self

Converts to this type from the input type.

impl<S: Simd> Index<usize> for f32x4<S>

type Output = f32

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<S: Simd> IndexMut<usize> for f32x4<S>

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

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

impl<S: Simd> Mul for f32x4<S>

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

Multiply two vectors element-wise.

type Output = f32x4<S>

The resulting type after applying the * operator.

impl<S: Simd> Mul<f32> for f32x4<S>

type Output = f32x4<S>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<S: Simd> Mul<f32x4<S>> for f32

type Output = f32x4<S>

The resulting type after applying the * operator.

fn mul(self, rhs: f32x4<S>) -> Self::Output

Performs the * operation.

impl<S: Simd> MulAssign for f32x4<S>

fn mul_assign(&mut self, rhs: Self)

Multiply two vectors element-wise.

impl<S: Simd> MulAssign<f32> for f32x4<S>

fn mul_assign(&mut self, rhs: f32)

Performs the *= operation.

impl<S: Simd> Neg for f32x4<S>

fn neg(self) -> Self::Output

Negate each element of the vector.

type Output = f32x4<S>

The resulting type after applying the - operator.

impl<S: Simd> Select<f32x4<S>> for mask32x4<S>

fn select(self, if_true: f32x4<S>, if_false: f32x4<S>) -> f32x4<S>

For each logical lane of this mask, select the first operand if the lane is true, and select the second operand if the lane is false.

impl<S: Simd> SimdBase<S> for f32x4<S>

const LEN: usize = 4

This vector type’s lane count. This is useful when you’re working with a native-width vector (e.g. Simd::f32s) and want to process data in native-width chunks.

type Element = f32

The type of this vector’s elements.

type ByteVector = u8x16<S>

The same-width SIMD vector of u8 lanes used as the byte representation.

type Mask = mask32x4<S>

A SIMD vector mask with the same number of logical lanes.

type Block = f32x4<S>

A 128-bit SIMD vector of the same scalar type.

type Array = [f32; 4]

The array type that this vector type corresponds to, which will always be [Self::Element; Self::LEN]. It has the same layout as this vector type, but likely has a lower alignment.

fn as_slice(&self) -> &[f32]

fn as_mut_slice(&mut self) -> &mut [f32]

fn from_slice(simd: S, slice: &[f32]) -> Self

Create a SIMD vector from a slice.

fn store_slice(&self, slice: &mut [f32])

Store a SIMD vector into a slice.

fn splat(simd: S, val: f32) -> Self

Create a SIMD vector with all elements set to the given value.

fn block_splat(block: Self::Block) -> Self

Create a SIMD vector from a 128-bit vector of the same scalar type, repeated.

fn from_fn(simd: S, f: impl FnMut(usize) -> f32) -> Self

Create a SIMD vector where each element is produced by calling f with that element’s lane index (from 0 to SimdBase::LEN - 1).

fn slide<const SHIFT: usize>(self, rhs: impl SimdInto<Self, S>) -> Self

Concatenate [self, rhs] and extract Self::LEN elements starting at index SHIFT.

fn slide_within_blocks<const SHIFT: usize>( self, rhs: impl SimdInto<Self, S>, ) -> Self

Like slide, but operates independently on each 128-bit block.

fn swizzle_dyn_within_blocks( self, indices: impl SimdInto<Self::Bytes, S>, ) -> Self

Dynamically swizzle this vector’s bytes independently within each 128-bit block.

fn swizzle_dyn(self, indices: impl SimdInto<Self::Bytes, S>) -> Self

Dynamically swizzle this vector’s bytes across the whole vector.

fn swizzle_dyn_precise(self, indices: impl SimdInto<Self::Bytes, S>) -> Self

Dynamically swizzle this vector’s bytes across the whole vector.

fn abs(self) -> Self

Compute the absolute value of each element.

fn reverse(self) -> Self

Reverse the order of the vector’s elements.

fn reduce_max(self) -> Self::Element

Return the maximum element in the vector. Integer vectors always return the exact maximum.

fn reduce_min(self) -> Self::Element

Return the minimum element in the vector. Integer vectors always return the exact minimum.

fn reduce_max_precise(self) -> Self::Element

Return the maximum element in the vector, ignoring quiet NaNs.

fn reduce_min_precise(self) -> Self::Element

Return the minimum element in the vector, ignoring quiet NaNs.

fn reduce_sum(self) -> Self::Element

Return the sum of all elements in the vector. Integer addition wraps.

fn reduce_product(self) -> Self::Element

Return the product of all elements in the vector. Integer multiplication wraps.

fn max(self, rhs: impl SimdInto<Self, S>) -> Self

Return the element-wise maximum of two vectors.

fn min(self, rhs: impl SimdInto<Self, S>) -> Self

Return the element-wise minimum of two vectors.

fn max_precise(self, rhs: impl SimdInto<Self, S>) -> Self

Return the element-wise maximum of two vectors.

fn min_precise(self, rhs: impl SimdInto<Self, S>) -> Self

Return the element-wise minimum of two vectors.

fn simd_eq(self, rhs: impl SimdInto<Self, S>) -> Self::Mask

Compare two vectors element-wise for equality.

fn simd_lt(self, rhs: impl SimdInto<Self, S>) -> Self::Mask

Compare two vectors element-wise for less than.

fn simd_le(self, rhs: impl SimdInto<Self, S>) -> Self::Mask

Compare two vectors element-wise for less than or equal.

fn simd_ge(self, rhs: impl SimdInto<Self, S>) -> Self::Mask

Compare two vectors element-wise for greater than or equal.

fn simd_gt(self, rhs: impl SimdInto<Self, S>) -> Self::Mask

Compare two vectors element-wise for greater than.

fn zip_low(self, rhs: impl SimdInto<Self, S>) -> Self

Interleave the lower half elements of two vectors.

fn zip_high(self, rhs: impl SimdInto<Self, S>) -> Self

Interleave the upper half elements of two vectors.

fn unzip_low(self, rhs: impl SimdInto<Self, S>) -> Self

Extract even-indexed elements from two vectors.

fn unzip_high(self, rhs: impl SimdInto<Self, S>) -> Self

Extract odd-indexed elements from two vectors.

fn interleave(self, rhs: impl SimdInto<Self, S>) -> (Self, Self)

Interleave two vectors.

fn deinterleave(self, rhs: impl SimdInto<Self, S>) -> (Self, Self)

Deinterleave two vectors.

fn load_array(simd: S, val: Self::Array) -> Self

Create a SIMD vector from its corresponding lane array.

fn load_array_ref(simd: S, val: &Self::Array) -> Self

Create a SIMD vector from a reference to its corresponding lane array.

fn to_array(self) -> Self::Array

Convert this SIMD vector to its corresponding lane array.

fn as_array(&self) -> &Self::Array

Project this SIMD vector reference to its corresponding lane array reference.

fn as_mut_array(&mut self) -> &mut Self::Array

Project this mutable SIMD vector reference to its corresponding mutable lane array reference.

fn store_array(self, dest: &mut Self::Array)

Store this SIMD vector into its corresponding lane array.

fn rotate_elements_left<const OFFSET: usize>(self) -> Self

Rotate the vector elements to the left by OFFSET.

fn rotate_elements_right<const OFFSET: usize>(self) -> Self

Rotate the vector elements to the right by OFFSET.

fn shift_elements_left<const OFFSET: usize>( self, padding: Self::Element, ) -> Self

Shift the vector elements to the left by OFFSET, filling in with padding from the right.

fn shift_elements_right<const OFFSET: usize>( self, padding: Self::Element, ) -> Self

Shift the vector elements to the right by OFFSET, filling in with padding from the left.

impl<S: Simd> SimdCombine<S> for f32x4<S>

type Combined = f32x8<S>

fn combine(self, rhs: impl SimdInto<Self, S>) -> Self::Combined

Concatenate two vectors into a new one that’s twice as long.

impl<S: Simd> SimdCvtFloat<i32x4<S>> for f32x4<S>

fn float_from(x: i32x4<S>) -> Self

Convert each signed 32-bit integer element to a floating-point value.

Values that cannot be exactly represented are rounded to the nearest representable value.

impl<S: Simd> SimdCvtFloat<u32x4<S>> for f32x4<S>

fn float_from(x: u32x4<S>) -> Self

Convert each unsigned 32-bit integer element to a floating-point value.

Values that cannot be exactly represented are rounded to the nearest representable value.

impl<S: Simd> SimdCvtTruncate<f32x4<S>> for i32x4<S>

fn truncate_from(x: f32x4<S>) -> Self

Convert each floating-point element to a signed 32-bit integer, truncating towards zero.

Out-of-range values or NaN will produce implementation-defined results.

fn truncate_from_precise(x: f32x4<S>) -> Self

Convert each floating-point element to a signed 32-bit integer, truncating towards zero.

Out-of-range values are saturated to the closest in-range value. NaN becomes 0.

impl<S: Simd> SimdCvtTruncate<f32x4<S>> for u32x4<S>

fn truncate_from(x: f32x4<S>) -> Self

Convert each floating-point element to an unsigned 32-bit integer, truncating towards zero.

Out-of-range values or NaN will produce implementation-defined results.

On x86 platforms below AVX-512, this operation will still be slower than converting to i32, because there is no native instruction for converting to u32. If you know your values fit within range of an i32, you should convert to an i32 and cast to your desired datatype afterwards.

fn truncate_from_precise(x: f32x4<S>) -> Self

Convert each floating-point element to an unsigned 32-bit integer, truncating towards zero.

Out-of-range values are saturated to the closest in-range value. NaN becomes 0.

impl<S: Simd> SimdFloat<S> for f32x4<S>

fn sqrt(self) -> Self

Compute the square root of each element.

fn approximate_recip(self) -> Self

Compute an approximate reciprocal (1. / x) for each element.

fn copysign(self, rhs: impl SimdInto<Self, S>) -> Self

Return a vector with the magnitude of self and the sign of rhs for each element.

fn mul_add( self, op1: impl SimdInto<Self, S>, op2: impl SimdInto<Self, S>, ) -> Self

Compute (self * op1) + op2 (fused multiply-add) for each element.

fn mul_add_precise( self, op1: impl SimdInto<Self, S>, op2: impl SimdInto<Self, S>, ) -> Self

Compute (self * op1) + op2 for each element, with a single rounding at the end.

fn mul_sub( self, op1: impl SimdInto<Self, S>, op2: impl SimdInto<Self, S>, ) -> Self

Compute (self * op1) - op2 (fused multiply-subtract) for each element.

fn mul_sub_precise( self, op1: impl SimdInto<Self, S>, op2: impl SimdInto<Self, S>, ) -> Self

Compute (self * op1) - op2 for each element, with a single rounding at the end.

fn floor(self) -> Self

Return the largest integer less than or equal to each element, that is, round towards negative infinity.

fn ceil(self) -> Self

Return the smallest integer greater than or equal to each element, that is, round towards positive infinity.

fn round_ties_even(self) -> Self

Round each element to the nearest integer, with ties rounding to the nearest even integer.

fn fract(self) -> Self

Return the fractional part of each element.

fn trunc(self) -> Self

Return the integer part of each element, rounding towards zero.

fn to_int<T: SimdCvtTruncate<Self>>(self) -> T

Convert this floating-point type to an integer. This is a convenience method that delegates to SimdCvtTruncate::truncate_from, and can only be called if there actually exists a target type of the same bit width (u32/i32 for f32, or u64/i64 for f64).

fn to_int_precise<T: SimdCvtTruncate<Self>>(self) -> T

Convert this floating-point type to an integer, saturating on overflow and returning 0 for NaN. This is a convenience method that delegates to SimdCvtTruncate::truncate_from_precise, and can only be called if there actually exists a target type of the same bit width (u32/i32 for f32, or u64/i64 for f64).

impl<S: Simd> SimdFrom<[f32; 4], S> for f32x4<S>

fn simd_from(simd: S, val: [f32; 4]) -> Self

impl<S: Simd> SimdFrom<__m128, S> for f32x4<S>

Available on x86 or x86-64 only.

fn simd_from(simd: S, arch: __m128) -> Self

impl<S: Simd> SimdFrom<f32, S> for f32x4<S>

fn simd_from(simd: S, value: f32) -> Self

impl<S: Simd> SimdInterleaved<S> for f32x4<S>

fn load_four_interleaved(simd: S, src: &[Self::Element]) -> [Self; 4]

Load four 128-bit vectors from a slice with 4-way interleaving.

fn store_four_interleaved(vectors: [Self; 4], dest: &mut [Self::Element])

Store four vectors into a scalar slice with four-way interleaving.

impl<S: Simd> SimdWiden<S> for f32x4<S>

type Widened = f64x2<S>

The same-width vector type with lanes twice as wide.

fn widen(self) -> (Self::Widened, Self::Widened)

Widen every lane, returning the lower and upper halves in that order.

impl<S: Simd> Sub for f32x4<S>

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

Subtract two vectors element-wise.

type Output = f32x4<S>

The resulting type after applying the - operator.

impl<S: Simd> Sub<f32> for f32x4<S>

type Output = f32x4<S>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<S: Simd> Sub<f32x4<S>> for f32

type Output = f32x4<S>

The resulting type after applying the - operator.

fn sub(self, rhs: f32x4<S>) -> Self::Output

Performs the - operation.

impl<S: Simd> SubAssign for f32x4<S>

fn sub_assign(&mut self, rhs: Self)

Subtract two vectors element-wise.

impl<S: Simd> SubAssign<f32> for f32x4<S>

fn sub_assign(&mut self, rhs: f32)

Performs the -= operation.