# Trait num_traits::float::FloatCore

``````pub trait FloatCore: Num + NumCast + Neg<Output = Self> + PartialOrd + Copy {
Show 29 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 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 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) {
}

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

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

## Object Safety§

This trait is not object safe.

source§

source§

source§

source§

source§

source§

source§

source§

source§

source§

source§

source§

source§

source§

source§

source§

source§

source§

source§

source§

source§

source§

source§

source§

source§

source§

source§

source§

source§

source§

source§

source§

source§

source§

source§

source§

source§

source§

source§

source§

source§

source§

source§

source§

source§

source§

source§

source§

source§

source§

source§

source§

source§

source§

source§

source§

source§

source§

source§

source§