Type Definition packed_simd_2::f64x2

pub type f64x2 = Simd<[f64; 2]>;

A 128-bit vector with 2 f64 lanes.

Implementations

impl f64x2

pub const fn new(x0: f64, x1: f64) -> Self

Creates a new instance with each vector elements initialized with the provided values.

pub const fn lanes() -> usize

Returns the number of vector lanes.

pub const fn splat(value: f64) -> Self

Constructs a new instance with each element initialized to value.

pub fn extract(self, index: usize) -> f64

Extracts the value at index.

Panics

If index >= Self::lanes().

pub unsafe fn extract_unchecked(self, index: usize) -> f64

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

pub fn replace(self, index: usize, new_value: f64) -> Self

Returns a new vector where the value at index is replaced by new_value.

Panics

If index >= Self::lanes().

pub unsafe fn replace_unchecked(self, index: usize, new_value: f64) -> Self

Returns a new vector where the value at index is replaced by new_value.

Safety

If index >= Self::lanes() the behavior is undefined.

impl f64x2

pub fn min(self, x: Self) -> Self

Minimum of two vectors.

Returns a new vector containing the minimum value of each of the input vector lanes.

pub fn max(self, x: Self) -> Self

Maximum of two vectors.

Returns a new vector containing the maximum value of each of the input vector lanes.

impl f64x2

pub fn sum(self) -> f64

Horizontal sum of the vector elements.

The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:

((x0 + x1) + (x2 + x3)) + ((x4 + x5) + (x6 + x7))

If one of the vector element is NaN the reduction returns NaN. The resulting NaN is not required to be equal to any of the NaNs in the vector.

pub fn product(self) -> f64

Horizontal product of the vector elements.

The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:

((x0 * x1) * (x2 * x3)) * ((x4 * x5) * (x6 * x7))

If one of the vector element is NaN the reduction returns NaN. The resulting NaN is not required to be equal to any of the NaNs in the vector.

impl f64x2

pub fn max_element(self) -> f64

Largest vector element value.

pub fn min_element(self) -> f64

Smallest vector element value.

impl f64x2

pub fn from_slice_aligned(slice: &[f64]) -> Self

Instantiates a new vector with the values of the slice.

Panics

If slice.len() < Self::lanes() or &slice[0] is not aligned to an align_of::<Self>() boundary.

pub fn from_slice_unaligned(slice: &[f64]) -> Self

Instantiates a new vector with the values of the slice.

Panics

If slice.len() < Self::lanes().

pub unsafe fn from_slice_aligned_unchecked(slice: &[f64]) -> Self

Instantiates a new vector with the values of the slice.

Safety

If slice.len() < Self::lanes() or &slice[0] is not aligned to an align_of::<Self>() boundary, the behavior is undefined.

pub unsafe fn from_slice_unaligned_unchecked(slice: &[f64]) -> Self

Instantiates a new vector with the values of the slice.

Safety

If slice.len() < Self::lanes() the behavior is undefined.

impl f64x2

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

Writes the values of the vector to the slice.

Panics

If slice.len() < Self::lanes() or &slice[0] is not aligned to an align_of::<Self>() boundary.

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

Writes the values of the vector to the slice.

Panics

If slice.len() < Self::lanes().

pub unsafe fn write_to_slice_aligned_unchecked(self, slice: &mut [f64])

Writes the values of the vector to the slice.

Safety

If slice.len() < Self::lanes() or &slice[0] is not aligned to an align_of::<Self>() boundary, the behavior is undefined.

pub unsafe fn write_to_slice_unaligned_unchecked(self, slice: &mut [f64])

Writes the values of the vector to the slice.

Safety

If slice.len() < Self::lanes() the behavior is undefined.

impl f64x2

pub fn shuffle1_dyn<I>(self, indices: I) -> Self where
    Self: Shuffle1Dyn<Indices = I>, 

Shuffle vector elements according to indices.

impl f64x2

pub const EPSILON: f64x2

Machine epsilon value.

pub const MIN: f64x2

Smallest finite value.

pub const MIN_POSITIVE: f64x2

Smallest positive normal value.

pub const MAX: f64x2

Largest finite value.

pub const NAN: f64x2

Not a Number (NaN).

pub const INFINITY: f64x2

Infinity (∞).

pub const NEG_INFINITY: f64x2

Negative infinity (-∞).

pub const PI: f64x2

Archimedes’ constant (π)

pub const FRAC_PI_2: f64x2

π/2

pub const FRAC_PI_3: f64x2

π/3

pub const FRAC_PI_4: f64x2

π/4

pub const FRAC_PI_6: f64x2

π/6

pub const FRAC_PI_8: f64x2

π/8

pub const FRAC_1_PI: f64x2

1/π

pub const FRAC_2_PI: f64x2

2/π

pub const FRAC_2_SQRT_PI: f64x2

2/sqrt(π)

pub const SQRT_2: f64x2

sqrt(2)

pub const FRAC_1_SQRT_2: f64x2

1/sqrt(2)

pub const E: f64x2

Euler’s number (e)

pub const LOG2_E: f64x2

log₂(e)

pub const LOG10_E: f64x2

log₁₀(e)

pub const LN_2: f64x2

ln(2)

pub const LN_10: f64x2

ln(10)

impl f64x2

pub fn is_nan(self) -> m64x2

pub fn is_infinite(self) -> m64x2

pub fn is_finite(self) -> m64x2

impl f64x2

pub fn abs(self) -> Self

Absolute value.

impl f64x2

pub fn cos(self) -> Self

Cosine.

pub fn cos_pi(self) -> Self

Cosine of self * PI.

impl f64x2

pub fn exp(self) -> Self

Returns the exponential function of self: e^(self).

impl f64x2

pub fn ln(self) -> Self

Returns the natural logarithm of self.

impl f64x2

pub fn mul_add(self, y: Self, z: Self) -> Self

Fused multiply add: self * y + z

impl f64x2

pub fn mul_adde(self, y: Self, z: Self) -> Self

Fused multiply add estimate: ~= self * y + z

While fused multiply-add (fma) has infinite precision, mul_adde has at worst the same precision of a multiply followed by an add. This might be more efficient on architectures that do not have an fma instruction.

impl f64x2

pub fn powf(self, x: Self) -> Self

Raises self number to the floating point power of x.

impl f64x2

pub fn recpre(self) -> Self

Reciprocal estimate: ~= 1. / self.

FIXME: The precision of the estimate is currently unspecified.

impl f64x2

pub fn rsqrte(self) -> Self

Reciprocal square-root estimate: ~= 1. / self.sqrt().

FIXME: The precision of the estimate is currently unspecified.

impl f64x2

pub fn sin(self) -> Self

Sine.

pub fn sin_pi(self) -> Self

Sine of self * PI.

pub fn sin_cos_pi(self) -> (Self, Self)

Sine and cosine of self * PI.

impl f64x2

pub fn sqrt(self) -> Self

impl f64x2

pub fn sqrte(self) -> Self

Square-root estimate.

FIXME: The precision of the estimate is currently unspecified.

impl f64x2

pub fn tanh(self) -> Self

Tanh.

impl f64x2

pub fn eq(self, other: Self) -> m64x2

Lane-wise equality comparison.

pub fn ne(self, other: Self) -> m64x2

Lane-wise inequality comparison.

pub fn lt(self, other: Self) -> m64x2

Lane-wise less-than comparison.

pub fn le(self, other: Self) -> m64x2

Lane-wise less-than-or-equals comparison.

pub fn gt(self, other: Self) -> m64x2

Lane-wise greater-than comparison.

pub fn ge(self, other: Self) -> m64x2

Lane-wise greater-than-or-equals comparison.

Trait Implementations

impl Add<Simd<[f64; 2]>> for f64x2

type Output = Self

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<f64> for f64x2

type Output = Self

The resulting type after applying the + operator.

fn add(self, other: f64) -> Self

Performs the + operation.

impl AddAssign<Simd<[f64; 2]>> for f64x2

fn add_assign(&mut self, other: Self)

Performs the += operation.

impl AddAssign<f64> for f64x2

fn add_assign(&mut self, other: f64)

Performs the += operation.

impl Debug for f64x2

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

Formats the value using the given formatter.

impl Default for f64x2

fn default() -> Self

Returns the “default value” for a type.

impl Div<Simd<[f64; 2]>> for f64x2

type Output = Self

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<f64> for f64x2

type Output = Self

The resulting type after applying the / operator.

fn div(self, other: f64) -> Self

Performs the / operation.

impl DivAssign<Simd<[f64; 2]>> for f64x2

fn div_assign(&mut self, other: Self)

Performs the /= operation.

impl DivAssign<f64> for f64x2

fn div_assign(&mut self, other: f64)

Performs the /= operation.

impl From<[f64; 2]> for f64x2

fn from(array: [f64; 2]) -> Self

Performs the conversion.

impl From<Simd<[f32; 2]>> for f64x2

fn from(source: f32x2) -> Self

Performs the conversion.

impl From<Simd<[i16; 2]>> for f64x2

fn from(source: i16x2) -> Self

Performs the conversion.

impl From<Simd<[i32; 2]>> for f64x2

fn from(source: i32x2) -> Self

Performs the conversion.

impl From<Simd<[i8; 2]>> for f64x2

fn from(source: i8x2) -> Self

Performs the conversion.

impl From<Simd<[u16; 2]>> for f64x2

fn from(source: u16x2) -> Self

Performs the conversion.

impl From<Simd<[u32; 2]>> for f64x2

fn from(source: u32x2) -> Self

Performs the conversion.

impl From<Simd<[u8; 2]>> for f64x2

fn from(source: u8x2) -> Self

Performs the conversion.

impl FromCast<Simd<[f32; 2]>> for f64x2

fn from_cast(x: f32x2) -> Self

Numeric cast from T to Self.

impl FromCast<Simd<[i128; 2]>> for f64x2

fn from_cast(x: i128x2) -> Self

Numeric cast from T to Self.

impl FromCast<Simd<[i16; 2]>> for f64x2

fn from_cast(x: i16x2) -> Self

Numeric cast from T to Self.

impl FromCast<Simd<[i32; 2]>> for f64x2

fn from_cast(x: i32x2) -> Self

Numeric cast from T to Self.

impl FromCast<Simd<[i64; 2]>> for f64x2

fn from_cast(x: i64x2) -> Self

Numeric cast from T to Self.

impl FromCast<Simd<[i8; 2]>> for f64x2

fn from_cast(x: i8x2) -> Self

Numeric cast from T to Self.

impl FromCast<Simd<[isize; 2]>> for f64x2

fn from_cast(x: isizex2) -> Self

Numeric cast from T to Self.

impl FromCast<Simd<[m128; 2]>> for f64x2

fn from_cast(x: m128x2) -> Self

Numeric cast from T to Self.

impl FromCast<Simd<[m16; 2]>> for f64x2

fn from_cast(x: m16x2) -> Self

Numeric cast from T to Self.

impl FromCast<Simd<[m32; 2]>> for f64x2

fn from_cast(x: m32x2) -> Self

Numeric cast from T to Self.

impl FromCast<Simd<[m64; 2]>> for f64x2

fn from_cast(x: m64x2) -> Self

Numeric cast from T to Self.

impl FromCast<Simd<[m8; 2]>> for f64x2

fn from_cast(x: m8x2) -> Self

Numeric cast from T to Self.

impl FromCast<Simd<[msize; 2]>> for f64x2

fn from_cast(x: msizex2) -> Self

Numeric cast from T to Self.

impl FromCast<Simd<[u128; 2]>> for f64x2

fn from_cast(x: u128x2) -> Self

Numeric cast from T to Self.

impl FromCast<Simd<[u16; 2]>> for f64x2

fn from_cast(x: u16x2) -> Self

Numeric cast from T to Self.

impl FromCast<Simd<[u32; 2]>> for f64x2

fn from_cast(x: u32x2) -> Self

Numeric cast from T to Self.

impl FromCast<Simd<[u64; 2]>> for f64x2

fn from_cast(x: u64x2) -> Self

Numeric cast from T to Self.

impl FromCast<Simd<[u8; 2]>> for f64x2

fn from_cast(x: u8x2) -> Self

Numeric cast from T to Self.

impl FromCast<Simd<[usize; 2]>> for f64x2

fn from_cast(x: usizex2) -> Self

Numeric cast from T to Self.

impl Mul<Simd<[f64; 2]>> for f64x2

type Output = Self

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<f64> for f64x2

type Output = Self

The resulting type after applying the * operator.

fn mul(self, other: f64) -> Self

Performs the * operation.

impl MulAssign<Simd<[f64; 2]>> for f64x2

fn mul_assign(&mut self, other: Self)

Performs the *= operation.

impl MulAssign<f64> for f64x2

fn mul_assign(&mut self, other: f64)

Performs the *= operation.

impl Neg for f64x2

type Output = Self

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

impl PartialEq<Simd<[f64; 2]>> for f64x2

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Self) -> bool

This method tests for !=.

impl<'a> Product<&'a Simd<[f64; 2]>> for f64x2

fn product<I: Iterator<Item = &'a f64x2>>(iter: I) -> f64x2

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl Product<Simd<[f64; 2]>> for f64x2

fn product<I: Iterator<Item = f64x2>>(iter: I) -> f64x2

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl Rem<Simd<[f64; 2]>> for f64x2

type Output = Self

The resulting type after applying the % operator.

fn rem(self, other: Self) -> Self

Performs the % operation.

impl Rem<f64> for f64x2

type Output = Self

The resulting type after applying the % operator.

fn rem(self, other: f64) -> Self

Performs the % operation.

impl RemAssign<Simd<[f64; 2]>> for f64x2

fn rem_assign(&mut self, other: Self)

Performs the %= operation.

impl RemAssign<f64> for f64x2

fn rem_assign(&mut self, other: f64)

Performs the %= operation.

impl Simd for f64x2

type Element = f64

Element type of the SIMD vector

const LANES: usize

The number of elements in the SIMD vector.

type LanesType = [u32; 2]

The type: [u32; Self::N].

impl Sub<Simd<[f64; 2]>> for f64x2

type Output = Self

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<f64> for f64x2

type Output = Self

The resulting type after applying the - operator.

fn sub(self, other: f64) -> Self

Performs the - operation.

impl SubAssign<Simd<[f64; 2]>> for f64x2

fn sub_assign(&mut self, other: Self)

Performs the -= operation.

impl SubAssign<f64> for f64x2

fn sub_assign(&mut self, other: f64)

Performs the -= operation.

impl<'a> Sum<&'a Simd<[f64; 2]>> for f64x2

fn sum<I: Iterator<Item = &'a f64x2>>(iter: I) -> f64x2

Method which takes an iterator and generates Self from the elements by “summing up” the items.

impl Sum<Simd<[f64; 2]>> for f64x2

fn sum<I: Iterator<Item = f64x2>>(iter: I) -> f64x2

Method which takes an iterator and generates Self from the elements by “summing up” the items.