Function compute_float

Source/external/fast_float.h:1722–1814

// in such cases.
template <typename binary>
fastfloat_really_inline FASTFLOAT_CONSTEXPR20
adjusted_mantissa compute_float(int64_t q, uint64_t w)  noexcept  {
  adjusted_mantissa answer;
  if ((w == 0) || (q < binary::smallest_power_of_ten())) {
	answer.power2 = 0;
	answer.mantissa = 0;
	// result should be zero
	return answer;
  }
  if (q > binary::largest_power_of_ten()) {
	// we want to get infinity:
	answer.power2 = binary::infinite_power();
	answer.mantissa = 0;
	return answer;
  }
  // At this point in time q is in [powers::smallest_power_of_five, powers::largest_power_of_five].

  // We want the most significant bit of i to be 1. Shift if needed.
  int lz = leading_zeroes(w);
  w <<= lz;

  // The required precision is binary::mantissa_explicit_bits() + 3 because
  // 1. We need the implicit bit
  // 2. We need an extra bit for rounding purposes
  // 3. We might lose a bit due to the "upperbit" routine (result too small, requiring a shift)

  value128 product = compute_product_approximation<binary::mantissa_explicit_bits() + 3>(q, w);
  // The computed 'product' is always sufficient.
  // Mathematical proof:
  // Noble Mushtak and Daniel Lemire, Fast Number Parsing Without Fallback (to appear)
  // See script/mushtak_lemire.py

  // The "compute_product_approximation" function can be slightly slower than a branchless approach:
  // value128 product = compute_product(q, w);
  // but in practice, we can win big with the compute_product_approximation if its additional branch
  // is easily predicted. Which is best is data specific.
  int upperbit = int(product.high >> 63);

  answer.mantissa = product.high >> (upperbit + 64 - binary::mantissa_explicit_bits() - 3);

  answer.power2 = int32_t(detail::power(int32_t(q)) + upperbit - lz - binary::minimum_exponent());
  if (answer.power2 <= 0) { // we have a subnormal?
	// Here have that answer.power2 <= 0 so -answer.power2 >= 0
	if(-answer.power2 + 1 >= 64) { // if we have more than 64 bits below the minimum exponent, you have a zero for sure.
	  answer.power2 = 0;
	  answer.mantissa = 0;
	  // result should be zero
	  return answer;
	}
	// next line is safe because -answer.power2 + 1 < 64
	answer.mantissa >>= -answer.power2 + 1;
	// Thankfully, we can't have both "round-to-even" and subnormals because
	// "round-to-even" only occurs for powers close to 0.
	answer.mantissa += (answer.mantissa & 1); // round up
	answer.mantissa >>= 1;
	// There is a weird scenario where we don't have a subnormal but just.
	// Suppose we start with 2.2250738585072013e-308, we end up
	// with 0x3fffffffffffff x 2^-1023-53 which is technically subnormal