Struct f64x8 

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

A SIMD vector of 8 f64 elements.

This type’s memory layout is identical to that of [f64; 8], except that it is aligned to 64 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 = f64x8::splat(simd, 1.0);
    let b = f64x8::simd_from(simd, 1.0);

    // From a slice:
    let c = f64x8::from_slice(simd, &[1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0]);

    // From an array:
    let d = f64x8::simd_from(simd, [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0]);

    // From an element-wise function:
    let e = f64x8::from_fn(simd, |i| i as f64);
    // From `Self::Block`:
    let f = f64x8::block_splat(f64x2::simd_from(simd, [1.0, 2.0]));
}

Fields

simd: S

Trait Implementations

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

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

Add two vectors element-wise.

type Output = f64x8<S>

The resulting type after applying the + operator.

impl<S: Simd> Add<f64> for f64x8<S>

type Output = f64x8<S>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<S: Simd> Add<f64x8<S>> for f64

type Output = f64x8<S>

The resulting type after applying the + operator.

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

Performs the + operation.

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

fn add_assign(&mut self, rhs: Self)

Add two vectors element-wise.

impl<S: Simd> AddAssign<f64> for f64x8<S>

fn add_assign(&mut self, rhs: f64)

Performs the += operation.

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

type Bytes = u8x64<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 f64x8<S>

where S::f64x8: 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 f64x8<S>

where S::f64x8: Copy,

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

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

Formats the value using the given formatter.

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

type Target = [f64; 8]

The resulting type after dereferencing.

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

Dereferences the value.

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

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

Mutably dereferences the value.

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

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

Divide two vectors element-wise.

type Output = f64x8<S>

The resulting type after applying the / operator.

impl<S: Simd> Div<f64> for f64x8<S>

type Output = f64x8<S>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<S: Simd> Div<f64x8<S>> for f64

type Output = f64x8<S>

The resulting type after applying the / operator.

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

Performs the / operation.

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

fn div_assign(&mut self, rhs: Self)

Divide two vectors element-wise.

impl<S: Simd> DivAssign<f64> for f64x8<S>

fn div_assign(&mut self, rhs: f64)

Performs the /= operation.

impl<S: Simd> ExtractToken for f64x8<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<f64x8<S>> for __m512d

Available on x86 or x86-64 only.

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

Converts to this type from the input type.

impl<S: Simd> From<f64x8<S>> for [f64; 8]

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

Converts to this type from the input type.

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

type Output = f64

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

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

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

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

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

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

Multiply two vectors element-wise.

type Output = f64x8<S>

The resulting type after applying the * operator.

impl<S: Simd> Mul<f64> for f64x8<S>

type Output = f64x8<S>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<S: Simd> Mul<f64x8<S>> for f64

type Output = f64x8<S>

The resulting type after applying the * operator.

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

Performs the * operation.

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

fn mul_assign(&mut self, rhs: Self)

Multiply two vectors element-wise.

impl<S: Simd> MulAssign<f64> for f64x8<S>

fn mul_assign(&mut self, rhs: f64)

Performs the *= operation.

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

fn neg(self) -> Self::Output

Negate each element of the vector.

type Output = f64x8<S>

The resulting type after applying the - operator.

impl<S: Simd> Select<f64x8<S>> for mask64x8<S>

fn select(self, if_true: f64x8<S>, if_false: f64x8<S>) -> f64x8<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 f64x8<S>

const LEN: usize = 8

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

The type of this vector’s elements.

type ByteVector = u8x64<S>

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

type Mask = mask64x8<S>

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

type Block = f64x2<S>

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

type Array = [f64; 8]

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) -> &[f64]

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

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

Create a SIMD vector from a slice.

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

Store a SIMD vector into a slice.

fn splat(simd: S, val: f64) -> 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) -> f64) -> 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> SimdCvtFloat<i64x8<S>> for f64x8<S>

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

Convert each signed 64-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<u64x8<S>> for f64x8<S>

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

Convert each unsigned 64-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<f64x8<S>> for i64x8<S>

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

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

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

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

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

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

impl<S: Simd> SimdCvtTruncate<f64x8<S>> for u64x8<S>

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

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

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

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

Convert each floating-point element to an unsigned 64-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 f64x8<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<[f64; 8], S> for f64x8<S>

fn simd_from(simd: S, val: [f64; 8]) -> Self

impl<S: Simd> SimdFrom<__m512d, S> for f64x8<S>

Available on x86 or x86-64 only.

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

impl<S: Simd> SimdFrom<f64, S> for f64x8<S>

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

impl<S: Simd> SimdNarrow<S> for f64x8<S>

type Narrowed = f32x16<S>

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

fn narrow(self, high: Self) -> Self::Narrowed

Narrow every lane.

fn saturating_narrow(self, high: Self) -> Self::Narrowed

Narrow with saturation for integers. Floats behave identically to narrow.

fn relaxed_narrow(self, high: Self) -> Self::Narrowed

Narrow using the cheapest operation for the active SIMD backend, assuming no overflow.

impl<S: Simd> SimdSplit<S> for f64x8<S>

type Split = f64x4<S>

fn split(self) -> (Self::Split, Self::Split)

Split this vector into left and right halves.

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

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

Subtract two vectors element-wise.

type Output = f64x8<S>

The resulting type after applying the - operator.

impl<S: Simd> Sub<f64> for f64x8<S>

type Output = f64x8<S>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<S: Simd> Sub<f64x8<S>> for f64

type Output = f64x8<S>

The resulting type after applying the - operator.

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

Performs the - operation.

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

fn sub_assign(&mut self, rhs: Self)

Subtract two vectors element-wise.

impl<S: Simd> SubAssign<f64> for f64x8<S>

fn sub_assign(&mut self, rhs: f64)

Performs the -= operation.