ordered-float

ordered-float provides OrderedFloat and NotNan wrapper types that implement Ord, Eq, and Hash for floating-point numbers, which Rust’s native f32/f64 types cannot do because of NaN’s IEEE-754 comparison semantics. This lets floats be used as keys in BTreeMap/HashMap, sorted with the standard library’s sort functions, and compared with <, ==, and friends without runtime panics or partial-ordering workarounds.

What You Get

• OrderedFloat<T> giving any float type a total order (NaN sorts consistently rather than being incomparable)
• NotNan<T> which enforces at construction time that the wrapped value is never NaN, returning a Result otherwise
• Hash implementations for both wrapper types, enabling floats as HashMap/HashSet keys
• Optional integrations behind feature flags for serde, rand, arbitrary, bytemuck, rkyv, schemars, and proptest
• no_std support via the libm feature for embedded and constrained environments

Common Use Cases

• Sorting a Vec<f64> of scores, prices, or measurements without a custom comparator
• Using floating-point values as keys in a BTreeMap or HashMap (e.g. for a priority queue keyed by a float weight)
• Guaranteeing at the type level that a float field can never be NaN via NotNan
• Serializing/deserializing float-keyed collections with serde in scientific or numerical Rust codebases

Under The Hood

Architecture - The crate is a single lib.rs module (~3000 lines including tests) defining two core newtypes, OrderedFloat<T> and NotNan<T>, each implementing Ord/Eq/Hash by treating NaN as a well-defined sort position rather than propagating IEEE-754’s incomparability, with NotNan additionally enforcing a construction-time invariant via Result-returning constructors. Tech Stack - Pure Rust, no_std-compatible (with an optional libm feature for math without the standard library), depending only on num-traits by default, with a long list of optional integration crates (serde, rand, arbitrary, bytemuck, rkyv, rkyv_08, schemars, speedy, derive-visitor) gated behind Cargo feature flags to keep the default dependency footprint minimal. Code Quality - The tests/ directory and inline unit tests cover both wrapper types, NaN edge cases, and each optional feature integration individually (e.g. serde round-tripping, proptest-based property tests), with rustfmt.toml enforcing consistent formatting across the small codebase. API Design - The API surface is deliberately minimal and idiomatic: both types implement the standard comparison/hash traits so they slot into existing generic code (sorted collections, hash maps) with zero special-casing, and NotNan::new() returning Result<Self, FloatIsNan> follows Rust’s fallible-construction convention rather than panicking.