# Enum radix_engine::types::radix_engine_common::prelude::rust::num::FpCategory

1.0.0 · source · ```
pub enum FpCategory {
Nan,
Infinite,
Zero,
Subnormal,
Normal,
}
```

## Expand description

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

## Trait Implementations§

source§### impl Clone for FpCategory

### impl Clone for FpCategory

source§#### fn clone(&self) -> FpCategory

#### fn clone(&self) -> FpCategory

source§#### fn clone_from(&mut self, source: &Self)

#### fn clone_from(&mut self, source: &Self)

`source`

. Read moresource§### impl Debug for FpCategory

### impl Debug for FpCategory

source§### impl PartialEq for FpCategory

### impl PartialEq for FpCategory

### impl Copy for FpCategory

### impl Eq for FpCategory

### impl StructuralPartialEq for FpCategory

## Auto Trait Implementations§

### impl RefUnwindSafe for FpCategory

### impl Send for FpCategory

### impl Sync for FpCategory

### impl Unpin for FpCategory

### impl UnwindSafe for FpCategory

## Blanket Implementations§

§### impl<U> As for U

### impl<U> As for U

§#### fn as_<T>(self) -> Twhere
T: CastFrom<U>,

#### fn as_<T>(self) -> Twhere
T: CastFrom<U>,

`self`

to type `T`

. The semantics of numeric casting with the `as`

operator are followed, so `<T as As>::as_::<U>`

can be used in the same way as `T as U`

for numeric conversions. Read moresource§### impl<T> BorrowMut<T> for Twhere
T: ?Sized,

### impl<T> BorrowMut<T> for Twhere
T: ?Sized,

source§#### fn borrow_mut(&mut self) -> &mut T

#### fn borrow_mut(&mut self) -> &mut T

§### impl<T> Downcast for Twhere
T: Any,

### impl<T> Downcast for Twhere
T: Any,

§#### fn into_any(self: Box<T>) -> Box<dyn Any>

#### fn into_any(self: Box<T>) -> Box<dyn Any>

`Box<dyn Trait>`

(where `Trait: Downcast`

) to `Box<dyn Any>`

. `Box<dyn Any>`

can
then be further `downcast`

into `Box<ConcreteType>`

where `ConcreteType`

implements `Trait`

.§#### fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

#### fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

`Rc<Trait>`

(where `Trait: Downcast`

) to `Rc<Any>`

. `Rc<Any>`

can then be
further `downcast`

into `Rc<ConcreteType>`

where `ConcreteType`

implements `Trait`

.§#### fn as_any(&self) -> &(dyn Any + 'static)

#### fn as_any(&self) -> &(dyn Any + 'static)

`&Trait`

(where `Trait: Downcast`

) to `&Any`

. This is needed since Rust cannot
generate `&Any`

’s vtable from `&Trait`

’s.§#### fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

#### fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

`&mut Trait`

(where `Trait: Downcast`

) to `&Any`

. This is needed since Rust cannot
generate `&mut Any`

’s vtable from `&mut Trait`

’s.§### impl<T> DowncastSync for T

### impl<T> DowncastSync for T

source§### impl<Q, K> Equivalent<K> for Q

### impl<Q, K> Equivalent<K> for Q

source§#### fn equivalent(&self, key: &K) -> bool

#### fn equivalent(&self, key: &K) -> bool

`key`

and return `true`

if they are equal.§### impl<Q, K> Equivalent<K> for Q

### impl<Q, K> Equivalent<K> for Q

§#### fn equivalent(&self, key: &K) -> bool

#### fn equivalent(&self, key: &K) -> bool

source§### impl<Q, K> Equivalent<K> for Q

### impl<Q, K> Equivalent<K> for Q

source§#### fn equivalent(&self, key: &K) -> bool

#### fn equivalent(&self, key: &K) -> bool

`key`

and return `true`

if they are equal.