How can I use a HashMap with f64 as key in Rust?

by

Presented with no comment beyond read all the other comments and answers to understand why you probably don’t want to do this:

use std::{collections::HashMap, hash};

#[derive(Debug, Copy, Clone)]
struct DontUseThisUnlessYouUnderstandTheDangers(f64);

impl DontUseThisUnlessYouUnderstandTheDangers {
    fn key(&self) -> u64 {
        self.0.to_bits()
    }
}

impl hash::Hash for DontUseThisUnlessYouUnderstandTheDangers {
    fn hash<H>(&self, state: &mut H)
    where
        H: hash::Hasher,
    {
        self.key().hash(state)
    }
}

impl PartialEq for DontUseThisUnlessYouUnderstandTheDangers {
    fn eq(&self, other: &DontUseThisUnlessYouUnderstandTheDangers) -> bool {
        self.key() == other.key()
    }
}

impl Eq for DontUseThisUnlessYouUnderstandTheDangers {}

fn main() {
    let a = DontUseThisUnlessYouUnderstandTheDangers(0.1);
    let b = DontUseThisUnlessYouUnderstandTheDangers(0.2);
    let c = DontUseThisUnlessYouUnderstandTheDangers(0.3);

    let mut map = HashMap::new();
    map.insert(a, 1);
    map.insert(b, 2);

    println!("{:?}", map.get(&a));
    println!("{:?}", map.get(&b));
    println!("{:?}", map.get(&c));
}

Basically, if you want to treat a f64 as a set of bits that have no meaning, well, we can treat them as an equivalently sized bag of bits that know how to be hashed and bitwise-compared.

Don’t be surprised when one of the 16 million NaN values doesn’t equal another one.

More Related Contents:

  1. How do I use floating point number literals when using generic types?
  2. How do I get the minimum or maximum value of an iterator containing floating point numbers?
  3. Why are floating point numbers inaccurate?
  4. Why not use Double or Float to represent currency?
  5. Floating point inaccuracy examples
  6. What is the rationale for all comparisons returning false for IEEE754 NaN values?
  7. Why do I see a double variable initialized to some value like 21.4 as 21.399999618530273?
  8. How to lookup from and insert into a HashMap efficiently?
  9. How is floating point stored? When does it matter?
  10. Why is NaN not equal to NaN? [duplicate]
  11. What is the difference between quiet NaN and signaling NaN?
  12. How to implement HashMap with two keys?
  13. Does float have a negative zero? (-0f)
  14. How do I create a HashMap literal?
  15. How can I update a value in a mutable HashMap?
  16. Floating point error in representation?
  17. Extended (80-bit) double floating point in x87, not SSE2 – we don’t miss it?
  18. Why does IEEE 754 reserve so many NaN values?
  19. Why can’t I compare reals in Standard ML?
  20. How do I use the Entry API with an expensive key that is only constructed if the Entry is Vacant?
  21. What’s the relative speed of floating point add vs. floating point multiply
  22. Can I use the AVX FMA units to do bit-exact 52 bit integer multiplications?
  23. How to iterate through a Hashmap, print the key/value and remove the value in Rust?
  24. How to perform round to even with floating point numbers
  25. Next higher/lower IEEE double precision number
  26. What uses do floating point NaN payloads have?
  27. Having parameter (constant) variable with NaN value in Fortran
  28. Is it possible to use a HashSet as the key to a HashMap?
  29. Maximum number of decimal digits that can affect a double
  30. How do I create a HashMap with type erased keys?

Leave a Comment