Enum `FpCategory`

enum FpCategory

A classification of floating point numbers.

This enum is used as the return type for f32::classify and f64::classify. See their documentation for more.

Examples

use std::num::FpCategory;

let num = 12.4_f32;
let inf = f32::INFINITY;
let zero = 0f32;
let sub: f32 = 1.1754942e-38;
let nan = f32::NAN;

assert_eq!(num.classify(), FpCategory::Normal);
assert_eq!(inf.classify(), FpCategory::Infinite);
assert_eq!(zero.classify(), FpCategory::Zero);
assert_eq!(sub.classify(), FpCategory::Subnormal);
assert_eq!(nan.classify(), FpCategory::Nan);

Variants

Nan

NaN (not a number): this value results from calculations like (-1.0).sqrt().

See the documentation for f32 for more information on the unusual properties of NaN.

Infinite

Positive or negative infinity, which often results from dividing a nonzero number by zero.

Zero

Positive or negative zero.

See the documentation for f32 for more information on the signedness of zeroes.

Subnormal

“Subnormal” or “denormal” floating point representation (less precise, relative to their magnitude, than Normal).

Subnormal numbers are larger in magnitude than Zero but smaller in magnitude than all Normal numbers.

Normal

A regular floating point number, not any of the exceptional categories.

The smallest positive normal numbers are f32::MIN_POSITIVE and f64::MIN_POSITIVE, and the largest positive normal numbers are f32::MAX and f64::MAX. (Unlike signed integers, floating point numbers are symmetric in their range, so negating any of these constants will produce their negative counterpart.)

Implementations

`impl Clone for FpCategory`

fn clone(self: &Self) -> FpCategory

`impl Copy for FpCategory`

`impl Debug for FpCategory`

fn fmt(self: &Self, f: &mut $crate::fmt::Formatter<'_>) -> $crate::fmt::Result

`impl Eq for FpCategory`

`impl Freeze for FpCategory`

`impl PartialEq for FpCategory`

fn eq(self: &Self, other: &FpCategory) -> bool

`impl RefUnwindSafe for FpCategory`

`impl Send for FpCategory`

`impl StructuralPartialEq for FpCategory`

`impl Sync for FpCategory`

`impl Unpin for FpCategory`

`impl UnwindSafe for FpCategory`

`impl<T> Any for FpCategory`

fn type_id(self: &Self) -> TypeId

`impl<T> Borrow for FpCategory`

fn borrow(self: &Self) -> &T

`impl<T> BorrowMut for FpCategory`

fn borrow_mut(self: &mut Self) -> &mut T

`impl<T> CloneToUninit for FpCategory`

unsafe fn clone_to_uninit(self: &Self, dest: *mut u8)

`impl<T> From for FpCategory`

fn from(t: T) -> T: Returns the argument unchanged.

`impl<T, U> Into for FpCategory`

fn into(self: Self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

`impl<T, U> TryFrom for FpCategory`

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

`impl<T, U> TryInto for FpCategory`

fn try_into(self: Self) -> Result<U, <U as TryFrom<T>>::Error>