Trait num_traits::float::FloatCore

pub trait FloatCore: Num + NumCast + Neg<Output = Self> + PartialOrd + Copy {
    // Required 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);

    // Provided methods
    fn is_nan(self) -> bool { ... }
    fn is_infinite(self) -> bool { ... }
    fn is_finite(self) -> bool { ... }
    fn is_normal(self) -> bool { ... }
    fn is_subnormal(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 clamp(self, min: Self, max: Self) -> Self { ... }
    fn recip(self) -> Self { ... }
    fn powi(self, exp: i32) -> Self { ... }
}

Generic trait for floating point numbers that works with no_std.

This trait implements a subset of the Float trait.

Required Methods

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

fn is_subnormal(self) -> bool

Returns true if the number is subnormal.

use num_traits::float::FloatCore;
use std::f64;

let min = f64::MIN_POSITIVE; // 2.2250738585072014e-308_f64
let max = f64::MAX;
let lower_than_min = 1.0e-308_f64;
let zero = 0.0_f64;

assert!(!min.is_subnormal());
assert!(!max.is_subnormal());

assert!(!zero.is_subnormal());
assert!(!f64::NAN.is_subnormal());
assert!(!f64::INFINITY.is_subnormal());
// Values between `0` and `min` are Subnormal.
assert!(lower_than_min.is_subnormal());

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

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

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

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

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

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

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

fn is_sign_positive(self) -> bool

Returns true if self is positive, including +0.0 and FloatCore::infinity(), and 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, true);
check(-f64::NAN, false);

fn is_sign_negative(self) -> bool

Returns true if self is negative, including -0.0 and FloatCore::neg_infinity(), and -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);
check(-f64::NAN, true);

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

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

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

A value bounded by a minimum and a maximum

If input is less than min then this returns min. If input is greater than max then this returns max. Otherwise this returns input.

Panics in debug mode if !(min <= max).

Examples

use num_traits::float::FloatCore;

fn check<T: FloatCore>(val: T, min: T, max: T, expected: T) {
    assert!(val.clamp(min, max) == expected);
}


check(1.0f32, 0.0, 2.0, 1.0);
check(1.0f32, 2.0, 3.0, 2.0);
check(3.0f32, 0.0, 2.0, 2.0);

check(1.0f64, 0.0, 2.0, 1.0);
check(1.0f64, 2.0, 3.0, 2.0);
check(3.0f64, 0.0, 2.0, 2.0);

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

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

Object Safety

This trait is not object safe.

Implementations on Foreign Types

impl FloatCore for f32

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 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 is_subnormal(self) -> bool

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

fn classify(self) -> FpCategory

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 to_degrees(self) -> Self

fn to_radians(self) -> Self

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 powi(self, n: i32) -> Self

impl FloatCore for f64

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 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 is_subnormal(self) -> bool

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

fn classify(self) -> FpCategory

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 to_degrees(self) -> Self

fn to_radians(self) -> Self

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 powi(self, n: i32) -> Self

Implementors