Method from_float

cpp/fory/util/float16.cc:30–117

Convert float32 to float16 using IEEE 754 round-to-nearest, ties-to-even. Layout of float32: [S|EEEEEEEE|MMMMMMMMMMMMMMMMMMMMMMM] (1+8+23 bits) Layout of float16: [S|EEEEE|MMMMMMMMMM] (1+5+10 bits) Exponent bias: 127 (f32) vs 15 (f16).

// Layout of float16: [S|EEEEE|MMMMMMMMMM]                (1+5+10 bits)
// Exponent bias: 127 (f32) vs 15 (f16).
float16_t float16_t::from_float(float f) noexcept {
  uint32_t bits;
  std::memcpy(&bits, &f, sizeof(bits));

  const uint32_t sign = bits & 0x80000000u;
  const uint32_t exp = (bits >> 23) & 0xFFu;
  const uint32_t mantissa = bits & 0x007FFFFFu;

  // NaN or Infinity (f32 exp = 0xFF)
  if (exp == 255u) {
    if (mantissa == 0u) {
      // ±Inf → ±Inf
      return from_bits(static_cast<uint16_t>((sign >> 16) | 0x7C00u));
    }
    // NaN → quiet NaN; map top 9 bits of f32 payload to f16 payload,
    // force quiet bit (bit 9 of f16 fraction).
    const uint32_t nan_payload = (mantissa >> 13) & 0x03FFu;
    const uint32_t quiet_bit = 0x0200u;
    return from_bits(static_cast<uint16_t>((sign >> 16) | 0x7C00u | quiet_bit |
                                           nan_payload));
  }

  // ±0 (also catches -0.0)
  if (exp == 0u && mantissa == 0u) {
    return from_bits(static_cast<uint16_t>(sign >> 16));
  }

  // Convert exponent bias: 127 → 15
  const int32_t exp16 = static_cast<int32_t>(exp) - 127 + 15;

  // Overflow → ±Inf
  if (exp16 >= 31) {
    return from_bits(static_cast<uint16_t>((sign >> 16) | 0x7C00u));
  }

  // Underflow: result is a f16 subnormal, or flushes to ±0.
  if (exp16 <= 0) {
    // Values with exp16 < -10 are too small even for the smallest f16
    // subnormal (2^-24); also handles all f32 subnormal inputs (exp==0).
    if (exp16 < -10) {
      return from_bits(static_cast<uint16_t>(sign >> 16));
    }
    // Assemble f16 subnormal.  The f32 normal implicit leading 1 participates
    // in the f16 mantissa, so include it explicitly.
    const uint32_t full_mantissa = (1u << 23) | mantissa;
    // Total right-shift to produce the 10-bit f16 subnormal mantissa:
    //   13 bits (to drop from 23 to 10) + (1 - exp16) for subnormal scaling.
    const int32_t shift_total = 13 + (1 - exp16);
    const uint32_t round_bit = 1u << (shift_total - 1);
    const uint32_t sticky_mask = round_bit - 1u;
    const bool sticky = (full_mantissa & sticky_mask) != 0u;
    const uint32_t mantissa16 = full_mantissa >> shift_total;
    // Round-to-nearest, ties-to-even
    const uint32_t result = ((full_mantissa & round_bit) != 0u &&
                             (sticky || (mantissa16 & 1u) != 0u))
                                ? mantissa16 + 1u
                                : mantissa16;
    // Note: if rounding carries out of the subnormal mantissa the natural