Struct f64x8 

pub struct f64x8 { /* private fields */ }

A SIMD vector with eight elements of type f64.

See the crate level documentation for more information about SIMD vectors.

Implementations

impl f64x8

The following functionality exists for all SIMD vectors.

pub const fn new(array: [f64; 8]) -> Self

Converts an array to a SIMD vector.

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

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

pub const fn to_array(self) -> [f64; 8]

Converts a SIMD vector to an array.

pub const fn as_array(&self) -> &[f64; 8]

Returns an array reference containing the entire SIMD vector.

pub const fn as_mut_array(&mut self) -> &mut [f64; 8]

Returns a mutable array reference containing the entire SIMD vector.

pub fn simd_eq<Rhs>(self, other: Rhs) -> <Self as CmpEq<Rhs>>::Output

where Self: CmpEq<Rhs>,

Returns a mask that checks if each element of self is equal to the corresponding element of other.

pub fn simd_ne<Rhs>(self, other: Rhs) -> <Self as CmpNe<Rhs>>::Output

where Self: CmpNe<Rhs>,

Returns a mask that checks if each element of self is not equal to the corresponding element of other.

pub fn simd_lt<Rhs>(self, other: Rhs) -> <Self as CmpLt<Rhs>>::Output

where Self: CmpLt<Rhs>,

Returns a mask that checks if each element of self is less than the corresponding element of other.

pub fn simd_gt<Rhs>(self, other: Rhs) -> <Self as CmpGt<Rhs>>::Output

where Self: CmpGt<Rhs>,

Returns a mask that checks if each element of self is greater than the corresponding element of other.

pub fn simd_le<Rhs>(self, other: Rhs) -> <Self as CmpLe<Rhs>>::Output

where Self: CmpLe<Rhs>,

Returns a mask that checks if each element of self is less than or equal to the corresponding element of other.

pub fn simd_ge<Rhs>(self, other: Rhs) -> <Self as CmpGe<Rhs>>::Output

where Self: CmpGe<Rhs>,

Returns a mask that checks if each element of self is greater than or equal to the corresponding element of other.

pub fn bitselect(self, if_one: Self, if_zero: Self) -> Self

Bitwise selection.

For each bit of self:

• If the bit is one, return the corresponding bit of if_one
• If the bit is zero, return the corresponding bit of if_zero

If you know self is a mask, meaning each element is either all zeros or all ones, consider using select which is faster.

pub fn select(self, if_true: Self, if_false: Self) -> Self

Elementwise selection.

For each element of self:

• If all bits are one, return the corresponding element of if_true
• If all bits are zero, return the corresponding element of if_false

This function assumes self is a mask, meaning each element is either all zeros or all ones. For bitwise selection use bitselect.

pub fn to_bitmask(self) -> u32

Converts to a bitmask, where each bit is 1 if the element of self is true or 0 if the element of self is false.

Each bit of the output corresponds to an element of self. The least significant bit corresponds to the lowest element. Remaining bits are 0.

This function assumes self is a mask, meaning each element is either all zeros or all ones. If the input is not a mask, the result is unspecified.

pub fn any(self) -> bool

Returns true if any element of self is true.

This function assumes self is a mask, meaning each element is either all zeros or all ones. If the input is not a mask, the result is unspecified.

pub fn all(self) -> bool

Returns true if all elements of self are true.

This function assumes self is a mask, meaning each element is either all zeros or all ones. If the input is not a mask, the result is unspecified.

pub fn none(self) -> bool

Returns true if none of the elements of self are true.

This function assumes self is a mask, meaning each element is either all zeros or all ones. If the input is not a mask, the result is unspecified.

pub fn transpose(data: [f64x8; 8]) -> [f64x8; 8]

Transposes an array of SIMD vectors interpreted as a square matrix.

Currently this function is never accelerated.

pub fn blend(self, if_true: Self, if_false: Self) -> Self

👎Deprecated since 1.6.0:

split into select and bitselect functions

Elementwise selection.

For each element of self:

• If all bits are one, return the corresponding element of if_true
• If all bits are zero, return the corresponding element of if_false

Originally this function did not specify whether it supported per-bit selection, or if it assumed self is a mask, meaning each element is either all zeros or all ones (for better performance). Because of this, blend has been split into two new functions: select and bitselect.

impl f64x8

The following functionality exists for all SIMD vectors of floats.

pub const ONE: Self

A SIMD vector with all elements set to 1.0.

pub const HALF: Self

A SIMD vector with all elements set to 0.5.

pub const ZERO: Self

A SIMD vector with all elements set to 0.0.

pub const EPSILON: Self

A SIMD vector with all elements set to f64::EPSILON.

pub const MIN: Self

A SIMD vector with all elements set to f64::MIN.

pub const MIN_POSITIVE: Self

A SIMD vector with all elements set to f64::MIN_POSITIVE.

pub const MAX: Self

A SIMD vector with all elements set to f64::MAX.

pub const NAN: Self

A SIMD vector with all elements set to f64::NAN.

pub const INFINITY: Self

A SIMD vector with all elements set to f64::INFINITY.

pub const NEG_INFINITY: Self

A SIMD vector with all elements set to f64::NEG_INFINITY.

pub const E: Self

A SIMD vector with all elements set to Euler’s number (e).

pub const FRAC_1_PI: Self

A SIMD vector with all elements set to 1/π.

pub const FRAC_2_PI: Self

A SIMD vector with all elements set to 2/π.

pub const FRAC_2_SQRT_PI: Self

A SIMD vector with all elements set to 2/sqrt(π).

pub const FRAC_1_SQRT_2: Self

A SIMD vector with all elements set to 1/sqrt(2).

pub const FRAC_PI_2: Self

A SIMD vector with all elements set to π/2.

pub const FRAC_PI_3: Self

A SIMD vector with all elements set to π/3.

pub const FRAC_PI_4: Self

A SIMD vector with all elements set to π/4.

pub const FRAC_PI_6: Self

A SIMD vector with all elements set to π/6.

pub const FRAC_PI_8: Self

A SIMD vector with all elements set to π/8.

pub const LN_2: Self

A SIMD vector with all elements set to ln(2).

pub const LN_10: Self

A SIMD vector with all elements set to ln(10).

pub const LOG2_E: Self

A SIMD vector with all elements set to log₂(e).

pub const LOG10_E: Self

A SIMD vector with all elements set to log₁₀(e).

pub const LOG10_2: Self

A SIMD vector with all elements set to log₁₀(2).

pub const LOG2_10: Self

A SIMD vector with all elements set to log₂(10).

pub const PI: Self

A SIMD vector with all elements set to Archimedes’ constant (π).

pub const SQRT_2: Self

A SIMD vector with all elements set to sqrt(2).

pub const TAU: Self

A SIMD vector with all elements set to the full circle constant (τ).

Equal to 2π.

pub fn reduce_add(self) -> f64

Reducing addition. Returns the sum of the vector’s elements.

Equivalent to self[0] + self[1] + ....

Unspecified precision

The order of addition is non-deterministic. This means it varies by platform, version, and can even differ within the same execution from one invocation to the next.

pub fn reduce_mul(self) -> f64

Reducing multiplication. Returns the product of the vector’s elements.

Equivalent to self[0] * self[1] * ....

Unspecified precision

The order of multiplication is non-deterministic. This means it varies by platform, version, and can even differ within the same execution from one invocation to the next.

pub fn is_nan(self) -> Self

Returns a mask that checks if each element is NaN.

pub fn is_inf(self) -> Self

Returns a mask that checks if each element is infinity (either positive or negative).

pub fn is_finite(self) -> Self

Returns a mask that checks if each element is neither infinite nor NaN.

pub fn is_sign_positive(self) -> Self

Returns a mask that checks if each element has a positive sign, including +0.0, NaNs with positive sign bit and positive infinity.

pub fn is_sign_negative(self) -> Self

Returns a mask that checks if each element has a negative sign, including -0.0, NaNs with negative sign bit and negative infinity.

pub fn recip(self) -> Self

Returns the reciprocal (inverse) of a number, 1/x.

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, version, and can even differ within the same execution from one invocation to the next.

To compute the reciprocal deterministically, use f64x8::ONE / x.

pub fn recip_sqrt(self) -> Self

Returns the square root of the reciprocal (inverse) of a number, sqrt(1/x).

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, version, and can even differ within the same execution from one invocation to the next.

pub fn to_degrees(self) -> Self

Converts radians to degrees.

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, version, and can even differ within the same execution from one invocation to the next.

pub fn to_radians(self) -> Self

Converts degrees to radians.

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, version, and can even differ within the same execution from one invocation to the next.

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

Returns the maximum between each element of self and the corresponding element of other, ignoring NaN.

For each lane, if exactly one of the arguments is NaN, then the other argument is returned. If both arguments are NaN, the return value is NaN. If the inputs compare equal (such as for the case of +0.0 and -0.0), either input may be returned non-deterministically.

See fast_max for a faster variant that does not handle NaNs.

pub fn fast_max(self, rhs: Self) -> Self

Returns the maximum between each element of self and the corresponding element of other, not specifying behavior for NaNs.

For each lane, if both arguments are NaN, the return value is NaN. If the inputs compare equal (such as for the case of +0.0 and -0.0), or if exactly one of the arguments is NaN, either input may be returned non-deterministically.

See max for a slower variant that does handle NaNs.

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

Returns the minimum between each element of self and the corresponding element of other, ignoring NaN.

For each lane, if exactly one of the arguments is NaN, then the other argument is returned. If both arguments are NaN, the return value is NaN. If the inputs compare equal (such as for the case of +0.0 and -0.0), either input may be returned non-deterministically.

See fast_min for a faster variant that does not handle NaNs.

pub fn fast_min(self, rhs: Self) -> Self

Returns the minimum between each element of self and the corresponding element of other, not specifying behavior for NaNs.

For each lane, if both arguments are NaN, the return value is NaN. If the inputs compare equal (such as for the case of +0.0 and -0.0), or if exactly one of the arguments is NaN, either input may be returned non-deterministically.

See min for a slower variant that does handle NaNs.

pub fn midpoint(self, other: Self) -> Self

Calculates the midpoint (average) between self and other.

This returns NaN when either argument is NaN or if a combination of +inf and -inf is provided as arguments.

This function currently returns a less precise result than f64::midpoint in order to gain performance, but this may change in the future.

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, version, and can even differ within the same execution from one invocation to the next.

pub const fn to_bits(self) -> u64x8

Raw transmutation to unsigned integer vector.

Note that this function preserves the bitwise value, and not the numeric value.

pub const fn from_bits(bits: u64x8) -> Self

Raw transmutation from unsigned integer vector.

Note that this function preserves the bitwise value, and not the numeric value.

pub fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval unless it is NaN.

If self, min or max are NaN, the result is NaN. If min > max, the result is min. If inputs compare equal (such as for the case of +0.0 and -0.0), either input may be returned non-deterministically.

See fast_clamp for a faster variant that does not handle min or max being NaN.

pub fn fast_clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval unless it is NaN.

If self is NaN, the result is NaN. If min > max, the result is min. If inputs compare equal (such as for the case of +0.0 and -0.0), or if min or max are NaN, any input may be returned non-deterministically.

See clamp for a slower variant that also handles min or max being NaN.

pub fn abs(self) -> Self

Computes the absolute value of self.

This function always returns the precise result.

pub fn signum(self) -> Self

Returns numbers that represents the signs of each element.

• 1.0 if the element is positive, +0.0 or INFINITY
• -1.0 if the element is negative, -0.0 or NEG_INFINITY
• NaN if the element is NaN

pub fn copysign(self, sign: Self) -> Self

Returns numbers composed of the magnitudes of self and the signs of sign.

Equal to self if the sign of self and sign are the same, otherwise equal to -self. Even if self or sign are NaN, the result is the exact bit pattern of self with the sign bit of sign.

pub fn flip_signs(self, sign: Self) -> Self

Flips the sign of self based on the sign of sign.

If sign has a positive sign, the result is self. If sign has a negative sign, the result is -self. Even if self or sign are NaN, the result is the exact bit pattern of self with a sign flipped based on the sign bit of sign.

pub fn floor(self) -> Self

Returns the largest integer less than or equal to each input element.

This function always returns the precise result.

pub fn ceil(self) -> Self

Returns the smallest integer greater than or equal to each input element.

This function always returns the precise result.

pub fn round(self) -> Self

Returns the nearest integer to each input element. If a value is half-way between two integers, round away from 0.0.

This function always returns the precise result.

For most targets architectures, round is slower than round_ties_even. If you do not care about the difference, consider using that instead.

pub fn round_int(self) -> i64x8

Returns the nearest integer to each input element.

The result for values half-way between two integers is currently not specified.

This saturates out of range values and turns NaNs to 0. See fast_round_int for a faster variant that does not handle out of range values or NaNs.

pub fn fast_round_int(self) -> i64x8

Returns the nearest integer to each input element.

The result for values half-way between two integers is currently not specified.

This function does not handle out of range values or NaNs. See round_int for a slower variant that does handle out of range values and NaNs.

pub fn round_ties_even(self) -> Self

Returns the nearest integer to each input element. Rounds half-way cases to the number with an even least significant digit.

This function always returns the precise result.

pub fn trunc(self) -> Self

Returns the integer part of each input element. This means that non-integer numbers are always truncated towards zero.

This function always returns the precise result.

pub fn trunc_int(self) -> i64x8

Returns the integer part of each input element. This means that non-integer numbers are always truncated towards zero.

This saturates out of range values and turns NaNs to 0. See fast_trunc_int for a faster variant that does not handle out of range values or NaNs.

pub fn fast_trunc_int(self) -> i64x8

Returns the integer part of each input element. This means that non-integer numbers are always truncated towards zero.

This function does not handle out of range values or NaNs. See trunc_int for a slower variant that does handle out of range values and NaNs.

pub fn fract(self) -> Self

Returns the fractional part of each input element.

This function always returns the precise result.

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

Fused multiply-add. Computes (self * a) + b.

If there is hardware FMA support, this computes the result with only one rounding error. If not, this falls back to separate multiply and add operations, resulting in two rounding errors. Note that in the future, this function may change to always having one rounding error, at the cost of worse performance.

Platform-specific behavior (may change in the future)

• On x86/x86_64 with AVX-512F+FMA: Uses 512-bit vfmadd (single rounding, best accuracy)
• On x86/x86_64 with AVX-512F only: Uses (self * m) + a (two roundings)
• Other platforms: Delegates to f64x4 (inherits its FMA behavior)

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

Fused multiply-sub. Computes (self * a) - b.

If there is hardware FMA support, this computes the result with only one rounding error. If not, this falls back to separate multiply and add operations, resulting in two rounding errors. Note that in the future, this function may change to always having one rounding error, at the cost of worse performance.

Platform-specific behavior (may change in the future)

• On x86/x86_64 with AVX-512F+FMA: Uses 512-bit vfmsub (single rounding, best accuracy)
• On x86/x86_64 with AVX-512F only: Uses (self * m) - s (two roundings)
• Other platforms: Delegates to f64x4 (inherits its FMA behavior)

pub fn mul_neg_add(self, a: Self, b: Self) -> Self

Fused multiply-negate-add. Computes -(self * a) + b.

If there is hardware FMA support, this computes the result with only one rounding error. If not, this falls back to separate multiply and add operations, resulting in two rounding errors. Note that in the future, this function may change to always having one rounding error, at the cost of worse performance.

Platform-specific behavior (may change in the future)

• On x86/x86_64 with AVX-512F+FMA: Uses 512-bit vfnmadd (single rounding, best accuracy)
• On x86/x86_64 with AVX-512F only: Uses a - (self * m) (two roundings)
• Other platforms: Delegates to f64x4 (inherits its FMA behavior)

pub fn mul_neg_sub(self, a: Self, b: Self) -> Self

Fused multiply-negate-sub. Computes -(self * a) - b.

If there is hardware FMA support, this computes the result with only one rounding error. If not, this falls back to separate multiply and add operations, resulting in two rounding errors. Note that in the future, this function may change to always having one rounding error, at the cost of worse performance.

Platform-specific behavior (may change in the future)

• On x86/x86_64 with AVX-512F+FMA: Uses 512-bit vfnmsub (single rounding, best accuracy)
• On x86/x86_64 with AVX-512F only: Uses -(self * m) - s (two roundings)
• Other platforms: Delegates to f64x4 (inherits its FMA behavior)

pub fn div_euclid(self, rhs: Self) -> Self

Calculates Euclidean division, the matching function for rem_euclid.

This computes the integer n such that self = n * rhs + self.rem_euclid(rhs). In other words, the result is self / rhs rounded to the integer n such that self >= n * rhs.

This function is not guaranteed to exactly match f64::div_euclid.

pub fn rem_euclid(self, rhs: Self) -> Self

Calculates the least nonnegative remainder of self when divided by rhs.

In particular, the return value r satisfies 0.0 <= r < rhs.abs() in most cases. However, due to a floating point round-off error it can result in r == rhs.abs(), violating the mathematical definition, if self is much smaller than rhs.abs() in magnitude and self < 0.0. This result is not an element of the function’s codomain, but it is the closest floating point number in the real numbers and thus fulfills the property self == self.div_euclid(rhs) * rhs + self.rem_euclid(rhs) approximately.

This function is not guaranteed to exactly match f64::rem_euclid.

pub fn powf_simd(self, n: Self) -> Self

Raises each element of the number self to the corresponding element of the floating point power n.

This function cannot be named simply powf, because a now deprecated function already uses that name.

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, version, and can even differ within the same execution from one invocation to the next.

pub fn sqrt(self) -> Self

Returns the square root of a number for each input element.

Returns NaN if self is a negative number other than -0.0.

This function always returns the precise result.

pub fn exp(self) -> Self

Returns e^(self), (the exponential function) for each input element.

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, version, and can even differ within the same execution from one invocation to the next. Calculate the exponent of a packed f64x8

pub fn exp2(self) -> Self

Returns 2^(self) for each input element.

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, version, and can even differ within the same execution from one invocation to the next.

pub fn ln(self) -> Self

Returns the natural logarithm of a number for each input element.

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, version, and can even differ within the same execution from one invocation to the next.

pub fn log2(self) -> Self

Returns the base 2 logarithm of a number for each input element.

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, version, and can even differ within the same execution from one invocation to the next.

pub fn log10(self) -> Self

Returns the base 10 logarithm of a number for each input element.

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, version, and can even differ within the same execution from one invocation to the next.

pub fn cbrt(self) -> Self

Returns the cube root of a number for each input element.

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, version, and can even differ within the same execution from one invocation to the next.

pub fn sin(self) -> Self

Computes the sine of a number (in radians) for each input element.

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, version, and can even differ within the same execution from one invocation to the next.

pub fn cos(self) -> Self

Computes the cosine of a number (in radians) for each input element.

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, version, and can even differ within the same execution from one invocation to the next.

pub fn tan(self) -> Self

Computes the tangent of a number (in radians) for each input element.

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, version, and can even differ within the same execution from one invocation to the next.

pub fn asin(self) -> Self

Computes the arcsine of a number for each input element. Return value is in radians in the range [-pi/2, pi/2] or NaN if the number is outside the range [-1, 1].

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, version, and can even differ within the same execution from one invocation to the next.

pub fn acos(self) -> Self

Computes the arccosine of a number for each input element. Return value is in radians in the range [0, pi] or NaN if the number is outside the range [-1, 1].

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, version, and can even differ within the same execution from one invocation to the next.

pub fn atan(self) -> Self

Computes the arctangent of a number for each input element. Return value is in radians in the range [-pi/2, pi/2].

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, version, and can even differ within the same execution from one invocation to the next.

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

Computes the four quadrant arctangent of each element of self (y) and the corresponding element of other (x) in radians.

x	y	Piecewise Definition	Range
>= +0	>= +0	arctan(y/x)	[+0, +pi/2]
>= +0	<= -0	arctan(y/x)	[-pi/2, -0]
<= -0	>= +0	arctan(y/x) + pi	[+pi/2, +pi]
<= -0	<= -0	arctan(y/x) - pi	[-pi, -pi/2]

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, version, and can even differ within the same execution from one invocation to the next.

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

Simultaneously computes the sine and cosine of a number x for each input element. Returns (sin(x), cos(x)).

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, version, and can even differ within the same execution from one invocation to the next.

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

Simultaneously computes the arcsine and arccosine of a number x for each input element. Returns (asin(x), acos(x)).

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, version, and can even differ within the same execution from one invocation to the next.

pub fn exp_m1(self) -> Self

Returns e^(self) - 1 for each input element in a way that is accurate even if a number is close to zero.

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, version, and can even differ within the same execution from one invocation to the next.

pub fn ln_1p(self) -> Self

Returns ln(1+n) (natural logarithm) for each input element more accurately than if the operations were performed separately.

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, version, and can even differ within the same execution from one invocation to the next.

pub fn sinh(self) -> Self

Returns the hyperbolic sine ((e^self - e^(-self))/2) for each input element.

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, version, and can even differ within the same execution from one invocation to the next.

pub fn cosh(self) -> Self

Returns the hyperbolic cosine ((e^self + e^(-self))/2) for each input element.

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, version, and can even differ within the same execution from one invocation to the next.

pub fn tanh(self) -> Self

Returns the hyperbolic tangent (sinh(self)/cosh(self)) for each input element.

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, version, and can even differ within the same execution from one invocation to the next.

pub fn pow_f64x8(self, n: Self) -> Self

👎Deprecated since 1.6.0:

renamed to powf_simd

Raises each element of the number self to the corresponding element of the floating point power n.

This function has been renamed to powf_simd.

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, version, and can even differ within the same execution from one invocation to the next.

pub fn powf(self, n: f64) -> Self

👎Deprecated since 1.6.0:

use x.powf_simd(splat(n)) instead

Raises each element of the number self to the scalar floating point power n.

This function has been deprecated because it raises all elements of x to the same power, even though that brings no performance benefit. Use x.powf_simd(f64x8::splat(n)) instead.

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, version, and can even differ within the same execution from one invocation to the next.

impl f64x8

The following functionality exists only for f64x8, or only for particular types inconsistently.

pub fn from_i32x8(v: i32x8) -> Self

Converts each element from i32 to f64.

Trait Implementations

impl Add for f64x8

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

Computes addition for each element of self and the corresponding element of rhs.

This always returns the precise result.

type Output = f64x8

The resulting type after applying the + operator.

impl Add<&f64> for f64x8

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

Computes addition for each element of self and the uniform scalar rhs.

This always returns the precise result.

type Output = f64x8

The resulting type after applying the + operator.

impl Add<&f64> for &f64x8

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

Computes addition for each element of self and the uniform scalar rhs.

This always returns the precise result.

type Output = f64x8

The resulting type after applying the + operator.

impl Add<&f64x8> for f64x8

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

Computes addition for each element of self and the corresponding element of rhs.

This always returns the precise result.

type Output = f64x8

The resulting type after applying the + operator.

impl Add<&f64x8> for f64

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

Computes addition for the uniform scalar self and each element of rhs, returning a SIMD vector.

This always returns the precise result.

type Output = f64x8

The resulting type after applying the + operator.

impl Add<&f64x8> for &f64x8

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

Computes addition for each element of self and the corresponding element of rhs.

This always returns the precise result.

type Output = f64x8

The resulting type after applying the + operator.

impl Add<&f64x8> for &f64

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

Computes addition for the uniform scalar self and each element of rhs, returning a SIMD vector.

This always returns the precise result.

type Output = f64x8

The resulting type after applying the + operator.

impl Add<f64> for f64x8

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

Computes addition for each element of self and the uniform scalar rhs.

This always returns the precise result.

type Output = f64x8

The resulting type after applying the + operator.

impl Add<f64> for &f64x8

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

Computes addition for each element of self and the uniform scalar rhs.

This always returns the precise result.

type Output = f64x8

The resulting type after applying the + operator.

impl Add<f64x8> for f64

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

Computes addition for the uniform scalar self and each element of rhs, returning a SIMD vector.

This always returns the precise result.

type Output = f64x8

The resulting type after applying the + operator.

impl Add<f64x8> for &f64x8

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

Computes addition for each element of self and the corresponding element of rhs.

This always returns the precise result.

type Output = f64x8

The resulting type after applying the + operator.

impl Add<f64x8> for &f64

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

Computes addition for the uniform scalar self and each element of rhs, returning a SIMD vector.

This always returns the precise result.

type Output = f64x8

The resulting type after applying the + operator.

impl AddAssign for f64x8

fn add_assign(&mut self, rhs: Self)

Computes addition for each element of self and the corresponding element of rhs.

This always returns the precise result.

impl AddAssign<&f64> for f64x8

fn add_assign(&mut self, rhs: &f64)

Computes addition for each element of self and the uniform scalar rhs.

This always returns the precise result.

impl AddAssign<&f64x8> for f64x8

fn add_assign(&mut self, rhs: &Self)

Computes addition for each element of self and the corresponding element of rhs.

This always returns the precise result.

impl AddAssign<f64> for f64x8

fn add_assign(&mut self, rhs: f64)

Computes addition for each element of self and the uniform scalar rhs.

This always returns the precise result.

impl AlignTo for f64x8

type Elem = f64

The element type of this SIMD vector.

fn simd_align_to( slice: &[Self::Elem], ) -> (&[Self::Elem], &[Self], &[Self::Elem])

A SIMD variant of align_to.

fn simd_align_to_mut( slice: &mut [Self::Elem], ) -> (&mut [Self::Elem], &mut [Self], &mut [Self::Elem])

A SIMD variant of align_to_mut.

impl Binary for f64x8

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

Formats the value using the given formatter.

impl BitAnd for f64x8

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

Computes bitwise AND for each element of self and the corresponding element of rhs.

This operator is not implemented for primitive scalar floats, but its behavior here is the same as for integers.

type Output = f64x8

The resulting type after applying the & operator.

impl BitAnd<&f64> for f64x8

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

Computes bitwise AND for each element of self and the uniform scalar rhs.

This operator is not implemented for primitive scalar floats, but its behavior here is the same as for integers.

type Output = f64x8

The resulting type after applying the & operator.

impl BitAnd<&f64> for &f64x8

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

Computes bitwise AND for each element of self and the uniform scalar rhs.

This operator is not implemented for primitive scalar floats, but its behavior here is the same as for integers.

type Output = f64x8

The resulting type after applying the & operator.

impl BitAnd<&f64x8> for f64x8

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

Computes bitwise AND for each element of self and the corresponding element of rhs.

This operator is not implemented for primitive scalar floats, but its behavior here is the same as for integers.

type Output = f64x8

The resulting type after applying the & operator.

impl BitAnd<&f64x8> for f64

fn bitand(self, rhs: &f64x8) -> Self::Output

Computes bitwise AND for the uniform scalar self and each element of rhs, returning a SIMD vector.

This operator is not implemented for primitive scalar floats, but its behavior here is the same as for integers.

type Output = f64x8

The resulting type after applying the & operator.

impl BitAnd<&f64x8> for &f64x8

fn bitand(self, rhs: &f64x8) -> Self::Output

Computes bitwise AND for each element of self and the corresponding element of rhs.

This operator is not implemented for primitive scalar floats, but its behavior here is the same as for integers.

type Output = f64x8

The resulting type after applying the & operator.

impl BitAnd<&f64x8> for &f64

fn bitand(self, rhs: &f64x8) -> Self::Output

Computes bitwise AND for the uniform scalar self and each element of rhs, returning a SIMD vector.

This operator is not implemented for primitive scalar floats, but its behavior here is the same as for integers.

type Output = f64x8

The resulting type after applying the & operator.

impl BitAnd<f64> for f64x8

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

Computes bitwise AND for each element of self and the uniform scalar rhs.

This operator is not implemented for primitive scalar floats, but its behavior here is the same as for integers.

type Output = f64x8

The resulting type after applying the & operator.

impl BitAnd<f64> for &f64x8

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

Computes bitwise AND for each element of self and the uniform scalar rhs.

This operator is not implemented for primitive scalar floats, but its behavior here is the same as for integers.

type Output = f64x8

The resulting type after applying the & operator.

impl BitAnd<f64x8> for f64

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

Computes bitwise AND for the uniform scalar self and each element of rhs, returning a SIMD vector.

This operator is not implemented for primitive scalar floats, but its behavior here is the same as for integers.

type Output = f64x8

The resulting type after applying the & operator.

impl BitAnd<f64x8> for &f64x8

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

Computes bitwise AND for each element of self and the corresponding element of rhs.

This operator is not implemented for primitive scalar floats, but its behavior here is the same as for integers.

type Output = f64x8

The resulting type after applying the & operator.

impl BitAnd<f64x8> for &f64

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

Computes bitwise AND for the uniform scalar self and each element of rhs, returning a SIMD vector.

This operator is not implemented for primitive scalar floats, but its behavior here is the same as for integers.

type Output = f64x8

The resulting type after applying the & operator.

impl BitAndAssign for f64x8

fn bitand_assign(&mut self, rhs: Self)

Computes bitwise AND for each element of self and the corresponding element of rhs.

This operator is not implemented for primitive scalar floats, but its behavior here is the same as for integers.

impl BitAndAssign<&f64> for f64x8

fn bitand_assign(&mut self, rhs: &f64)

Computes bitwise AND for each element of self and the uniform scalar rhs.

This operator is not implemented for primitive scalar floats, but its behavior here is the same as for integers.

impl BitAndAssign<&f64x8> for f64x8

fn bitand_assign(&mut self, rhs: &Self)

Computes bitwise AND for each element of self and the corresponding element of rhs.

This operator is not implemented for primitive scalar floats, but its behavior here is the same as for integers.

impl BitAndAssign<f64> for f64x8

fn bitand_assign(&mut self, rhs: f64)

Computes bitwise AND for each element of self and the uniform scalar rhs.

This operator is not implemented for primitive scalar floats, but its behavior here is the same as for integers.

impl BitOr for f64x8

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

Computes bitwise OR for each element of self and the corresponding element of rhs.

This operator is not implemented for primitive scalar floats, but its behavior here is the same as for integers.

type Output = f64x8

The resulting type after applying the | operator.

impl BitOr<&f64> for f64x8

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

Computes bitwise OR for each element of self and the uniform scalar rhs.

This operator is not implemented for primitive scalar floats, but its behavior here is the same as for integers.

type Output = f64x8

The resulting type after applying the | operator.

impl BitOr<&f64> for &f64x8

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

Computes bitwise OR for each element of self and the uniform scalar rhs.

This operator is not implemented for primitive scalar floats, but its behavior here is the same as for integers.

type Output = f64x8

The resulting type after applying the | operator.

impl BitOr<&f64x8> for f64x8

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

Computes bitwise OR for each element of self and the corresponding element of rhs.

This operator is not implemented for primitive scalar floats, but its behavior here is the same as for integers.

type Output = f64x8

The resulting type after applying the | operator.

impl BitOr<&f64x8> for f64

fn bitor(self, rhs: &f64x8) -> Self::Output

Computes bitwise OR for the uniform scalar self and each element of rhs, returning a SIMD vector.

This operator is not implemented for primitive scalar floats, but its behavior here is the same as for integers.

type Output = f64x8

The resulting type after applying the | operator.

impl BitOr<&f64x8> for &f64x8

fn bitor(self, rhs: &f64x8) -> Self::Output

Computes bitwise OR for each element of self and the corresponding element of rhs.

This operator is not implemented for primitive scalar floats, but its behavior here is the same as for integers.

type Output = f64x8

The resulting type after applying the | operator.

impl BitOr<&f64x8> for &f64

fn bitor(self, rhs: &f64x8) -> Self::Output

Computes bitwise OR for the uniform scalar self and each element of rhs, returning a SIMD vector.

This operator is not implemented for primitive scalar floats, but its behavior here is the same as for integers.

type Output = f64x8

The resulting type after applying the | operator.

impl BitOr<f64> for f64x8

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

Computes bitwise OR for each element of self and the uniform scalar rhs.

This operator is not implemented for primitive scalar floats, but its behavior here is the same as for integers.

type Output = f64x8

The resulting type after applying the | operator.

impl BitOr<f64> for &f64x8

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

Computes bitwise OR for each element of self and the uniform scalar rhs.

This operator is not implemented for primitive scalar floats, but its behavior here is the same as for integers.

type Output = f64x8

The resulting type after applying the | operator.

impl BitOr<f64x8> for f64

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

Computes bitwise OR for the uniform scalar self and each element of rhs, returning a SIMD vector.

This operator is not implemented for primitive scalar floats, but its behavior here is the same as for integers.

type Output = f64x8

The resulting type after applying the | operator.

impl BitOr<f64x8> for &f64x8

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

Computes bitwise OR for each element of self and the corresponding element of rhs.

This operator is not implemented for primitive scalar floats, but its behavior here is the same as for integers.

type Output = f64x8

The resulting type after applying the | operator.

impl BitOr<f64x8> for &f64

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

Computes bitwise OR for the uniform scalar self and each element of rhs, returning a SIMD vector.

This operator is not implemented for primitive scalar floats, but its behavior here is the same as for integers.

type Output = f64x8

The resulting type after applying the | operator.

impl BitOrAssign for f64x8

fn bitor_assign(&mut self, rhs: Self)

Computes bitwise OR for each element of self and the corresponding element of rhs.

This operator is not implemented for primitive scalar floats, but its behavior here is the same as for integers.

impl BitOrAssign<&f64> for f64x8

fn bitor_assign(&mut self, rhs: &f64)

Computes bitwise OR for each element of self and the uniform scalar rhs.

This operator is not implemented for primitive scalar floats, but its behavior here is the same as for integers.

impl BitOrAssign<&f64x8> for f64x8

fn bitor_assign(&mut self, rhs: &Self)

Computes bitwise OR for each element of self and the corresponding element of rhs.

This operator is not implemented for primitive scalar floats, but its behavior here is the same as for integers.

impl BitOrAssign<f64> for f64x8

fn bitor_assign(&mut self, rhs: f64)

Computes bitwise OR for each element of self and the uniform scalar rhs.

This operator is not implemented for primitive scalar floats, but its behavior here is the same as for integers.

impl BitXor for f64x8

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

Computes bitwise XOR for each element of self and the corresponding element of rhs.

This operator is not implemented for primitive scalar floats, but its behavior here is the same as for integers.

type Output = f64x8

The resulting type after applying the ^ operator.

impl BitXor<&f64> for f64x8

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

Computes bitwise XOR for each element of self and the uniform scalar rhs.

This operator is not implemented for primitive scalar floats, but its behavior here is the same as for integers.

type Output = f64x8

The resulting type after applying the ^ operator.

impl BitXor<&f64> for &f64x8

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

Computes bitwise XOR for each element of self and the uniform scalar rhs.

This operator is not implemented for primitive scalar floats, but its behavior here is the same as for integers.

type Output = f64x8

The resulting type after applying the ^ operator.

impl BitXor<&f64x8> for f64x8

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

Computes bitwise XOR for each element of self and the corresponding element of rhs.

This operator is not implemented for primitive scalar floats, but its behavior here is the same as for integers.

type Output = f64x8

The resulting type after applying the ^ operator.

impl BitXor<&f64x8> for f64

fn bitxor(self, rhs: &f64x8) -> Self::Output

Computes bitwise XOR for the uniform scalar self and each element of rhs, returning a SIMD vector.

This operator is not implemented for primitive scalar floats, but its behavior here is the same as for integers.

type Output = f64x8

The resulting type after applying the ^ operator.

impl BitXor<&f64x8> for &f64x8

fn bitxor(self, rhs: &f64x8) -> Self::Output

Computes bitwise XOR for each element of self and the corresponding element of rhs.

This operator is not implemented for primitive scalar floats, but its behavior here is the same as for integers.

type Output = f64x8

The resulting type after applying the ^ operator.

impl BitXor<&f64x8> for &f64

fn bitxor(self, rhs: &f64x8) -> Self::Output

Computes bitwise XOR for the uniform scalar self and each element of rhs, returning a SIMD vector.

This operator is not implemented for primitive scalar floats, but its behavior here is the same as for integers.

type Output = f64x8

The resulting type after applying the ^ operator.

impl BitXor<f64> for f64x8

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

Computes bitwise XOR for each element of self and the uniform scalar rhs.

This operator is not implemented for primitive scalar floats, but its behavior here is the same as for integers.

type Output = f64x8

The resulting type after applying the ^ operator.

impl BitXor<f64> for &f64x8

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

Computes bitwise XOR for each element of self and the uniform scalar rhs.

This operator is not implemented for primitive scalar floats, but its behavior here is the same as for integers.

type Output = f64x8

The resulting type after applying the ^ operator.

impl BitXor<f64x8> for f64

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

Computes bitwise XOR for the uniform scalar self and each element of rhs, returning a SIMD vector.

This operator is not implemented for primitive scalar floats, but its behavior here is the same as for integers.

type Output = f64x8

The resulting type after applying the ^ operator.

impl BitXor<f64x8> for &f64x8

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

Computes bitwise XOR for each element of self and the corresponding element of rhs.

This operator is not implemented for primitive scalar floats, but its behavior here is the same as for integers.

type Output = f64x8

The resulting type after applying the ^ operator.

impl BitXor<f64x8> for &f64

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

Computes bitwise XOR for the uniform scalar self and each element of rhs, returning a SIMD vector.

This operator is not implemented for primitive scalar floats, but its behavior here is the same as for integers.

type Output = f64x8

The resulting type after applying the ^ operator.

impl BitXorAssign for f64x8

fn bitxor_assign(&mut self, rhs: Self)

Computes bitwise XOR for each element of self and the corresponding element of rhs.

This operator is not implemented for primitive scalar floats, but its behavior here is the same as for integers.

impl BitXorAssign<&f64> for f64x8

fn bitxor_assign(&mut self, rhs: &f64)

Computes bitwise XOR for each element of self and the uniform scalar rhs.

This operator is not implemented for primitive scalar floats, but its behavior here is the same as for integers.

impl BitXorAssign<&f64x8> for f64x8

fn bitxor_assign(&mut self, rhs: &Self)

Computes bitwise XOR for each element of self and the corresponding element of rhs.

This operator is not implemented for primitive scalar floats, but its behavior here is the same as for integers.

impl BitXorAssign<f64> for f64x8

fn bitxor_assign(&mut self, rhs: f64)

Computes bitwise XOR for each element of self and the uniform scalar rhs.

This operator is not implemented for primitive scalar floats, but its behavior here is the same as for integers.

impl Clone for f64x8

fn clone(&self) -> f64x8

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl CmpEq for f64x8

type Output = f64x8

👎Deprecated since 1.5.0:

use the inherent function simd_eq instead

The type returned by simd_eq.

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

👎Deprecated since 1.5.0:

use the inherent function simd_eq instead

Returns a mask that checks if each element of self is equal to the corresponding element of rhs.

impl CmpEq<f64> for f64x8

type Output = f64x8

👎Deprecated since 1.5.0:

use the inherent function simd_eq instead

The type returned by simd_eq.

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

👎Deprecated since 1.5.0:

use the inherent function simd_eq instead

Returns a mask that checks if each element of self is equal to the corresponding element of rhs.

impl CmpGe for f64x8

type Output = f64x8

👎Deprecated since 1.5.0:

use the inherent function simd_ge instead

The type returned by simd_ge.

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

👎Deprecated since 1.5.0:

use the inherent function simd_ge instead

Returns a mask that checks if each element of self is greater than or equal to the corresponding element of rhs.

impl CmpGe<f64> for f64x8

type Output = f64x8

👎Deprecated since 1.5.0:

use the inherent function simd_ge instead

The type returned by simd_ge.

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

👎Deprecated since 1.5.0:

use the inherent function simd_ge instead

Returns a mask that checks if each element of self is greater than or equal to the corresponding element of rhs.

impl CmpGt for f64x8

type Output = f64x8

👎Deprecated since 1.5.0:

use the inherent function simd_gt instead

The type returned by simd_gt.

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

👎Deprecated since 1.5.0:

use the inherent function simd_gt instead

Returns a mask that checks if each element of self is greater than the corresponding element of rhs.

impl CmpGt<f64> for f64x8

type Output = f64x8

👎Deprecated since 1.5.0:

use the inherent function simd_gt instead

The type returned by simd_gt.

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

👎Deprecated since 1.5.0:

use the inherent function simd_gt instead

Returns a mask that checks if each element of self is greater than the corresponding element of rhs.

impl CmpLe for f64x8

type Output = f64x8

👎Deprecated since 1.5.0:

use the inherent function simd_le instead

The type returned by simd_le.

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

👎Deprecated since 1.5.0:

use the inherent function simd_le instead

Returns a mask that checks if each element of self is less than or equal to the corresponding element of rhs.

impl CmpLe<f64> for f64x8

type Output = f64x8

👎Deprecated since 1.5.0:

use the inherent function simd_le instead

The type returned by simd_le.

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

👎Deprecated since 1.5.0:

use the inherent function simd_le instead

Returns a mask that checks if each element of self is less than or equal to the corresponding element of rhs.

impl CmpLt for f64x8

type Output = f64x8

👎Deprecated since 1.5.0:

use the inherent function simd_lt instead

The type returned by simd_lt.

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

👎Deprecated since 1.5.0:

use the inherent function simd_lt instead

Returns a mask that checks if each element of self is less than the corresponding element of rhs.

impl CmpLt<f64> for f64x8

type Output = f64x8

👎Deprecated since 1.5.0:

use the inherent function simd_lt instead

The type returned by simd_lt.

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

👎Deprecated since 1.5.0:

use the inherent function simd_lt instead

Returns a mask that checks if each element of self is less than the corresponding element of rhs.

impl CmpNe for f64x8

type Output = f64x8

👎Deprecated since 1.5.0:

use the inherent function simd_ne instead

The type returned by simd_ne.

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

👎Deprecated since 1.5.0:

use the inherent function simd_ne instead

Returns a mask that checks if each element of self is not equal to the corresponding element of rhs.

impl CmpNe<f64> for f64x8

type Output = f64x8

👎Deprecated since 1.5.0:

use the inherent function simd_ne instead

The type returned by simd_ne.

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

👎Deprecated since 1.5.0:

use the inherent function simd_ne instead

Returns a mask that checks if each element of self is not equal to the corresponding element of rhs.

impl Copy for f64x8

impl Debug for f64x8

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

Formats the value using the given formatter.

impl Default for f64x8

fn default() -> f64x8

Returns the “default value” for a type.

impl Display for f64x8

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

Formats the value using the given formatter.

impl Div for f64x8

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

Computes division for each element of self and the corresponding element of rhs.

This always returns the precise result.

type Output = f64x8

The resulting type after applying the / operator.

impl Div<&f64> for f64x8

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

Computes division for each element of self and the uniform scalar rhs.

This always returns the precise result.

type Output = f64x8

The resulting type after applying the / operator.

impl Div<&f64> for &f64x8

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

Computes division for each element of self and the uniform scalar rhs.

This always returns the precise result.

type Output = f64x8

The resulting type after applying the / operator.

impl Div<&f64x8> for f64x8

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

Computes division for each element of self and the corresponding element of rhs.

This always returns the precise result.

type Output = f64x8

The resulting type after applying the / operator.

impl Div<&f64x8> for f64

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

Computes division for the uniform scalar self and each element of rhs, returning a SIMD vector.

This always returns the precise result.

type Output = f64x8

The resulting type after applying the / operator.

impl Div<&f64x8> for &f64x8

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

Computes division for each element of self and the corresponding element of rhs.

This always returns the precise result.

type Output = f64x8

The resulting type after applying the / operator.

impl Div<&f64x8> for &f64

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

Computes division for the uniform scalar self and each element of rhs, returning a SIMD vector.

This always returns the precise result.

type Output = f64x8

The resulting type after applying the / operator.

impl Div<f64> for f64x8

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

Computes division for each element of self and the uniform scalar rhs.

This always returns the precise result.

type Output = f64x8

The resulting type after applying the / operator.

impl Div<f64> for &f64x8

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

Computes division for each element of self and the uniform scalar rhs.

This always returns the precise result.

type Output = f64x8

The resulting type after applying the / operator.

impl Div<f64x8> for f64

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

Computes division for the uniform scalar self and each element of rhs, returning a SIMD vector.

This always returns the precise result.

type Output = f64x8

The resulting type after applying the / operator.

impl Div<f64x8> for &f64x8

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

Computes division for each element of self and the corresponding element of rhs.

This always returns the precise result.

type Output = f64x8

The resulting type after applying the / operator.

impl Div<f64x8> for &f64

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

Computes division for the uniform scalar self and each element of rhs, returning a SIMD vector.

This always returns the precise result.

type Output = f64x8

The resulting type after applying the / operator.

impl DivAssign for f64x8

fn div_assign(&mut self, rhs: Self)

Computes division for each element of self and the corresponding element of rhs.

This always returns the precise result.

impl DivAssign<&f64> for f64x8

fn div_assign(&mut self, rhs: &f64)

Computes division for each element of self and the uniform scalar rhs.

This always returns the precise result.

impl DivAssign<&f64x8> for f64x8

fn div_assign(&mut self, rhs: &Self)

Computes division for each element of self and the corresponding element of rhs.

This always returns the precise result.

impl DivAssign<f64> for f64x8

fn div_assign(&mut self, rhs: f64)

Computes division for each element of self and the uniform scalar rhs.

This always returns the precise result.

impl From<&[f64]> for f64x8

fn from(value: &[f64]) -> Self

Converts a slice to a SIMD vector, filling in zeros if there are not enough elements, and panicking if there are too many elements.

Note that in the future, handling of too many elements may change.

impl From<[f64; 8]> for f64x8

fn from(arr: [f64; 8]) -> Self

Converts an array to a SIMD vector.

impl From<__m512d> for f64x8

Available on x86-64 only.

fn from(value: __m512d) -> Self

Converts a native intrinsics SIMD type to a high-level SIMD type.

impl From<f64> for f64x8

fn from(elem: f64) -> Self

Converts a single value to a SIMD vector by setting all elements to that value.

impl From<f64x8> for [f64; 8]

fn from(simd: f64x8) -> Self

Converts a SIMD vector to an array.

impl From<f64x8> for __m512d

Available on x86-64 only.

fn from(value: f64x8) -> Self

Converts a high-level SIMD type to a native intrinsics SIMD type.

impl From<i32x8> for f64x8

fn from(v: i32x8) -> Self

Converts to this type from the input type.

impl LowerExp for f64x8

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

Formats the value using the given formatter.

impl LowerHex for f64x8

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

Formats the value using the given formatter.

impl Mul for f64x8

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

Computes multiplication for each element of self and the corresponding element of rhs.

This always returns the precise result.

type Output = f64x8

The resulting type after applying the * operator.

impl Mul<&f64> for f64x8

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

Computes multiplication for each element of self and the uniform scalar rhs.

This always returns the precise result.

type Output = f64x8

The resulting type after applying the * operator.

impl Mul<&f64> for &f64x8

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

Computes multiplication for each element of self and the uniform scalar rhs.

This always returns the precise result.

type Output = f64x8

The resulting type after applying the * operator.

impl Mul<&f64x8> for f64x8

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

Computes multiplication for each element of self and the corresponding element of rhs.

This always returns the precise result.

type Output = f64x8

The resulting type after applying the * operator.

impl Mul<&f64x8> for f64

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

Computes multiplication for the uniform scalar self and each element of rhs, returning a SIMD vector.

This always returns the precise result.

type Output = f64x8

The resulting type after applying the * operator.

impl Mul<&f64x8> for &f64x8

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

Computes multiplication for each element of self and the corresponding element of rhs.

This always returns the precise result.

type Output = f64x8

The resulting type after applying the * operator.

impl Mul<&f64x8> for &f64

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

Computes multiplication for the uniform scalar self and each element of rhs, returning a SIMD vector.

This always returns the precise result.

type Output = f64x8

The resulting type after applying the * operator.

impl Mul<f64> for f64x8

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

Computes multiplication for each element of self and the uniform scalar rhs.

This always returns the precise result.

type Output = f64x8

The resulting type after applying the * operator.

impl Mul<f64> for &f64x8

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

Computes multiplication for each element of self and the uniform scalar rhs.

This always returns the precise result.

type Output = f64x8

The resulting type after applying the * operator.

impl Mul<f64x8> for f64

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

Computes multiplication for the uniform scalar self and each element of rhs, returning a SIMD vector.

This always returns the precise result.

type Output = f64x8

The resulting type after applying the * operator.

impl Mul<f64x8> for &f64x8

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

Computes multiplication for each element of self and the corresponding element of rhs.

This always returns the precise result.

type Output = f64x8

The resulting type after applying the * operator.

impl Mul<f64x8> for &f64

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

Computes multiplication for the uniform scalar self and each element of rhs, returning a SIMD vector.

This always returns the precise result.

type Output = f64x8

The resulting type after applying the * operator.

impl MulAssign for f64x8

fn mul_assign(&mut self, rhs: Self)

Computes multiplication for each element of self and the corresponding element of rhs.

This always returns the precise result.

impl MulAssign<&f64> for f64x8

fn mul_assign(&mut self, rhs: &f64)

Computes multiplication for each element of self and the uniform scalar rhs.

This always returns the precise result.

impl MulAssign<&f64x8> for f64x8

fn mul_assign(&mut self, rhs: &Self)

Computes multiplication for each element of self and the corresponding element of rhs.

This always returns the precise result.

impl MulAssign<f64> for f64x8

fn mul_assign(&mut self, rhs: f64)

Computes multiplication for each element of self and the uniform scalar rhs.

This always returns the precise result.

impl Neg for f64x8

fn neg(self) -> Self::Output

Returns the negative of each element of self.

This always returns the precise result, simply flipping the sign-bit.

type Output = f64x8

The resulting type after applying the - operator.

impl Neg for &f64x8

fn neg(self) -> Self::Output

Returns the negative of each element of self.

This always returns the precise result, simply flipping the sign-bit.

type Output = f64x8

The resulting type after applying the - operator.

impl Not for f64x8

fn not(self) -> Self::Output

Computes bitwise NOT for each element of self.

This operator is not implemented for primitive scalar floats, but its behavior here is the same as for integers.

type Output = f64x8

The resulting type after applying the ! operator.

impl Not for &f64x8

fn not(self) -> Self::Output

Computes bitwise NOT for each element of self.

This operator is not implemented for primitive scalar floats, but its behavior here is the same as for integers.

type Output = f64x8

The resulting type after applying the ! operator.

impl Octal for f64x8

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

Formats the value using the given formatter.

impl PartialEq for f64x8

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

Equality operator ==.

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

Inequality operator !=.

impl Pod for f64x8

impl<Rhs> Product<Rhs> for f64x8

where f64x8: MulAssign<Rhs>,

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

Computes the product of multiple SIMD vectors for each lane.

The order of multiplication is not specified.

impl Rem for f64x8

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

Computes the remainder for each element of self and the corresponding element of rhs.

This always returns the precise result.

type Output = f64x8

The resulting type after applying the % operator.

impl Rem<&f64> for f64x8

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

Computes the remainder for each element of self and the uniform scalar rhs.

This always returns the precise result.

type Output = f64x8

The resulting type after applying the % operator.

impl Rem<&f64> for &f64x8

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

Computes the remainder for each element of self and the uniform scalar rhs.

This always returns the precise result.

type Output = f64x8

The resulting type after applying the % operator.

impl Rem<&f64x8> for f64x8

fn rem(self, rhs: &Self) -> Self::Output

Computes the remainder for each element of self and the corresponding element of rhs.

This always returns the precise result.

type Output = f64x8

The resulting type after applying the % operator.

impl Rem<&f64x8> for f64

fn rem(self, rhs: &f64x8) -> Self::Output

Computes the remainder for the uniform scalar self and each element of rhs, returning a SIMD vector.

This always returns the precise result.

type Output = f64x8

The resulting type after applying the % operator.

impl Rem<&f64x8> for &f64x8

fn rem(self, rhs: &f64x8) -> Self::Output

Computes the remainder for each element of self and the corresponding element of rhs.

This always returns the precise result.

type Output = f64x8

The resulting type after applying the % operator.

impl Rem<&f64x8> for &f64

fn rem(self, rhs: &f64x8) -> Self::Output

Computes the remainder for the uniform scalar self and each element of rhs, returning a SIMD vector.

This always returns the precise result.

type Output = f64x8

The resulting type after applying the % operator.

impl Rem<f64> for f64x8

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

Computes the remainder for each element of self and the uniform scalar rhs.

This always returns the precise result.

type Output = f64x8

The resulting type after applying the % operator.

impl Rem<f64> for &f64x8

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

Computes the remainder for each element of self and the uniform scalar rhs.

This always returns the precise result.

type Output = f64x8

The resulting type after applying the % operator.

impl Rem<f64x8> for f64

fn rem(self, rhs: f64x8) -> Self::Output

Computes the remainder for the uniform scalar self and each element of rhs, returning a SIMD vector.

This always returns the precise result.

type Output = f64x8

The resulting type after applying the % operator.

impl Rem<f64x8> for &f64x8

fn rem(self, rhs: f64x8) -> Self::Output

Computes the remainder for each element of self and the corresponding element of rhs.

This always returns the precise result.

type Output = f64x8

The resulting type after applying the % operator.

impl Rem<f64x8> for &f64

fn rem(self, rhs: f64x8) -> Self::Output

Computes the remainder for the uniform scalar self and each element of rhs, returning a SIMD vector.

This always returns the precise result.

type Output = f64x8

The resulting type after applying the % operator.

impl RemAssign for f64x8

fn rem_assign(&mut self, rhs: Self)

Computes the remainder for each element of self and the corresponding element of rhs.

This always returns the precise result.

impl RemAssign<&f64> for f64x8

fn rem_assign(&mut self, rhs: &f64)

Computes the remainder for each element of self and the uniform scalar rhs.

This always returns the precise result.

impl RemAssign<&f64x8> for f64x8

fn rem_assign(&mut self, rhs: &Self)

Computes the remainder for each element of self and the corresponding element of rhs.

This always returns the precise result.

impl RemAssign<f64> for f64x8

fn rem_assign(&mut self, rhs: f64)

Computes the remainder for each element of self and the uniform scalar rhs.

This always returns the precise result.

impl StructuralPartialEq for f64x8

impl Sub for f64x8

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

Computes subtraction for each element of self and the corresponding element of rhs.

This always returns the precise result.

type Output = f64x8

The resulting type after applying the - operator.

impl Sub<&f64> for f64x8

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

Computes subtraction for each element of self and the uniform scalar rhs.

This always returns the precise result.

type Output = f64x8

The resulting type after applying the - operator.

impl Sub<&f64> for &f64x8

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

Computes subtraction for each element of self and the uniform scalar rhs.

This always returns the precise result.

type Output = f64x8

The resulting type after applying the - operator.

impl Sub<&f64x8> for f64x8

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

Computes subtraction for each element of self and the corresponding element of rhs.

This always returns the precise result.

type Output = f64x8

The resulting type after applying the - operator.

impl Sub<&f64x8> for f64

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

Computes subtraction for the uniform scalar self and each element of rhs, returning a SIMD vector.

This always returns the precise result.

type Output = f64x8

The resulting type after applying the - operator.

impl Sub<&f64x8> for &f64x8

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

Computes subtraction for each element of self and the corresponding element of rhs.

This always returns the precise result.

type Output = f64x8

The resulting type after applying the - operator.

impl Sub<&f64x8> for &f64

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

Computes subtraction for the uniform scalar self and each element of rhs, returning a SIMD vector.

This always returns the precise result.

type Output = f64x8

The resulting type after applying the - operator.

impl Sub<f64> for f64x8

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

Computes subtraction for each element of self and the uniform scalar rhs.

This always returns the precise result.

type Output = f64x8

The resulting type after applying the - operator.

impl Sub<f64> for &f64x8

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

Computes subtraction for each element of self and the uniform scalar rhs.

This always returns the precise result.

type Output = f64x8

The resulting type after applying the - operator.

impl Sub<f64x8> for f64

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

Computes subtraction for the uniform scalar self and each element of rhs, returning a SIMD vector.

This always returns the precise result.

type Output = f64x8

The resulting type after applying the - operator.

impl Sub<f64x8> for &f64x8

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

Computes subtraction for each element of self and the corresponding element of rhs.

This always returns the precise result.

type Output = f64x8

The resulting type after applying the - operator.

impl Sub<f64x8> for &f64

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

Computes subtraction for the uniform scalar self and each element of rhs, returning a SIMD vector.

This always returns the precise result.

type Output = f64x8

The resulting type after applying the - operator.

impl SubAssign for f64x8

fn sub_assign(&mut self, rhs: Self)

Computes subtraction for each element of self and the corresponding element of rhs.

This always returns the precise result.

impl SubAssign<&f64> for f64x8

fn sub_assign(&mut self, rhs: &f64)

Computes subtraction for each element of self and the uniform scalar rhs.

This always returns the precise result.

impl SubAssign<&f64x8> for f64x8

fn sub_assign(&mut self, rhs: &Self)

Computes subtraction for each element of self and the corresponding element of rhs.

This always returns the precise result.

impl SubAssign<f64> for f64x8

fn sub_assign(&mut self, rhs: f64)

Computes subtraction for each element of self and the uniform scalar rhs.

This always returns the precise result.

impl<Rhs> Sum<Rhs> for f64x8

where f64x8: AddAssign<Rhs>,

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

Computes the sum of multiple SIMD vectors for each lane.

The order of addition is not specified.

impl UpperExp for f64x8

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

Formats the value using the given formatter.

impl UpperHex for f64x8

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

Formats the value using the given formatter.

impl Zeroable for f64x8

fn zeroed() -> Self

Calls zeroed.