FloatCore in num_traits::float - Rust
Description: Generic trait for floating point numbers that works with `no_std`.
Keywords: rust, rustlang, rust-lang, FloatCore

# Trait num_traits::float::FloatCore

source ·

    pub trait FloatCore: Num + NumCast + Neg<Output = Self> + PartialOrd + Copy {
    Show 29 methods    fn infinity() -> Self;
        fn neg_infinity() -> Self;
        fn nan() -> Self;
        fn neg_zero() -> Self;
        fn min_value() -> Self;
        fn min_positive_value() -> Self;
        fn epsilon() -> Self;
        fn max_value() -> Self;
        fn classify(self) -> FpCategory;
        fn to_degrees(self) -> Self;
        fn to_radians(self) -> Self;
        fn integer_decode(self) -> (u64, i16, i8);

        fn is_nan(self) -> bool { ... }
        fn is_infinite(self) -> bool { ... }
        fn is_finite(self) -> bool { ... }
        fn is_normal(self) -> bool { ... }
        fn floor(self) -> Self { ... }
        fn ceil(self) -> Self { ... }
        fn round(self) -> Self { ... }
        fn trunc(self) -> Self { ... }
        fn fract(self) -> Self { ... }
        fn abs(self) -> Self { ... }
        fn signum(self) -> Self { ... }
        fn is_sign_positive(self) -> bool { ... }
        fn is_sign_negative(self) -> bool { ... }
        fn min(self, other: Self) -> Self { ... }
        fn max(self, other: Self) -> Self { ... }
        fn recip(self) -> Self { ... }
        fn powi(self, exp: i32) -> Self { ... }
    }

Expand description

Generic trait for floating point numbers that works with `no_std`.

This trait implements a subset of the `Float` trait.

## Required Methods§

source

#### fn infinity() -> Self

Returns positive infinity.

##### Examples

    use num_traits::float::FloatCore;
    use std::{f32, f64};

    fn check<T: FloatCore>(x: T) {
        assert!(T::infinity() == x);
    }

    check(f32::INFINITY);
    check(f64::INFINITY);

source

#### fn neg_infinity() -> Self

Returns negative infinity.

##### Examples

    use num_traits::float::FloatCore;
    use std::{f32, f64};

    fn check<T: FloatCore>(x: T) {
        assert!(T::neg_infinity() == x);
    }

    check(f32::NEG_INFINITY);
    check(f64::NEG_INFINITY);

source

#### fn nan() -> Self

Returns NaN.

##### Examples

    use num_traits::float::FloatCore;

    fn check<T: FloatCore>() {
        let n = T::nan();
        assert!(n != n);
    }

    check::<f32>();
    check::<f64>();

source

#### fn neg_zero() -> Self

Returns `-0.0`.

##### Examples

    use num_traits::float::FloatCore;
    use std::{f32, f64};

    fn check<T: FloatCore>(n: T) {
        let z = T::neg_zero();
        assert!(z.is_zero());
        assert!(T::one() / z == n);
    }

    check(f32::NEG_INFINITY);
    check(f64::NEG_INFINITY);

source

#### fn min_value() -> Self

Returns the smallest finite value that this type can represent.

##### Examples

    use num_traits::float::FloatCore;
    use std::{f32, f64};

    fn check<T: FloatCore>(x: T) {
        assert!(T::min_value() == x);
    }

    check(f32::MIN);
    check(f64::MIN);

source

#### fn min_positive_value() -> Self

Returns the smallest positive, normalized value that this type can represent.

##### Examples

    use num_traits::float::FloatCore;
    use std::{f32, f64};

    fn check<T: FloatCore>(x: T) {
        assert!(T::min_positive_value() == x);
    }

    check(f32::MIN_POSITIVE);
    check(f64::MIN_POSITIVE);

source

#### fn epsilon() -> Self

Returns epsilon, a small positive value.

##### Examples

    use num_traits::float::FloatCore;
    use std::{f32, f64};

    fn check<T: FloatCore>(x: T) {
        assert!(T::epsilon() == x);
    }

    check(f32::EPSILON);
    check(f64::EPSILON);

source

#### fn max_value() -> Self

Returns the largest finite value that this type can represent.

##### Examples

    use num_traits::float::FloatCore;
    use std::{f32, f64};

    fn check<T: FloatCore>(x: T) {
        assert!(T::max_value() == x);
    }

    check(f32::MAX);
    check(f64::MAX);

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.

##### Examples

    use num_traits::float::FloatCore;
    use std::{f32, f64};
    use std::num::FpCategory;

    fn check<T: FloatCore>(x: T, c: FpCategory) {
        assert!(x.classify() == c);
    }

    check(f32::INFINITY, FpCategory::Infinite);
    check(f32::MAX, FpCategory::Normal);
    check(f64::NAN, FpCategory::Nan);
    check(f64::MIN_POSITIVE, FpCategory::Normal);
    check(f64::MIN_POSITIVE / 2.0, FpCategory::Subnormal);
    check(0.0f64, FpCategory::Zero);

source

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

Converts to degrees, assuming the number is in radians.

##### Examples

    use num_traits::float::FloatCore;
    use std::{f32, f64};

    fn check<T: FloatCore>(rad: T, deg: T) {
        assert!(rad.to_degrees() == deg);
    }

    check(0.0f32, 0.0);
    check(f32::consts::PI, 180.0);
    check(f64::consts::FRAC_PI_4, 45.0);
    check(f64::INFINITY, f64::INFINITY);

source

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

Converts to radians, assuming the number is in degrees.

##### Examples

    use num_traits::float::FloatCore;
    use std::{f32, f64};

    fn check<T: FloatCore>(deg: T, rad: T) {
        assert!(deg.to_radians() == rad);
    }

    check(0.0f32, 0.0);
    check(180.0, f32::consts::PI);
    check(45.0, f64::consts::FRAC_PI_4);
    check(f64::INFINITY, f64::INFINITY);

source

#### fn integer_decode(self) -> (u64, i16, i8)

Returns the mantissa, base 2 exponent, and sign as integers, respectively. The original number can be recovered by `sign * mantissa * 2 ^ exponent`.

##### Examples

    use num_traits::float::FloatCore;
    use std::{f32, f64};

    fn check<T: FloatCore>(x: T, m: u64, e: i16, s:i8) {
        let (mantissa, exponent, sign) = x.integer_decode();
        assert_eq!(mantissa, m);
        assert_eq!(exponent, e);
        assert_eq!(sign, s);
    }

    check(2.0f32, 1 << 23, -22, 1);
    check(-2.0f32, 1 << 23, -22, -1);
    check(f32::INFINITY, 1 << 23, 105, 1);
    check(f64::NEG_INFINITY, 1 << 52, 972, -1);

## Provided Methods§

source

#### fn is_nan(self) -> bool

Returns `true` if the number is NaN.

##### Examples

    use num_traits::float::FloatCore;
    use std::{f32, f64};

    fn check<T: FloatCore>(x: T, p: bool) {
        assert!(x.is_nan() == p);
    }

    check(f32::NAN, true);
    check(f32::INFINITY, false);
    check(f64::NAN, true);
    check(0.0f64, false);

source

#### fn is_infinite(self) -> bool

Returns `true` if the number is infinite.

##### Examples

    use num_traits::float::FloatCore;
    use std::{f32, f64};

    fn check<T: FloatCore>(x: T, p: bool) {
        assert!(x.is_infinite() == p);
    }

    check(f32::INFINITY, true);
    check(f32::NEG_INFINITY, true);
    check(f32::NAN, false);
    check(f64::INFINITY, true);
    check(f64::NEG_INFINITY, true);
    check(0.0f64, false);

source

#### fn is_finite(self) -> bool

Returns `true` if the number is neither infinite or NaN.

##### Examples

    use num_traits::float::FloatCore;
    use std::{f32, f64};

    fn check<T: FloatCore>(x: T, p: bool) {
        assert!(x.is_finite() == p);
    }

    check(f32::INFINITY, false);
    check(f32::MAX, true);
    check(f64::NEG_INFINITY, false);
    check(f64::MIN_POSITIVE, true);
    check(f64::NAN, false);

source

#### fn is_normal(self) -> bool

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

##### Examples

    use num_traits::float::FloatCore;
    use std::{f32, f64};

    fn check<T: FloatCore>(x: T, p: bool) {
        assert!(x.is_normal() == p);
    }

    check(f32::INFINITY, false);
    check(f32::MAX, true);
    check(f64::NEG_INFINITY, false);
    check(f64::MIN_POSITIVE, true);
    check(0.0f64, false);

source

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

Returns the largest integer less than or equal to a number.

##### Examples

    use num_traits::float::FloatCore;
    use std::{f32, f64};

    fn check<T: FloatCore>(x: T, y: T) {
        assert!(x.floor() == y);
    }

    check(f32::INFINITY, f32::INFINITY);
    check(0.9f32, 0.0);
    check(1.0f32, 1.0);
    check(1.1f32, 1.0);
    check(-0.0f64, 0.0);
    check(-0.9f64, -1.0);
    check(-1.0f64, -1.0);
    check(-1.1f64, -2.0);
    check(f64::MIN, f64::MIN);

source

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

Returns the smallest integer greater than or equal to a number.

##### Examples

    use num_traits::float::FloatCore;
    use std::{f32, f64};

    fn check<T: FloatCore>(x: T, y: T) {
        assert!(x.ceil() == y);
    }

    check(f32::INFINITY, f32::INFINITY);
    check(0.9f32, 1.0);
    check(1.0f32, 1.0);
    check(1.1f32, 2.0);
    check(-0.0f64, 0.0);
    check(-0.9f64, -0.0);
    check(-1.0f64, -1.0);
    check(-1.1f64, -1.0);
    check(f64::MIN, f64::MIN);

source

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

Returns the nearest integer to a number. Round half-way cases away from `0.0`.

##### Examples

    use num_traits::float::FloatCore;
    use std::{f32, f64};

    fn check<T: FloatCore>(x: T, y: T) {
        assert!(x.round() == y);
    }

    check(f32::INFINITY, f32::INFINITY);
    check(0.4f32, 0.0);
    check(0.5f32, 1.0);
    check(0.6f32, 1.0);
    check(-0.4f64, 0.0);
    check(-0.5f64, -1.0);
    check(-0.6f64, -1.0);
    check(f64::MIN, f64::MIN);

source

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

Return the integer part of a number.

##### Examples

    use num_traits::float::FloatCore;
    use std::{f32, f64};

    fn check<T: FloatCore>(x: T, y: T) {
        assert!(x.trunc() == y);
    }

    check(f32::INFINITY, f32::INFINITY);
    check(0.9f32, 0.0);
    check(1.0f32, 1.0);
    check(1.1f32, 1.0);
    check(-0.0f64, 0.0);
    check(-0.9f64, -0.0);
    check(-1.0f64, -1.0);
    check(-1.1f64, -1.0);
    check(f64::MIN, f64::MIN);

source

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

Returns the fractional part of a number.

##### Examples

    use num_traits::float::FloatCore;
    use std::{f32, f64};

    fn check<T: FloatCore>(x: T, y: T) {
        assert!(x.fract() == y);
    }

    check(f32::MAX, 0.0);
    check(0.75f32, 0.75);
    check(1.0f32, 0.0);
    check(1.25f32, 0.25);
    check(-0.0f64, 0.0);
    check(-0.75f64, -0.75);
    check(-1.0f64, 0.0);
    check(-1.25f64, -0.25);
    check(f64::MIN, 0.0);

source

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

Computes the absolute value of `self`. Returns `FloatCore::nan()` if the number is `FloatCore::nan()`.

##### Examples

    use num_traits::float::FloatCore;
    use std::{f32, f64};

    fn check<T: FloatCore>(x: T, y: T) {
        assert!(x.abs() == y);
    }

    check(f32::INFINITY, f32::INFINITY);
    check(1.0f32, 1.0);
    check(0.0f64, 0.0);
    check(-0.0f64, 0.0);
    check(-1.0f64, 1.0);
    check(f64::MIN, f64::MAX);

source

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

Returns a number that represents the sign of `self`.

- `1.0` if the number is positive, `+0.0` or `FloatCore::infinity()`
- `-1.0` if the number is negative, `-0.0` or `FloatCore::neg_infinity()`
- `FloatCore::nan()` if the number is `FloatCore::nan()`

##### Examples

    use num_traits::float::FloatCore;
    use std::{f32, f64};

    fn check<T: FloatCore>(x: T, y: T) {
        assert!(x.signum() == y);
    }

    check(f32::INFINITY, 1.0);
    check(3.0f32, 1.0);
    check(0.0f32, 1.0);
    check(-0.0f64, -1.0);
    check(-3.0f64, -1.0);
    check(f64::MIN, -1.0);

source

#### fn is_sign_positive(self) -> bool

Returns `true` if `self` is positive, including `+0.0` and `FloatCore::infinity()`, and since Rust 1.20 also `FloatCore::nan()`.

##### Examples

    use num_traits::float::FloatCore;
    use std::{f32, f64};

    fn check<T: FloatCore>(x: T, p: bool) {
        assert!(x.is_sign_positive() == p);
    }

    check(f32::INFINITY, true);
    check(f32::MAX, true);
    check(0.0f32, true);
    check(-0.0f64, false);
    check(f64::NEG_INFINITY, false);
    check(f64::MIN_POSITIVE, true);
    check(-f64::NAN, false);

source

#### fn is_sign_negative(self) -> bool

Returns `true` if `self` is negative, including `-0.0` and `FloatCore::neg_infinity()`, and since Rust 1.20 also `-FloatCore::nan()`.

##### Examples

    use num_traits::float::FloatCore;
    use std::{f32, f64};

    fn check<T: FloatCore>(x: T, p: bool) {
        assert!(x.is_sign_negative() == p);
    }

    check(f32::INFINITY, false);
    check(f32::MAX, false);
    check(0.0f32, false);
    check(-0.0f64, true);
    check(f64::NEG_INFINITY, true);
    check(f64::MIN_POSITIVE, false);
    check(f64::NAN, false);

source

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

Returns the minimum of the two numbers.

If one of the arguments is NaN, then the other argument is returned.

##### Examples

    use num_traits::float::FloatCore;
    use std::{f32, f64};

    fn check<T: FloatCore>(x: T, y: T, min: T) {
        assert!(x.min(y) == min);
    }

    check(1.0f32, 2.0, 1.0);
    check(f32::NAN, 2.0, 2.0);
    check(1.0f64, -2.0, -2.0);
    check(1.0f64, f64::NAN, 1.0);

source

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

Returns the maximum of the two numbers.

If one of the arguments is NaN, then the other argument is returned.

##### Examples

    use num_traits::float::FloatCore;
    use std::{f32, f64};

    fn check<T: FloatCore>(x: T, y: T, max: T) {
        assert!(x.max(y) == max);
    }

    check(1.0f32, 2.0, 2.0);
    check(1.0f32, f32::NAN, 1.0);
    check(-1.0f64, 2.0, 2.0);
    check(-1.0f64, f64::NAN, -1.0);

source

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

Returns the reciprocal (multiplicative inverse) of the number.

##### Examples

    use num_traits::float::FloatCore;
    use std::{f32, f64};

    fn check<T: FloatCore>(x: T, y: T) {
        assert!(x.recip() == y);
        assert!(y.recip() == x);
    }

    check(f32::INFINITY, 0.0);
    check(2.0f32, 0.5);
    check(-0.25f64, -4.0);
    check(-0.0f64, f64::NEG_INFINITY);

source

#### fn powi(self, exp: i32) -> Self

Raise a number to an integer power.

Using this function is generally faster than using `powf`

##### Examples

    use num_traits::float::FloatCore;

    fn check<T: FloatCore>(x: T, exp: i32, powi: T) {
        assert!(x.powi(exp) == powi);
    }

    check(9.0f32, 2, 81.0);
    check(1.0f32, -2, 1.0);
    check(10.0f64, 20, 1e20);
    check(4.0f64, -2, 0.0625);
    check(-1.0f64, std::i32::MIN, 1.0);

## Implementations on Foreign Types§

source§

### impl FloatCore for f32

source§

#### fn infinity() -> Self

source§

#### fn neg_infinity() -> Self

source§

#### fn nan() -> Self

source§

#### fn neg_zero() -> Self

source§

#### fn min_value() -> Self

source§

#### fn min_positive_value() -> Self

source§

#### fn epsilon() -> Self

source§

#### fn max_value() -> Self

source§

#### fn integer_decode(self) -> (u64, i16, i8)

source§

#### fn classify(self) -> FpCategory

source§

#### fn is_sign_negative(self) -> bool

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

### impl FloatCore for f64

source§

#### fn infinity() -> Self

source§

#### fn neg_infinity() -> Self

source§

#### fn nan() -> Self

source§

#### fn neg_zero() -> Self

source§

#### fn min_value() -> Self

source§

#### fn min_positive_value() -> Self

source§

#### fn epsilon() -> Self

source§

#### fn max_value() -> Self

source§

#### fn integer_decode(self) -> (u64, i16, i8)

source§

#### fn classify(self) -> FpCategory

source§

#### fn is_sign_negative(self) -> bool

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

## Implementors§