floating-point - 哪些单精度 float 需要 9 位有效小数位才能明确表示十进制数？

Question

我在这篇关于单精度 float 的维基百科文章中找到了以下声明 https://en.wikipedia.org/wiki/Single-precision_floating-point_format :

If an IEEE 754 single-precision number is converted to a decimal string with at least 9 significant digits, and then converted back to single-precision representation, the final result must match the original number.

我试图找到单精度 float 的示例，这些 float 实际上需要 9 个有效十进制数字，并且只有 8 个有效数字并没有明确且没有找到任何数字，例如通过在 gdb 调试器中打印浮点值或尝试将不同的值转换为 Octave 音阶中的单精度，但没有找到需要超过 8 个十进制数字才能具有与其直接相邻浮点值不同的十进制表示的示例。

问题是，实际上是否存在需要 9 个十进制数字的单精度(32 位)浮点值，或者这只是一个永远不需要的安全上边界。您能否举一个单精度浮点值的示例，当它转换为仅 8 位有效十进制数字然后转换回二进制浮点表示时，其值与原始 float 不同。

Answer 1

32 位 float 以 32 位存储，这意味着不同的值最多不会超过 40 亿个。计算机的速度足以遍历所有数字，因此，暴力搜索 32 位 float 可以在可接受的时间内自动执行此操作，并测试所有可能的数字，如果转换为只有 8 个有效十进制数字加上从字符串到单精度浮点表示的反向转换会改变值。

以下简短的 C++ 程序对所有正浮点值执行此操作:

#include <cstdio>
#include <cmath>
#include <limits>
#include <cinttypes>

int main(int argc, char**argv) {
  // Test if conversion with /precision/ significant decimal digit is enough
  int precision = 8;

  // Can override precision = 8 with a command line parameter
  if (argc > 1) {
    precision = strtol(argv[1], nullptr, 0);
    if (precision < 1 || precision > 50) {
      printf("Error: precision should be between 1 and 50, got %d.\n",
             precision);
      exit(1);
    }
  }

  // Buffer length of character buffers to store string representations of
  // floating point numbers with /precision/ significant digits.  /buflen/ is
  // larger than /precision/ because it also needs to store leading zeros,
  // decimal point, sign, scientific notation exponents, and terminating \0.
  const int buflen = precision + 10;

  // storage for current number converted to string with 8 decimal digits
  char str[buflen] = "";

  // shorthands for maxfloat and infinity
  const float maxfloat = std::numeric_limits<float>::max();
  const float inf = std::numeric_limits<float>::infinity();

  // Count the number of times where /precision/ was not sufficient
  uint64_t num_clashes_found = 0;

  // Count all tested floats
  uint64_t num_floats_tested = 0;

  // loop over all positive single precision floating point numbers
  for (float f = 0.0f;               // start with zero
       f <= maxfloat;                // iterate up to and including maxfloat
       ++num_floats_tested,          // count the number of all tested floats
       f = nextafterf(f, inf))       // increment f to next larger float value 
  {
    // convert number to string with /precision/ significant decimal digits
    int numprintedchars = snprintf(str, buflen, "%.*g", precision, f);

    // If string buffer is not long enough to store number as string with
    // /precision/ significant digits, then print warning and terminate program
    if (numprintedchars >= buflen) {
      printf("Buffer length %d is not enough to store \"%.*g\", should"
             " be at least %d\n", buflen, precision, f, numprintedchars+1);
      exit(1);
    }

    // convert the string back to float
    float float_from_string = strtof(str,nullptr);

    // Compare the value
    if (f != float_from_string) {
      printf("%.*g converts to \"%s\" which reads back as %.*g.\n",
             precision+1, f, str, precision+1, float_from_string);
      ++num_clashes_found;
    }
  }
  printf("Found %" PRIu64" clashes when using %d significant decimal digits.\n",
         num_clashes_found, precision);
  printf("Total number of tested floats is %" PRIu64", i.e. with %d significant"
         " decimal digits, we get clashes in %g%% of all numbers.\n",
         num_floats_tested, precision,
         100.0 / num_floats_tested * num_clashes_found);
  return 0;
}

这个程序需要大约 20 分钟来遍历所有正的单精度 float 。

它找到的一个示例数字是 0.111294314f。当转换为具有 8 个有效数字的十进制字符串时，结果为“0.11129431”。下一个较小的单精度 float 是 0.111294307f，它在转换为只有 8 个有效数字的字符串时具有相同的十进制表示。

该程序总共计算出大约有 21.4 亿个正 float ，但其中只有大约 3200 万个需要 9 个有效十进制数字才能明确表示。这相当于所有需要 9 位数字的数字的 1.5%，这就解释了为什么手动测试不太可能找到它们:

很明显，人们会手动测试十进制表示以数字 1 开头的浮点值，因为与前面非常相似的以数字 9 开头的值相比，对于这些值，您需要一个更重要的十进制数字作为前导 1 . 但是，也有 10 的幂，其中不存在转换为十进制 1.xxx * 10^yy 的浮点值实际上需要 9 个有效数字。这些 10 的幂，其中 8 个有效数字总是足够的(给出 10 的指数，上面命名为 yy):-34、-31、-21、-18、-15、-12、-09、-06、-05 , -03, +00, +07, +08, +10, +13, +16, +19, +22, +25, +28。如果碰巧手动测试这些 10 次方附近的值，则无法找到阳性结果。这包括 10^0，即接近 1.0 的值，这可能是人类最有可能开始手动搜索的位置。