Trait FloatCore

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

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

Implementors