Function SplitF64ToF32

tensorflow/compiler/xla/util.cc:332–354

Utility function to split a double-precision float (F64) into a pair of F32s. For a p-bit number, and a splitting point (p/2) <= s <= (p - 1), the algorithm produces a (p - s)-bit value 'hi' and a non-overlapping (s - 1)-bit value 'lo'. See Theorem 4 in [1] (attributed to Dekker) or [2] for the original theorem by Dekker. For double-precision F64s, which contain a 53 bit mantissa (52 of them expl

// [2] T. J. Dekker, A floating point technique for extending the available
//     precision, Numerische Mathematik, vol. 18, pp. 224–242, 1971.
std::pair<float, float> SplitF64ToF32(double x) {
  const float x_f32 = static_cast<float>(x);
  // Early return if x is an infinity or NaN.
  if (!std::isfinite(x)) {
    return std::make_pair(x_f32, 0.0f);
  }

  // Only values within the range of F32 are supported, unless it is infinity.
  // Small values with large negative exponents would be rounded to zero.
  CHECK(std::isfinite(x_f32)) << x;

  // The high float is simply the double rounded to the nearest float. Because
  // we are rounding to nearest with ties to even, the error introduced in
  // rounding is less than half an ULP in the high ULP.
  const float hi = x_f32;
  // We can compute the low term using Sterbenz' lemma: If a and b are two
  // positive floating point numbers and a/2 ≤ b ≤ 2a, then their difference can
  // be computed exactly.
  // Note: the difference is computed exactly but is rounded to the nearest
  // float which will introduce additional error.
  const float lo = static_cast<float>(x - static_cast<double>(hi));
  return std::make_pair(hi, lo);
}

}  // namespace xla