# [−][src]Trait num::traits::float::FloatCore

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

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

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

Loading content...

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

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

### `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, min: T) {
        assert!(x.max(y) == min);
    }

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

Loading content...

## Implementations on Foreign Types

### `impl FloatCore for f32`[src]

#### `fn infinity() -> f32`[src]

#### `fn neg_infinity() -> f32`[src]

#### `fn nan() -> f32`[src]

#### `fn neg_zero() -> f32`[src]

#### `fn min_value() -> f32`[src]

#### `fn min_positive_value() -> f32`[src]

#### `fn epsilon() -> f32`[src]

#### `fn max_value() -> f32`[src]

#### `fn integer_decode(self) -> (u64, i16, i8)`[src]

#### `fn is_nan(self) -> bool`[src]

#### `fn is_infinite(self) -> bool`[src]

#### `fn is_finite(self) -> bool`[src]

#### `fn is_normal(self) -> bool`[src]

#### `fn classify(self) -> FpCategory`[src]

#### `fn floor(self) -> f32`[src]

#### `fn ceil(self) -> f32`[src]

#### `fn round(self) -> f32`[src]

#### `fn trunc(self) -> f32`[src]

#### `fn fract(self) -> f32`[src]

#### `fn abs(self) -> f32`[src]

#### `fn signum(self) -> f32`[src]

#### `fn is_sign_positive(self) -> bool`[src]

#### `fn is_sign_negative(self) -> bool`[src]

#### `fn min(self, other: f32) -> f32`[src]

#### `fn max(self, other: f32) -> f32`[src]

#### `fn recip(self) -> f32`[src]

#### `fn powi(self, n: i32) -> f32`[src]

#### `fn to_degrees(self) -> f32`[src]

#### `fn to_radians(self) -> f32`[src]

### `impl FloatCore for f64`[src]

#### `fn infinity() -> f64`[src]

#### `fn neg_infinity() -> f64`[src]

#### `fn nan() -> f64`[src]

#### `fn neg_zero() -> f64`[src]

#### `fn min_value() -> f64`[src]

#### `fn min_positive_value() -> f64`[src]

#### `fn epsilon() -> f64`[src]

#### `fn max_value() -> f64`[src]

#### `fn integer_decode(self) -> (u64, i16, i8)`[src]

#### `fn is_nan(self) -> bool`[src]

#### `fn is_infinite(self) -> bool`[src]

#### `fn is_finite(self) -> bool`[src]

#### `fn is_normal(self) -> bool`[src]

#### `fn classify(self) -> FpCategory`[src]

#### `fn floor(self) -> f64`[src]

#### `fn ceil(self) -> f64`[src]

#### `fn round(self) -> f64`[src]

#### `fn trunc(self) -> f64`[src]

#### `fn fract(self) -> f64`[src]

#### `fn abs(self) -> f64`[src]

#### `fn signum(self) -> f64`[src]

#### `fn is_sign_positive(self) -> bool`[src]

#### `fn is_sign_negative(self) -> bool`[src]

#### `fn min(self, other: f64) -> f64`[src]

#### `fn max(self, other: f64) -> f64`[src]

#### `fn recip(self) -> f64`[src]

#### `fn powi(self, n: i32) -> f64`[src]

#### `fn to_degrees(self) -> f64`[src]

#### `fn to_radians(self) -> f64`[src]

Loading content...

## Implementors

Loading content...

# Help

## Keyboard Shortcuts

`?`
  Show this help dialog
`S`
  Focus the search field
`↑`
  Move up in search results
`↓`
  Move down in search results
`↹`
  Switch tab
`⏎`
  Go to active search result
`+`
  Expand all sections
`-`
  Collapse all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g., `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g., `vec -> usize` or `* -> vec`)

Search multiple things at once by splitting your query with comma (e.g., `str,u8` or `String,struct:Vec,test`)