#[inline]
pub fn hypot(coords: &[f64]) -> f64 {
    let mut max = 0.0_f64;
    let mut found_nan = false;
    let mut abs_coords = Vec::with_capacity(10);

    for &x in coords {
        let ax = x.abs();
        abs_coords.push(ax);
        found_nan |= ax.is_nan();
        if ax > max {
            max = ax;
        }
    }

    vector_norm(&abs_coords, max, found_nan)
}

unsafe extern "C" {
    pub fn frexp(n: f64, exp: *mut i32) -> f64;
}

/// Compute the Euclidean norm of a vector with high precision.
pub fn vector_norm(vec: &[f64], max: f64, found_nan: bool) -> f64 {
    let n = vec.len();

    if max.is_infinite() {
        return max;
    }
    if found_nan {
        return f64::NAN;
    }

    let mut max_e: i32 = 0;
    unsafe { frexp(max, &mut max_e) };

    // the code below is totally unreachable, but making recursive call is important
    if max_e < -1023 {
        // When max_e < -1023, ldexp(1.0, -max_e) would overflow.
        // TODO: This can be in-place ops, but we allocate a copy since we take &[f64].
        // This is acceptable because subnormal inputs are extremely rare in practice.
        let vec_copy: Vec<f64> = vec.iter().map(|&x| x / f64::MIN_POSITIVE).collect();
        let r = f64::MIN_POSITIVE * vector_norm(&vec_copy, max / f64::MIN_POSITIVE, found_nan);
        unreachable!();
        return r;
    }

    unreachable!();
}

#[cfg(test)]
mod tests {
    use super::*;

    pub const SNAN: f64 = f64::from_bits(0x7FF0_0000_0000_0001);

    fn test_hypot(coords: &[f64]) {
        let rs_result = hypot(coords);

        // SNAN + INFINITY should return INFINITY
        if coords[0].to_bits() == SNAN.to_bits() && coords[1].to_bits() == f64::INFINITY.to_bits() {
            assert_eq!(
                rs_result.to_bits(),
                0x7ff0000000000000,
                "hypot([SNAN, INFINITY]) should return INFINITY, got 0x{:x}",
                rs_result.to_bits()
            );
        }

        // Minimal serde_json usage - required for bug to manifest
        // This code path is never executed for SNAN test case
        if rs_result.is_nan() {
            return;
        }

        let _json = serde_json::to_string(&rs_result).unwrap();
    }

    pub const EDGE_VALUES: &[f64] = &[SNAN, f64::INFINITY];

    #[test]
    fn edgetest_hypot() {
        for &x in EDGE_VALUES {
            for &y in EDGE_VALUES {
                test_hypot(&[x, y]);
            }
        }
    }
}