Struct NotNan

pub struct NotNan<T>(/* private fields */);

Expand description

A wrapper around floats providing an implementation of Eq, Ord and Hash.

A NaN value cannot be stored in this type.

use ordered_float::NotNan;

let mut v = [
    NotNan::new(2.0).unwrap(),
    NotNan::new(1.0).unwrap(),
];
v.sort();
assert_eq!(v, [1.0, 2.0]);

Because NotNan implements Ord and Eq, it can be used as a key in a HashSet, HashMap, BTreeMap, or BTreeSet (unlike the primitive f32 or f64 types):

let mut s: HashSet<NotNan<f32>> = HashSet::new();
let key = NotNan::new(1.0).unwrap();
s.insert(key);
assert!(s.contains(&key));

-0.0 and +0.0 are still considered equal. This different sign may show up in printing, or when dividing by zero (the sign of the zero becomes the sign of the resulting infinity). Therefore, NotNan may be unsuitable for use as a key in interning and memoization applications which require equal results from equal inputs, unless signed zeros make no difference or are canonicalized before insertion.

Arithmetic on NotNan values will panic if it produces a NaN value:

let a = NotNan::new(std::f32::INFINITY).unwrap();
let b = NotNan::new(std::f32::NEG_INFINITY).unwrap();

// This will panic:
let c = a + b;

§Representation

NotNan has #[repr(transparent)], so it is sound to use transmute or pointer casts to convert between any type T and NotNan<T>, as long as this does not create a NaN value. However, consider using bytemuck as a safe alternative if possible.

Implementations§

§

impl<T> NotNan<T>
where T: FloatCore,

pub fn new(val: T) -> Result<NotNan<T>, FloatIsNan>

Create a NotNan value.

Returns Err if val is NaN

§

impl<T> NotNan<T>

pub fn into_inner(self) -> T

Get the value out.

pub const unsafe fn new_unchecked(val: T) -> NotNan<T>

Create a NotNan value from a value that is guaranteed to not be NaN

§Safety

Behaviour is undefined if val is NaN

pub const unsafe fn unchecked_new(val: T) -> NotNan<T>

👎Deprecated since 2.5.0: Please use the new_unchecked function instead.

Create a NotNan value from a value that is guaranteed to not be NaN

§Safety

Behaviour is undefined if val is NaN

§

impl NotNan<f64>

pub fn as_f32(self) -> NotNan<f32>

Converts this NotNan<f64> to a NotNan<f32> while giving up on precision, using roundTiesToEven as rounding mode, yielding Infinity on overflow.

Note: For the reverse conversion (from NotNan<f32> to NotNan<f64>), you can use .into().

Trait Implementations§

§

impl<T> Add<&NotNan<T>> for NotNan<T>
where T: FloatCore,

§

type Output = NotNan<T>

The resulting type after applying the + operator.

§

fn add(self, other: &NotNan<T>) -> <NotNan<T> as Add<&NotNan<T>>>::Output

Performs the + operation. Read more

§

impl<T> Add<&T> for &NotNan<T>
where T: FloatCore,

§

type Output = NotNan<T>

The resulting type after applying the + operator.

§

fn add(self, other: &T) -> <&NotNan<T> as Add<&T>>::Output

Performs the + operation. Read more

§

impl<T> Add<&T> for NotNan<T>
where T: FloatCore,

§

type Output = NotNan<T>

The resulting type after applying the + operator.

§

fn add(self, other: &T) -> <NotNan<T> as Add<&T>>::Output

Performs the + operation. Read more

§

impl<T> Add<NotNan<T>> for &NotNan<T>
where T: FloatCore,

§

type Output = NotNan<T>

The resulting type after applying the + operator.

§

fn add(self, other: NotNan<T>) -> <&NotNan<T> as Add<NotNan<T>>>::Output

Performs the + operation. Read more

§

impl<T> Add<T> for &NotNan<T>
where T: FloatCore,

§

type Output = NotNan<T>

The resulting type after applying the + operator.

§

fn add(self, other: T) -> <&NotNan<T> as Add<T>>::Output

Performs the + operation. Read more

§

impl<T> Add<T> for NotNan<T>
where T: FloatCore,

Adds a float directly.

Panics if the provided value is NaN or the computation results in NaN

§

type Output = NotNan<T>

The resulting type after applying the + operator.

§

fn add(self, other: T) -> NotNan<T>

Performs the + operation. Read more

§

impl<T> Add for &NotNan<T>
where T: FloatCore,

§

type Output = NotNan<T>

The resulting type after applying the + operator.

§

fn add(self, other: &NotNan<T>) -> <&NotNan<T> as Add>::Output

Performs the + operation. Read more

§

impl<T> Add for NotNan<T>
where T: FloatCore,

§

type Output = NotNan<T>

The resulting type after applying the + operator.

§

fn add(self, other: NotNan<T>) -> NotNan<T>

Performs the + operation. Read more

§

impl<T> AddAssign<&NotNan<T>> for NotNan<T>
where T: FloatCore + AddAssign,

§

fn add_assign(&mut self, other: &NotNan<T>)

Performs the += operation. Read more

§

impl<T> AddAssign<&T> for NotNan<T>
where T: FloatCore + AddAssign,

§

fn add_assign(&mut self, other: &T)

Performs the += operation. Read more

§

impl<T> AddAssign<T> for NotNan<T>
where T: FloatCore + AddAssign,

§

fn add_assign(&mut self, other: T)

Performs the += operation. Read more

§

impl<T> AddAssign for NotNan<T>
where T: FloatCore + AddAssign,

§

fn add_assign(&mut self, other: NotNan<T>)

Performs the += operation. Read more

§