Struct f64x8 

#[repr(C, align(64))]
pub struct f64x8<S: Simd> {
    pub(crate) val: S::f64x8,
    pub simd: S,
}

A SIMD vector of 8 f64 elements.

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

val: S::f64x8

simd: S

Trait Implementations

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> 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> AddAssign<f64> for f64x8<S>

fn add_assign(&mut self, rhs: f64)

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> Bytes for f64x8<S>

type Bytes = u8x64<S>

fn to_bytes(self) -> Self::Bytes

Convert this type to an array of bytes.

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

Create an instance of this type from an array of bytes.

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

Bitcast directly from this type to another one of the same size.

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

where S::f64x8: Clone,

fn clone(&self) -> f64x8<S>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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<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> 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> DivAssign<f64> for f64x8<S>

fn div_assign(&mut self, rhs: f64)

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> 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<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> 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> MulAssign<f64> for f64x8<S>

fn mul_assign(&mut self, rhs: f64)

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> 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 element of this mask, select the first operand if the element is all ones, and select the second operand if the element is all zeroes.

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

const N: 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 Mask = mask64x8<S>

A SIMD vector mask with the same number of elements.

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::N]. It has the same layout as this vector type, but likely has a lower alignment.

fn witness(&self) -> S

Get the Simd implementation associated with this type.

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::N - 1).

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

Concatenate [self, rhs] and extract Self::N 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.

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

fn abs(self) -> Self

Compute the absolute value of each element.

fn sqrt(self) -> Self

Compute the square root of 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 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 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 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_sub( self, op1: impl SimdInto<Self, S>, op2: impl SimdInto<Self, S>, ) -> Self

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

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 (currently, only u32 and i32).

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 (currently, only u32 and i32).

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

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

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

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

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<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> 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> SubAssign<f64> for f64x8<S>

fn sub_assign(&mut self, rhs: f64)

Performs the -= operation.

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

fn sub_assign(&mut self, rhs: Self)

Subtract two vectors element-wise.

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

where S::f64x8: Copy,