# Trait std::simd::prelude::SimdFloat

source ·

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

    Show 24 methods    // 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)
Expand description

Operations on SIMD vectors of floats.

## Required Associated Types§

source

#### type Mask

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

Mask type used for manipulating this SIMD vector type.

source

#### type Scalar

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

Scalar type contained by this SIMD vector type.

source

#### type Bits

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

Bit representation of this SIMD vector type.

source

#### type Cast<T: SimdElement>

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

A SIMD vector with a different element type.

## Required Methods§

source

#### 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]));

Run
source

#### 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.

source

#### 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.

source

#### 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.

source

#### 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`.

source

#### fn recip(self) -> Self

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

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

source

#### fn to_degrees(self) -> Self

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

Converts each lane from radians to degrees.

source

#### fn to_radians(self) -> Self

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

Converts each lane from degrees to radians.

source

#### 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`, `NaN`s with positive sign bit and positive infinity.

source

#### 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`, `NaN`s with negative sign bit and negative infinity.

source

#### 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`.

source

#### 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.

source

#### 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`.

source

#### 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.

source

#### 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`.

source

#### 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`

source

#### 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.

source

#### 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.

source

#### 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.

source

#### 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`.

source

#### 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.);

Run
source

#### 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.);

Run
source

#### 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());

Run
source

#### 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());

Run

## Object Safety§

This trait is not object safe.

## Implementors§

source§

### 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>

source§

### 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>