const F16_SUBNORMAL_ULP: f32 = f32::from_bits(0x3380_0000);
pub fn f16_to_f32(bits: u16) -> f32 {
let sign = u32::from(bits >> 15) << 31;
let exp = (bits >> 10) & 0x1F;
let frac = u32::from(bits & 0x03FF);
match exp {
0 => {
let magnitude = frac as f32 * F16_SUBNORMAL_ULP;
f32::from_bits(magnitude.to_bits() | sign)
}
0x1F => f32::from_bits(sign | 0x7F80_0000 | (frac << 13)),
_ => f32::from_bits(sign | (u32::from(exp) + 112) << 23 | (frac << 13)),
}
}
pub fn f32_to_f16(x: f32) -> u16 {
let bits = x.to_bits();
let sign = ((bits >> 16) & 0x8000) as u16;
let exp = ((bits >> 23) & 0xFF) as i32;
let frac = bits & 0x007F_FFFF;
if exp == 0xFF {
if frac == 0 {
return sign | 0x7C00;
}
return sign | 0x7C00 | 0x0200 | ((frac >> 13) as u16 & 0x03FF);
}
let e16 = exp - 112;
if e16 >= 0x1F {
return sign | 0x7C00;
}
if e16 <= 0 {
if e16 < -10 {
return sign;
}
let mant = if exp == 0 { frac } else { frac | 0x0080_0000 };
let shift = (14 - e16) as u32;
let ulp = 1u32 << shift;
let half = ulp >> 1;
let mut v = mant >> shift;
let rem = mant & (ulp - 1);
if rem > half || (rem == half && v & 1 == 1) {
v += 1; }
return sign | v as u16;
}
let mut v = ((e16 as u32) << 10) | (frac >> 13);
let rem = frac & 0x1FFF;
if rem > 0x1000 || (rem == 0x1000 && v & 1 == 1) {
v += 1;
}
sign | v as u16
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn f16_to_f32_known_vectors() {
assert_eq!(f16_to_f32(0x0000), 0.0);
assert!(f16_to_f32(0x8000) == 0.0 && f16_to_f32(0x8000).is_sign_negative());
assert_eq!(f16_to_f32(0x3C00), 1.0);
assert_eq!(f16_to_f32(0xC100), -2.5);
assert_eq!(f16_to_f32(0x7BFF), 65504.0); assert_eq!(f16_to_f32(0x0001), F16_SUBNORMAL_ULP); assert_eq!(f16_to_f32(0x03FF), 1023.0 * F16_SUBNORMAL_ULP); assert_eq!(f16_to_f32(0x8001), -F16_SUBNORMAL_ULP);
assert_eq!(f16_to_f32(0x7C00), f32::INFINITY);
assert_eq!(f16_to_f32(0xFC00), f32::NEG_INFINITY);
assert!(f16_to_f32(0x7E00).is_nan());
assert!(f16_to_f32(0xFE01).is_nan());
assert_eq!(f16_to_f32(0x3555), 0.333_251_95); }
#[test]
fn f32_to_f16_known_vectors() {
assert_eq!(f32_to_f16(0.0), 0x0000);
assert_eq!(f32_to_f16(-0.0), 0x8000);
assert_eq!(f32_to_f16(1.0), 0x3C00);
assert_eq!(f32_to_f16(-2.5), 0xC100);
assert_eq!(f32_to_f16(65504.0), 0x7BFF);
assert_eq!(f32_to_f16(65520.0), 0x7C00); assert_eq!(f32_to_f16(1e9), 0x7C00);
assert_eq!(f32_to_f16(f32::INFINITY), 0x7C00);
assert_eq!(f32_to_f16(f32::NEG_INFINITY), 0xFC00);
assert_eq!(f32_to_f16(F16_SUBNORMAL_ULP), 0x0001);
assert_eq!(f32_to_f16(0.5 * F16_SUBNORMAL_ULP), 0x0000); assert_eq!(f32_to_f16(0.75 * F16_SUBNORMAL_ULP), 0x0001); assert_eq!(f32_to_f16(1e-10), 0x0000); assert_eq!(f32_to_f16(-1e-10), 0x8000);
assert!(f16_to_f32(f32_to_f16(f32::NAN)).is_nan());
assert!(f16_to_f32(f32_to_f16(f32::from_bits(0x7F80_0001))).is_nan());
}
#[test]
fn f16_round_trip_all_finite() {
for bits in 0u16..=0xFFFF {
let exp = (bits >> 10) & 0x1F;
if exp == 0x1F {
continue; }
let f = f16_to_f32(bits);
assert_eq!(
f32_to_f16(f),
bits,
"bits {bits:#06x} -> {f} did not round-trip"
);
}
}
#[test]
fn f32_to_f16_nearest_even_on_normals() {
assert_eq!(f32_to_f16(1.000_488_3), 0x3C00);
assert_eq!(f32_to_f16(1.000_488_4), 0x3C01);
assert_eq!(f32_to_f16(1.001_464_8), 0x3C02);
}
}