浮点数往返后不相等

use std::time::Instant;

// Writes many f64 with to_string (shortest repr), reads them back with from_str.
fn check(label: &str, mut make: impl FnMut(u64) -> f64) {
  let mut x: u64 = 0x2545F4914F6CDD1D;
  let (mut total, mut differ) = (0, 0);
  let mut example = None;
  for _ in 0..1_000_000 {
    x ^= x << 13;
    x ^= x >> 7;
    x ^= x << 17;
    let f = make(x);
    let text = serde_json::to_string(&f).unwrap();
    let parsed: f64 = serde_json::from_str(&text).unwrap();
    // The text itself is fine: std's parser reads every one back exactly.
    assert_eq!(text.parse::<f64>().unwrap(), f);
    total += 1;
    if parsed != f {
      differ += 1;
      example.get_or_insert((text, f.to_bits(), parsed.to_bits()));
    }
  }
  println!("{label}: {total} round trips, {differ} not identical");
  if let Some((text, a, b)) = example {
    println!("  e.g. {text}: bits {a:#x} -> {b:#x}");
  }
}

fn main() {
  check("[0, 1)", |x| (x >> 11) as f64 / (1u64 << 53) as f64);

  // Parse speed: one JSON array of 1_000_000 floats in [0, 1).
  let mut x: u64 = 0x2545F4914F6CDD1D;
  let floats: Vec<f64> = (0..1_000_000)
    .map(|_| {
      x ^= x << 13;
      x ^= x >> 7;
      x ^= x << 17;
      (x >> 11) as f64 / (1u64 << 53) as f64
    })
    .collect();
  let text = serde_json::to_string(&floats).unwrap();
  let mut best = u128::MAX;
  for _ in 0..5 {
    let t = Instant::now();
    let back: Vec<f64> = serde_json::from_str(&text).unwrap();
    best = best.min(t.elapsed().as_millis());
    assert_eq!(back.len(), floats.len());
  }
  println!("parse {} bytes of floats: best of 5 = {best} ms", text.len());
}

[0, 1): 1000000 round trips, 105294 not identical
  e.g. 0.38595771669529844: bits 0x3fd8b387feb616c6 -> 0x3fd8b387feb616c5
parse 19270909 bytes of floats: best of 5 = 19 ms

    #[cfg(not(feature = "float_roundtrip"))]
    fn f64_from_parts(
        &mut self,
        positive: bool,
        significand: u64,
        mut exponent: i32,
    ) -> Result<f64> {
        let mut f = significand as f64;
        loop {
            match POW10.get(exponent.wrapping_abs() as usize) {
                Some(&pow) => {
                    if exponent >= 0 {
                        f *= pow;
                        // ...
                    } else {
                        f /= pow;
                    }
                    break;
                }
                // ...
            }
        }
        Ok(if positive { f } else { -f })
    }

serde_json = { version = "=1.0.154", features = ["float_roundtrip"] }

[0, 1): 1000000 round trips, 0 not identical
parse 19270909 bytes of floats: best of 5 = 29 ms

# Use sufficient precision when parsing fixed precision floats from JSON to
# ensure that they maintain accuracy when round-tripped through JSON. This comes
# at an approximately 2x performance cost for parsing floats compared to the
# default best-effort precision.
#
# Unlike arbitrary_precision, this feature makes f64 -> JSON -> f64 produce
# output identical to the input.
float_roundtrip = []

// NaN and infinities have no JSON spelling: what comes out, and can it be read back?
fn main() {
  let v = vec![1.5, f64::NAN, f64::INFINITY, f64::NEG_INFINITY];
  let text = serde_json::to_string(&v).unwrap();
  println!("to_string           {text}");
  println!("to_value            {:?}", serde_json::to_value(&v).unwrap());
  println!("from_str Vec<f64>   {:?}", serde_json::from_str::<Vec<f64>>(&text).map_err(|e| e.to_string()));
  println!("from_str Vec<Option<f64>> {:?}", serde_json::from_str::<Vec<Option<f64>>>(&text).map_err(|e| e.to_string()));
  println!("from_str 1e400      {:?}", serde_json::from_str::<f64>("1e400").map_err(|e| e.to_string()));
}

to_string           [1.5,null,null,null]
to_value            Array [Number(1.5), Null, Null, Null]
from_str Vec<f64>   Err("invalid type: null, expected f64 at line 1 column 9")
from_str Vec<Option<f64>> Ok([Some(1.5), None, None, None])
from_str 1e400      Err("number out of range at line 1 column 5")