num_traits::float

Trait FloatCore

Source 
pub trait FloatCore:
    Num
    + NumCast
    + Neg<Output = Self>
    + PartialOrd
    + Copy {

Show 31 methods    // 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 { ... }

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

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

Dyn Compatibility§

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

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

Source§

fn is_infinite(self) -> bool

Source§

fn is_finite(self) -> bool

Source§

fn is_normal(self) -> bool

Source§

fn is_subnormal(self) -> bool

Source§

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

Source§

fn classify(self) -> FpCategory

Source§

fn is_sign_positive(self) -> bool

Source§

fn is_sign_negative(self) -> bool

Source§

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

Source§

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

Source§

fn recip(self) -> Self

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

Source§

fn abs(self) -> Self

Source§

fn signum(self) -> Self

Source§

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

Source§

fn is_infinite(self) -> bool

Source§

fn is_finite(self) -> bool

Source§

fn is_normal(self) -> bool

Source§

fn is_subnormal(self) -> bool

Source§

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

Source§

fn classify(self) -> FpCategory

Source§

fn is_sign_positive(self) -> bool

Source§

fn is_sign_negative(self) -> bool

Source§

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

Source§

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

Source§

fn recip(self) -> Self

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

Source§

fn abs(self) -> Self

Source§

fn signum(self) -> Self

Source§

fn powi(self, n: i32) -> Self

Implementors§