writer_float_math.hpp

#pragma once
 
inline uint64_t Writer::RoundScaledF32(float value, uint32_t scale)
{
  uint32_t bits = std::bit_cast<uint32_t>(value);
  uint32_t exponent_bits = (bits >> 23) & 0xFFU;
  uint32_t fraction_bits = bits & 0x7FFFFFU;
  uint32_t significand =
      (exponent_bits == 0) ? fraction_bits : ((1U << 23) | fraction_bits);
  int exponent2 =
      (exponent_bits == 0) ? -149 : static_cast<int>(exponent_bits) - 150;
  uint64_t numerator = static_cast<uint64_t>(significand) * scale;
 
  if (exponent2 >= 0)
  {
    return numerator << exponent2;
  }
 
  unsigned int shift = static_cast<unsigned int>(-exponent2);
  if (shift >= 64)
  {
    return 0;
  }
  uint64_t quotient = numerator >> shift;
  uint64_t remainder = numerator & ((uint64_t{1} << shift) - 1U);
  uint64_t halfway = uint64_t{1} << (shift - 1);
  if (remainder > halfway || (remainder == halfway && (quotient & 1U) != 0U))
  {
    ++quotient;
  }
  return quotient;
}
 
template <typename Float>
struct Writer::DecimalScale
{
  int exponent = 0;  
  Float scale = 1;   
};
 
template <typename Float>
Float Writer::Power10(int exponent)
{
  Float result = 1;
  Float base = 10;
  unsigned int remaining =
      static_cast<unsigned int>(exponent < 0 ? -exponent : exponent);
 
  while (remaining != 0)
  {
    if ((remaining & 1U) != 0U)
    {
      if (exponent < 0)
      {
        result /= base;
      }
      else
      {
        result *= base;
      }
    }
 
    remaining >>= 1U;
    if (remaining != 0U)
    {
      base *= base;
    }
  }
 
  return result;
}
 
template <typename Float>
Writer::DecimalScale<Float> Writer::NormalizeDecimal(Float value)
{
  DecimalScale<Float> normalized{};
  if (value == 0)
  {
    return normalized;
  }
 
  int binary_exponent = 0;
  std::frexp(value, &binary_exponent);
  constexpr Float log10_of_2 =
      static_cast<Float>(0.30102999566398119521373889472449L);
  normalized.exponent =
      static_cast<int>(static_cast<Float>(binary_exponent - 1) * log10_of_2);
  normalized.scale = Power10<Float>(normalized.exponent);
 
  Float scaled = value / normalized.scale;
  while (scaled < 1)
  {
    normalized.scale /= 10;
    --normalized.exponent;
    scaled *= 10;
  }
  while (scaled >= 10)
  {
    normalized.scale *= 10;
    ++normalized.exponent;
    scaled /= 10;
  }
 
  return normalized;
}
 
template <typename Float>
uint8_t Writer::ExtractDigit(Float& value, Float scale)
{
  Float scaled = value / scale;
  auto digit = static_cast<int>(scaled + static_cast<Float>(1e-12L));
  if (digit < 0)
  {
    digit = 0;
  }
  else if (digit > 9)
  {
    digit = 9;
  }
 
  value -= static_cast<Float>(digit) * scale;
  Float epsilon = scale * static_cast<Float>(1e-9L);
  if (value < 0 && value > -epsilon)
  {
    value = 0;
  }
 
  return static_cast<uint8_t>(digit);
}
 
inline size_t Writer::TrimGeneralText(char* text, size_t size)
{
  size_t exponent_pos = size;
  for (size_t i = 0; i < size; ++i)
  {
    if (text[i] == 'e' || text[i] == 'E')
    {
      exponent_pos = i;
      break;
    }
  }
 
  size_t mantissa_end = exponent_pos;
  while (mantissa_end > 0 && text[mantissa_end - 1] == '0')
  {
    --mantissa_end;
  }
  if (mantissa_end > 0 && text[mantissa_end - 1] == '.')
  {
    --mantissa_end;
  }
 
  if (exponent_pos == size)
  {
    return mantissa_end;
  }
 
  std::memmove(text + mantissa_end, text + exponent_pos, size - exponent_pos);
  return mantissa_end + (size - exponent_pos);
}
 
inline bool Writer::AppendExponentText(char* out, size_t& out_size, int exponent,
                                       bool upper_case)
{
  if (!AppendBufferChar(out, float_buffer_capacity, out_size,
                        upper_case ? 'E' : 'e'))
  {
    return false;
  }
  if (!AppendBufferChar(out, float_buffer_capacity, out_size,
                        exponent < 0 ? '-' : '+'))
  {
    return false;
  }
 
  char digits[UnsignedDigitCapacity<unsigned int, 10>()];
  unsigned int magnitude =
      static_cast<unsigned int>(exponent < 0 ? -exponent : exponent);
  size_t digit_count = AppendUnsigned<10>(digits, magnitude);
  if (digit_count < 2 &&
      !AppendBufferChar(out, float_buffer_capacity, out_size, '0'))
  {
    return false;
  }
 
  return AppendBufferText(out, float_buffer_capacity, out_size,
                          std::string_view(digits, digit_count));
}