# Trait num_traits::float::FloatCore

``````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 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

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

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

Returns NaN.

##### Examples
``````use num_traits::float::FloatCore;

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

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

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

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

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

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

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

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

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) {
}

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

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) {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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