Trait PrimitiveFloat

Source

pub trait PrimitiveFloat:
    PrimitiveNumber
    + From<i8>
    + From<u8>
    + Neg<Output = Self> {
    type Bits: PrimitiveUnsigned;
Show 33 associated constants and 58 methods
    const DIGITS: u32;
    const EPSILON: Self;
    const INFINITY: Self;
    const MANTISSA_DIGITS: u32;
    const MAX: Self;
    const MAX_10_EXP: i32;
    const MAX_EXP: i32;
    const MIN: Self;
    const MIN_10_EXP: i32;
    const MIN_EXP: i32;
    const MIN_POSITIVE: Self;
    const NAN: Self;
    const NEG_INFINITY: Self;
    const RADIX: u32;
    const E: Self;
    const FRAC_1_PI: Self;
    const FRAC_1_SQRT_2: Self;
    const FRAC_2_PI: Self;
    const FRAC_2_SQRT_PI: Self;
    const FRAC_PI_2: Self;
    const FRAC_PI_3: Self;
    const FRAC_PI_4: Self;
    const FRAC_PI_6: Self;
    const FRAC_PI_8: Self;
    const LN_2: Self;
    const LN_10: Self;
    const LOG2_10: Self;
    const LOG2_E: Self;
    const LOG10_2: Self;
    const LOG10_E: Self;
    const PI: Self;
    const SQRT_2: Self;
    const TAU: Self;

    // Required methods
    fn abs(self) -> Self;
    fn clamp(self, min: Self, max: Self) -> Self;
    fn classify(self) -> FpCategory;
    fn copysign(self, sign: Self) -> Self;
    fn from_bits(value: Self::Bits) -> Self;
    fn is_finite(self) -> bool;
    fn is_infinite(self) -> bool;
    fn is_nan(self) -> bool;
    fn is_normal(self) -> bool;
    fn is_sign_negative(self) -> bool;
    fn is_sign_positive(self) -> bool;
    fn is_subnormal(self) -> bool;
    fn max(self, other: Self) -> Self;
    fn midpoint(self, other: Self) -> Self;
    fn min(self, other: Self) -> Self;
    fn recip(self) -> Self;
    fn signum(self) -> Self;
    fn to_bits(self) -> Self::Bits;
    fn to_degrees(self) -> Self;
    fn to_radians(self) -> Self;
    fn total_cmp(&self, other: &Self) -> Ordering;
    unsafe fn to_int_unchecked<Int>(self) -> Int
       where Self: PrimitiveFloatToInt<Int>;
    fn acos(self) -> Self;
    fn acosh(self) -> Self;
    fn asin(self) -> Self;
    fn asinh(self) -> Self;
    fn atan(self) -> Self;
    fn atan2(self, other: Self) -> Self;
    fn atanh(self) -> Self;
    fn cbrt(self) -> Self;
    fn ceil(self) -> Self;
    fn cos(self) -> Self;
    fn cosh(self) -> Self;
    fn div_euclid(self, rhs: Self) -> Self;
    fn exp(self) -> Self;
    fn exp2(self) -> Self;
    fn exp_m1(self) -> Self;
    fn floor(self) -> Self;
    fn fract(self) -> Self;
    fn hypot(self, other: Self) -> Self;
    fn ln(self) -> Self;
    fn ln_1p(self) -> Self;
    fn log(self, base: Self) -> Self;
    fn log2(self) -> Self;
    fn log10(self) -> Self;
    fn mul_add(self, a: Self, b: Self) -> Self;
    fn powf(self, n: Self) -> Self;
    fn powi(self, n: i32) -> Self;
    fn rem_euclid(self, rhs: Self) -> Self;
    fn round(self) -> Self;
    fn round_ties_even(self) -> Self;
    fn sin(self) -> Self;
    fn sin_cos(self) -> (Self, Self);
    fn sinh(self) -> Self;
    fn sqrt(self) -> Self;
    fn tan(self) -> Self;
    fn tanh(self) -> Self;
    fn trunc(self) -> Self;
}

Expand description

Trait for all primitive floating-point types, including the supertrait PrimitiveNumber.

This encapsulates trait implementations, constants, and inherent methods that are common among the primitive floating-point types, f32 and f64. Unstable types f16 and f128 will be added once they are stabilized.

See the corresponding items on the individual types for more documentation and examples.

This trait is sealed with a private trait to prevent downstream implementations, so we may continue to expand along with the standard library without worrying about breaking changes for implementors.

§Examples

This example requires the std feature for powi and sqrt:

use num_primitive::PrimitiveFloat;

// Euclidean distance, √(∑(aᵢ - bᵢ)²)
fn distance<T: PrimitiveFloat>(a: &[T], b: &[T]) -> T {
    assert_eq!(a.len(), b.len());
    core::iter::zip(a, b).map(|(a, b)| (*a - b).powi(2)).sum::<T>().sqrt()
}

assert_eq!(distance::<f32>(&[0., 0.], &[3., 4.]), 5.);
assert_eq!(distance::<f64>(&[0., 1., 2.], &[1., 3., 0.]), 3.);

This example works without any features:

use num_primitive::PrimitiveFloat;

// Squared Euclidean distance, ∑(aᵢ - bᵢ)²
fn distance_squared<T: PrimitiveFloat>(a: &[T], b: &[T]) -> T {
    assert_eq!(a.len(), b.len());
    core::iter::zip(a, b).map(|(a, b)| (*a - b)).map(|x| x * x).sum::<T>()
}

assert_eq!(distance_squared::<f32>(&[0., 0.], &[3., 4.]), 25.);
assert_eq!(distance_squared::<f64>(&[0., 1., 2.], &[1., 3., 0.]), 9.);

Required Associated Constants§

Source

const DIGITS: u32

Approximate number of significant digits in base 10.

Source

const EPSILON: Self

Machine epsilon value.

Source

const INFINITY: Self

Infinity (∞).

Source

const MANTISSA_DIGITS: u32

Number of significant digits in base 2.

Source

const MAX: Self

Largest finite value.

Source

const MAX_10_EXP: i32

Maximum x for which 10^x is normal.

Source

const MAX_EXP: i32

Maximum possible power of 2 exponent.

Source

const MIN: Self

Smallest finite value.

Source

const MIN_10_EXP: i32

Minimum x for which 10^x is normal.

Source

const MIN_EXP: i32

One greater than the minimum possible normal power of 2 exponent.

Source

const MIN_POSITIVE: Self

Smallest positive normal value.

Source

const NAN: Self

Not a Number (NaN).

Source

const NEG_INFINITY: Self

Negative infinity (−∞).

Source

const RADIX: u32

The radix or base of the internal representation.

Source

const E: Self

Euler’s number (e)

Source

const FRAC_1_PI: Self

1/π

Source

const FRAC_1_SQRT_2: Self

1/sqrt(2)

Source

const FRAC_2_PI: Self

2/π

Source

const FRAC_2_SQRT_PI: Self

2/sqrt(π)

Source

const FRAC_PI_2: Self

π/2

Source

const FRAC_PI_3: Self

π/3

Source

const FRAC_PI_4: Self

π/4

Source

const FRAC_PI_6: Self

π/6

Source

const FRAC_PI_8: Self

π/8

Source

const LN_2: Self

ln(2)

Source

const LN_10: Self

ln(10)

Source

const LOG2_10: Self

log₂(10)

Source

const LOG2_E: Self

log₂(e)

Source

const LOG10_2: Self

log₁₀(2)

Source

const LOG10_E: Self

log₁₀(e)

Source

const PI: Self

Archimedes’ constant (π)

Source

const SQRT_2: Self

sqrt(2)

Source

const TAU: Self

The full circle constant (τ)

Required Associated Types§

Source

type Bits: PrimitiveUnsigned

An unsigned integer type used by methods from_bits and to_bits.

Required Methods§

Source

fn abs(self) -> Self

Computes the absolute value of self.

Source

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

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

Source

fn classify(self) -> FpCategory

Returns the floating point category of the number. If only one property is going to be tested, it is generally faster to use the specific predicate instead.

Source

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

Returns a number composed of the magnitude of self and the sign of sign.

Source

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

Raw transmutation from Self::Bits.

Source

fn is_finite(self) -> bool

Returns true if this number is neither infinite nor NaN.

Source

fn is_infinite(self) -> bool

Returns true if this value is positive infinity or negative infinity.

Source

fn is_nan(self) -> bool

Returns true if this value is NaN.

Source

fn is_normal(self) -> bool

Returns true if the number is neither zero, infinite, subnormal, or NaN.

Source

fn is_sign_negative(self) -> bool

Returns true if self has a negative sign, including -0.0, NaNs with negative sign bit and negative infinity.

Source

fn is_sign_positive(self) -> bool

Returns true if self has a positive sign, including +0.0, NaNs with positive sign bit and positive infinity.

Source

fn is_subnormal(self) -> bool

Returns true if the number is subnormal.

Source

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

Returns the maximum of the two numbers, ignoring NaN.

Source

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

Calculates the middle point of self and other.

Source

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

Returns the minimum of the two numbers, ignoring NaN.

Source

fn recip(self) -> Self

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

Source

fn signum(self) -> Self

Returns a number that represents the sign of self.

Source

fn to_bits(self) -> Self::Bits

Raw transmutation to Self::Bits.

Source

fn to_degrees(self) -> Self

Converts radians to degrees.

Source

fn to_radians(self) -> Self

Converts degrees to radians.

Source

fn total_cmp(&self, other: &Self) -> Ordering

Returns the ordering between self and other.

Source

unsafe fn to_int_unchecked<Int>(self) -> Int
where Self: PrimitiveFloatToInt<Int>,

Rounds toward zero and converts to any primitive 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 Int, after truncating off its fractional part

Source