Trait std::simd::prelude::SimdFloat

pub trait SimdFloat: Copy + Sealed {
    type Mask;
    type Scalar;
    type Bits;
    type Cast<T: SimdElement>;

    // Required methods
    fn cast<T>(self) -> Self::Cast<T>
       where T: SimdCast;
    unsafe fn to_int_unchecked<I>(self) -> Self::Cast<I>
       where I: SimdCast,
             Self::Scalar: FloatToInt<I>;
    fn to_bits(self) -> Self::Bits;
    fn from_bits(bits: Self::Bits) -> Self;
    fn abs(self) -> Self;
    fn recip(self) -> Self;
    fn to_degrees(self) -> Self;
    fn to_radians(self) -> Self;
    fn is_sign_positive(self) -> Self::Mask;
    fn is_sign_negative(self) -> Self::Mask;
    fn is_nan(self) -> Self::Mask;
    fn is_infinite(self) -> Self::Mask;
    fn is_finite(self) -> Self::Mask;
    fn is_subnormal(self) -> Self::Mask;
    fn is_normal(self) -> Self::Mask;
    fn signum(self) -> Self;
    fn copysign(self, sign: Self) -> Self;
    fn simd_min(self, other: Self) -> Self;
    fn simd_max(self, other: Self) -> Self;
    fn simd_clamp(self, min: Self, max: Self) -> Self;
    fn reduce_sum(self) -> Self::Scalar;
    fn reduce_product(self) -> Self::Scalar;
    fn reduce_max(self) -> Self::Scalar;
    fn reduce_min(self) -> Self::Scalar;
}

🔬This is a nightly-only experimental API. (portable_simd #86656)

Operations on SIMD vectors of floats.

Required Associated Types

type Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

Mask type used for manipulating this SIMD vector type.

type Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)

Scalar type contained by this SIMD vector type.

type Bits

🔬This is a nightly-only experimental API. (portable_simd #86656)

Bit representation of this SIMD vector type.

type Cast<T: SimdElement>

🔬This is a nightly-only experimental API. (portable_simd #86656)

A SIMD vector with a different element type.

Required Methods

fn cast<T>(self) -> Self::Cast<T>where T: SimdCast,

🔬This is a nightly-only experimental API. (portable_simd #86656)

Performs elementwise conversion of this vector’s elements to another SIMD-valid type.

This follows the semantics of Rust’s as conversion for floats (truncating or saturating at the limits) for each element.

Example

let floats: Simd<f32, 4> = Simd::from_array([1.9, -4.5, f32::INFINITY, f32::NAN]);
let ints = floats.cast::<i32>();
assert_eq!(ints, Simd::from_array([1, -4, i32::MAX, 0]));

// Formally equivalent, but `Simd::cast` can optimize better.
assert_eq!(ints, Simd::from_array(floats.to_array().map(|x| x as i32)));

// The float conversion does not round-trip.
let floats_again = ints.cast();
assert_ne!(floats, floats_again);
assert_eq!(floats_again, Simd::from_array([1.0, -4.0, 2147483647.0, 0.0]));

unsafe fn to_int_unchecked<I>(self) -> Self::Cast<I>where I: SimdCast, Self::Scalar: FloatToInt<I>,

🔬This is a nightly-only experimental API. (portable_simd #86656)

Rounds toward zero and converts to the same-width integer type, assuming that the value is finite and fits in that type.

Safety

The value must:

• Not be NaN
• Not be infinite
• Be representable in the return type, after truncating off its fractional part

If these requirements are infeasible or costly, consider using the safe function cast, which saturates on conversion.

fn to_bits(self) -> Self::Bits

🔬This is a nightly-only experimental API. (portable_simd #86656)

Raw transmutation to an unsigned integer vector type with the same size and number of lanes.

fn from_bits(bits: Self::Bits) -> Self

🔬This is a nightly-only experimental API. (portable_simd #86656)

Raw transmutation from an unsigned integer vector type with the same size and number of lanes.

fn abs(self) -> Self

🔬This is a nightly-only experimental API. (portable_simd #86656)

Produces a vector where every lane has the absolute value of the equivalently-indexed lane in self.

fn recip(self) -> Self

🔬This is a nightly-only experimental API. (portable_simd #86656)

Takes the reciprocal (inverse) of each lane, 1/x.

fn to_degrees(self) -> Self

🔬This is a nightly-only experimental API. (portable_simd #86656)

Converts each lane from radians to degrees.

fn to_radians(self) -> Self

🔬This is a nightly-only experimental API. (portable_simd #86656)

Converts each lane from degrees to radians.

fn is_sign_positive(self) -> Self::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

Returns true for each lane if it has a positive sign, including +0.0, NaNs with positive sign bit and positive infinity.

fn is_sign_negative(self) -> Self::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

Returns true for each lane if it has a negative sign, including -0.0, NaNs with negative sign bit and negative infinity.

fn is_nan(self) -> Self::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

Returns true for each lane if its value is NaN.

fn is_infinite(self) -> Self::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

Returns true for each lane if its value is positive infinity or negative infinity.

fn is_finite(self) -> Self::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

Returns true for each lane if its value is neither infinite nor NaN.

fn is_subnormal(self) -> Self::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

Returns true for each lane if its value is subnormal.

fn is_normal(self) -> Self::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

Returns true for each lane if its value is neither zero, infinite, subnormal, nor NaN.

fn signum(self) -> Self

🔬This is a nightly-only experimental API. (portable_simd #86656)

Replaces each lane with a number that represents its sign.

• 1.0 if the number is positive, +0.0, or INFINITY
• -1.0 if the number is negative, -0.0, or NEG_INFINITY
• NAN if the number is NAN

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

🔬This is a nightly-only experimental API. (portable_simd #86656)

Returns each lane with the magnitude of self and the sign of sign.

For any lane containing a NAN, a NAN with the sign of sign is returned.

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

🔬This is a nightly-only experimental API. (portable_simd #86656)

Returns the minimum of each lane.

If one of the values is NAN, then the other value is returned.

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

🔬This is a nightly-only experimental API. (portable_simd #86656)

Returns the maximum of each lane.

If one of the values is NAN, then the other value is returned.

fn simd_clamp(self, min: Self, max: Self) -> Self

🔬This is a nightly-only experimental API. (portable_simd #86656)

Restrict each lane to a certain interval unless it is NaN.

For each lane in self, returns the corresponding lane in max if the lane is greater than max, and the corresponding lane in min if the lane is less than min. Otherwise returns the lane in self.

fn reduce_sum(self) -> Self::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)

Returns the sum of the lanes of the vector.

Examples

let v = f32x2::from_array([1., 2.]);
assert_eq!(v.reduce_sum(), 3.);

fn reduce_product(self) -> Self::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)

Reducing multiply. Returns the product of the lanes of the vector.

Examples

let v = f32x2::from_array([3., 4.]);
assert_eq!(v.reduce_product(), 12.);

fn reduce_max(self) -> Self::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)

Returns the maximum lane in the vector.

Returns values based on equality, so a vector containing both 0. and -0. may return either.

This function will not return NaN unless all lanes are NaN.

Examples

let v = f32x2::from_array([1., 2.]);
assert_eq!(v.reduce_max(), 2.);

// NaN values are skipped...
let v = f32x2::from_array([1., f32::NAN]);
assert_eq!(v.reduce_max(), 1.);

// ...unless all values are NaN
let v = f32x2::from_array([f32::NAN, f32::NAN]);
assert!(v.reduce_max().is_nan());

fn reduce_min(self) -> Self::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)

Returns the minimum lane in the vector.

Returns values based on equality, so a vector containing both 0. and -0. may return either.

This function will not return NaN unless all lanes are NaN.

Examples

let v = f32x2::from_array([3., 7.]);
assert_eq!(v.reduce_min(), 3.);

// NaN values are skipped...
let v = f32x2::from_array([1., f32::NAN]);
assert_eq!(v.reduce_min(), 1.);

// ...unless all values are NaN
let v = f32x2::from_array([f32::NAN, f32::NAN]);
assert!(v.reduce_min().is_nan());

Object Safety

This trait is not object safe.

Implementors

impl<const LANES: usize> SimdFloat for Simd<f32, LANES>where LaneCount<LANES>: SupportedLaneCount,

type Mask = Mask<<i32 as SimdElement>::Mask, LANES>

type Scalar = f32

type Bits = Simd<u32, LANES>

type Cast<T: SimdElement> = Simd<T, LANES>

impl<const LANES: usize> SimdFloat for Simd<f64, LANES>where LaneCount<LANES>: SupportedLaneCount,

type Mask = Mask<<i64 as SimdElement>::Mask, LANES>

type Scalar = f64

type Bits = Simd<u64, LANES>

type Cast<T: SimdElement> = Simd<T, LANES>