Printf 宽度说明符，以保持浮点值的精度

有没有一个 printf宽度说明符，可以应用到浮点说明符，将自动格式化输出到必要的数字 有效数字，以便当扫描字符串回来，原来的浮点值获得？

例如，假设我将 float打印到小数位 2的精度:

float foobar = 0.9375;
printf("%.2f", foobar);    // prints out 0.94

当我扫描输出 0.94时，我没有标准兼容的保证，我将得到原始的 0.9375浮点值(在这个示例中，我可能不会)。

我想一种方法告诉 printf自动打印浮点数值的 有效数字的必要数字，以确保它可以被扫描回原来的值传递给 printf。

我可以使用 float.h到 导出最大宽度中的一些宏来传递给 printf，但是是否已经有一个说明符来自动打印到 有效数字的必要数目——或者至少打印到最大宽度？

343999 次浏览
小开

只需使用来自 <float.h>的宏和可变宽度转换说明符(".*") :

float f = 3.14159265358979323846;
printf("%.*f\n", FLT_DIG, f);
小开

如果你只对位(十六进制模式)感兴趣，你可以使用 %a格式。这保证你:

默认精确度足以精确表示值，如果存在以2为基数的精确表示，而其他足够大则用于区分 double 类型的值。

我必须补充一下，这只有在 C99之后才能使用。

小开
最佳答案

我推荐@Jens Gustedt 十六进制解决方案: 使用% a。

OP 希望“以最高的精度打印(或至少打印到最重要的小数)”。

一个简单的例子是打印七分之一，如:

#include <float.h>
int Digs = DECIMAL_DIG;
double OneSeventh = 1.0/7.0;
printf("%.*e\n", Digs, OneSeventh);
// 1.428571428571428492127e-01

但是让我们深入挖掘。

从数学上讲，答案是“0.142857142857142857...”，但我们使用的是有限精度的浮点数。 假设 IEEE 754双精度二进制。 因此，OneSeventh = 1.0/7.0的结果是下面的值。还显示了前面和后面可表示的 double浮点数。

OneSeventh before = 0.1428571428571428 214571170656199683435261249542236328125
OneSeventh        = 0.1428571428571428 49212692681248881854116916656494140625
OneSeventh after  = 0.1428571428571428 769682682968777953647077083587646484375

打印 double的 一模一样小数只有有限的用途。

在 <float.h>中有两个宏家族可以帮助我们。
第一组是在十进制的字符串中打印的 意义重大数字的个数，因此当扫描字符串回来时, 我们得到原来的浮点数。这里显示了 C 规范的 最低限度值和一个 样本 C11编译器。

FLT_DECIMAL_DIG   6,  9 (float)                           (C11)
DBL_DECIMAL_DIG  10, 17 (double)                          (C11)
LDBL_DECIMAL_DIG 10, 21 (long double)                     (C11)
DECIMAL_DIG      10, 21 (widest supported floating type)  (C99)

第二套是数字 意义重大数字字符串可能被扫描成一个浮点，然后 FP 打印，仍然保留相同的字符串表示。这里显示了 C 规范的 最低限度值和一个 样本 C11编译器。我相信 C99之前就有了。

FLT_DIG   6, 6 (float)
DBL_DIG  10, 15 (double)
LDBL_DIG 10, 18 (long double)

第一组宏似乎满足了 OP 的 意义重大数字目标。但是 宏观并不总是可用的。

#ifdef DBL_DECIMAL_DIG
#define OP_DBL_Digs (DBL_DECIMAL_DIG)
#else
#ifdef DECIMAL_DIG
#define OP_DBL_Digs (DECIMAL_DIG)
#else
#define OP_DBL_Digs (DBL_DIG + 3)
#endif
#endif

“ + 3”是我之前答案的关键。 它的核心是如果知道了往返转换字符串 FP-string (设置 # 2宏可用 C89) ，如何确定 FP-string-FP 的数字(设置 # 1宏可用后 C89) ？一般来说，结果是加3。

现在有多少 意义重大数字打印是已知的，并通过 <float.h>驱动。

要打印 N 个 意义重大十进制数字，可以使用不同的格式。

对于 "%e"，精确字段是数字 之后的前导数字和小数点。 所以 - 1是正确的。注意: 这个 -1不在初始 int Digs = DECIMAL_DIG;中

printf("%.*e\n", OP_DBL_Digs - 1, OneSeventh);
// 1.4285714285714285e-01

对于 "%f"，精确字段是数字位数 之后的小数点。 对于像 OneSeventh/1000000.0这样的数字，需要 OP_DBL_Digs + 6才能看到所有的 意义重大数字。

printf("%.*f\n", OP_DBL_Digs    , OneSeventh);
// 0.14285714285714285
printf("%.*f\n", OP_DBL_Digs + 6, OneSeventh/1000000.0);
// 0.00000014285714285714285

注意: 很多人使用 "%f"。它在小数点后显示6位数字; 6是显示默认值，而不是数字的精度。

小开

不，没有这样的 Printf 宽度说明符以最大精度打印浮点数。让我解释为什么。

float和 double的最大精度是 变量，取决于 float或 double的 实际价值。

召回 float和 double是以 sign.ponent.mantissa 格式存储的。这意味着 对于小数的分数分量，还有更多的位比大数字要多。

enter image description here

例如，float可以很容易地区分0.0和0.1。

float r = 0;
printf( "%.6f\n", r ) ; // 0.000000
r+=0.1 ;
printf( "%.6f\n", r ) ; // 0.100000

但是 float并不知道 1e27和 1e27 + 0.1之间的区别。

r = 1e27;
printf( "%.6f\n", r ) ; // 999999988484154753734934528.000000
r+=0.1 ;
printf( "%.6f\n", r ) ; // still 999999988484154753734934528.000000

这是因为 所有的精确度(它受到尾数位数的限制)用于小数点左边的大部分数字。

%.f修饰符只是表示在 格式运行的情况下，要从浮点数打印多少个小数值。事实上，可用的准确度取决于数字的大小是由 你作为程序员来处理的。printf不能/不能为你处理这个。

小开

无损地打印浮点数的简短答案(这样它们就可以被读取) 返回到完全相同的数字，除了 NaN 和 Infinity) :

  • 如果您的类型是 float: 使用 printf("%.9g", number)。
  • 如果类型是 double: 使用 printf("%.17g", number)。

不要使用 %f，因为它只能指定小数后面的有效数字，并且会截断小数。作为参考，神奇的数字9和17可以在定义 FLT_DECIMAL_DIG和 DBL_DECIMAL_DIG的 float.h中找到。

小开

在我对一个答案的一条评论中，我哀叹道，我一直想要找到一种方法，以十进制形式将所有的有效数字以浮点形式打印出来，就像问题提出的那样。我终于坐下来写了。它并不十分完美，这是打印附加信息的演示代码，但它基本上适用于我的测试。请让我知道，如果你(即任何人)想要一个整个包装程序的副本，驱动它进行测试。

static unsigned int
ilog10(uintmax_t v);


/*
* Note:  As presented this demo code prints a whole line including information
* about how the form was arrived with, as well as in certain cases a couple of
* interesting details about the number, such as the number of decimal places,
* and possibley the magnitude of the value and the number of significant
* digits.
*/
void
print_decimal(double d)
{
size_t sigdig;
int dplaces;
double flintmax;


/*
* If we really want to see a plain decimal presentation with all of
* the possible significant digits of precision for a floating point
* number, then we must calculate the correct number of decimal places
* to show with "%.*f" as follows.
*
* This is in lieu of always using either full on scientific notation
* with "%e" (where the presentation is always in decimal format so we
* can directly print the maximum number of significant digits
* supported by the representation, taking into acount the one digit
* represented by by the leading digit)
*
*        printf("%1.*e", DBL_DECIMAL_DIG - 1, d)
*
* or using the built-in human-friendly formatting with "%g" (where a
* '*' parameter is used as the number of significant digits to print
* and so we can just print exactly the maximum number supported by the
* representation)
*
*         printf("%.*g", DBL_DECIMAL_DIG, d)
*
*
* N.B.:  If we want the printed result to again survive a round-trip
* conversion to binary and back, and to be rounded to a human-friendly
* number, then we can only print DBL_DIG significant digits (instead
* of the larger DBL_DECIMAL_DIG digits).
*
* Note:  "flintmax" here refers to the largest consecutive integer
* that can be safely stored in a floating point variable without
* losing precision.
*/
#ifdef PRINT_ROUND_TRIP_SAFE
# ifdef DBL_DIG
sigdig = DBL_DIG;
# else
sigdig = ilog10(uipow(FLT_RADIX, DBL_MANT_DIG - 1));
# endif
#else
# ifdef DBL_DECIMAL_DIG
sigdig = DBL_DECIMAL_DIG;
# else
sigdig = (size_t) lrint(ceil(DBL_MANT_DIG * log10((double) FLT_RADIX))) + 1;
# endif
#endif
flintmax = pow((double) FLT_RADIX, (double) DBL_MANT_DIG); /* xxx use uipow() */
if (d == 0.0) {
printf("z = %.*s\n", (int) sigdig + 1, "0.000000000000000000000"); /* 21 */
} else if (fabs(d) >= 0.1 &&
fabs(d) <= flintmax) {
dplaces = (int) (sigdig - (size_t) lrint(ceil(log10(ceil(fabs(d))))));
if (dplaces < 0) {
/* XXX this is likely never less than -1 */
/*
* XXX the last digit is not significant!!! XXX
*
* This should also be printed with sprintf() and edited...
*/
printf("R = %.0f [%d too many significant digits!!!, zero decimal places]\n", d, abs(dplaces));
} else if (dplaces == 0) {
/*
* The decimal fraction here is not significant and
* should always be zero  (XXX I've never seen this)
*/
printf("R = %.0f [zero decimal places]\n", d);
} else {
if (fabs(d) == 1.0) {
/*
* This is a special case where the calculation
* is off by one because log10(1.0) is 0, but
* we still have the leading '1' whole digit to
* count as a significant digit.
*/
#if 0
printf("ceil(1.0) = %f, log10(ceil(1.0)) = %f, ceil(log10(ceil(1.0))) = %f\n",
ceil(fabs(d)), log10(ceil(fabs(d))), ceil(log10(ceil(fabs(d)))));
#endif
dplaces--;
}
/* this is really the "useful" range of %f */
printf("r = %.*f [%d decimal places]\n", dplaces, d, dplaces);
}
} else {
if (fabs(d) < 1.0) {
int lz;


lz = abs((int) lrint(floor(log10(fabs(d)))));
/* i.e. add # of leading zeros to the precision */
dplaces = (int) sigdig - 1 + lz;
printf("f = %.*f [%d decimal places]\n", dplaces, d, dplaces);
} else {                /* d > flintmax */
size_t n;
size_t i;
char *df;


/*
* hmmmm...  the easy way to suppress the "invalid",
* i.e. non-significant digits is to do a string
* replacement of all dgits after the first
* DBL_DECIMAL_DIG to convert them to zeros, and to
* round the least significant digit.
*/
df = malloc((size_t) 1);
n = (size_t) snprintf(df, (size_t) 1, "%.1f", d);
n++;                /* for the NUL */
df = realloc(df, n);
(void) snprintf(df, n, "%.1f", d);
if ((n - 2) > sigdig) {
/*
* XXX rounding the integer part here is "hard"
* -- we would have to convert the digits up to
* this point back into a binary format and
* round that value appropriately in order to
* do it correctly.
*/
if (df[sigdig] >= '5' && df[sigdig] <= '9') {
if (df[sigdig - 1] == '9') {
/*
* xxx fixing this is left as
* an exercise to the reader!
*/
printf("F = *** failed to round integer part at the least significant digit!!! ***\n");
free(df);
return;
} else {
df[sigdig - 1]++;
}
}
for (i = sigdig; df[i] != '.'; i++) {
df[i] = '0';
}
} else {
i = n - 1; /* less the NUL */
if (isnan(d) || isinf(d)) {
sigdig = 0; /* "nan" or "inf" */
}
}
printf("F = %.*s. [0 decimal places, %lu digits, %lu digits significant]\n",
(int) i, df, (unsigned long int) i, (unsigned long int) sigdig);
free(df);
}
}


return;
}




static unsigned int
msb(uintmax_t v)
{
unsigned int mb = 0;


while (v >>= 1) { /* unroll for more speed...  (see ilog2()) */
mb++;
}


return mb;
}


static unsigned int
ilog10(uintmax_t v)
{
unsigned int r;
static unsigned long long int const PowersOf10[] =
{ 1LLU, 10LLU, 100LLU, 1000LLU, 10000LLU, 100000LLU, 1000000LLU,
10000000LLU, 100000000LLU, 1000000000LLU, 10000000000LLU,
100000000000LLU, 1000000000000LLU, 10000000000000LLU,
100000000000000LLU, 1000000000000000LLU, 10000000000000000LLU,
100000000000000000LLU, 1000000000000000000LLU,
10000000000000000000LLU };


if (!v) {
return ~0U;
}
/*
* By the relationship "log10(v) = log2(v) / log2(10)", we need to
* multiply "log2(v)" by "1 / log2(10)", which is approximately
* 1233/4096, or (1233, followed by a right shift of 12).
*
* Finally, since the result is only an approximation that may be off
* by one, the exact value is found by subtracting "v < PowersOf10[r]"
* from the result.
*/
r = ((msb(v) * 1233) >> 12) + 1;


return r - (v < PowersOf10[r]);
}
小开

我做了一个小实验来验证使用 DBL_DECIMAL_DIG打印确实能够精确地保存数字的二进制表示。事实证明，对于我尝试过的编译器和 C 库，DBL_DECIMAL_DIG确实是所需的位数，而少打印一位数会造成严重的问题。

#include <float.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>


union {
short s[4];
double d;
} u;


void
test(int digits)
{
int i, j;
char buff[40];
double d2;
int n, num_equal, bin_equal;


srand(17);
n = num_equal = bin_equal = 0;
for (i = 0; i < 1000000; i++) {
for (j = 0; j < 4; j++)
u.s[j] = (rand() << 8) ^ rand();
if (isnan(u.d))
continue;
n++;
sprintf(buff, "%.*g", digits, u.d);
sscanf(buff, "%lg", &d2);
if (u.d == d2)
num_equal++;
if (memcmp(&u.d, &d2, sizeof(double)) == 0)
bin_equal++;
}
printf("Tested %d values with %d digits: %d found numericaly equal, %d found binary equal\n", n, digits, num_equal, bin_equal);
}


int
main()
{
test(DBL_DECIMAL_DIG);
test(DBL_DECIMAL_DIG - 1);
return 0;
}

我使用微软的 C 编译器19.00.24215.1和 gcc 版本7.4.020170516(Debian 6.3.0-18 + deb9u1)运行它。少使用一个十进制数字可以将比较完全相等的数字减半。(我还验证了所使用的 rand()确实产生了大约100万个不同的数字。)这是详细的结果。

微软 C

Tested 999507 values with 17 digits: 999507 found numericaly equal, 999507 found binary equal
Tested 999507 values with 16 digits: 545389 found numericaly equal, 545389 found binary equal

海湾合作委员会

Tested 999485 values with 17 digits: 999485 found numericaly equal, 999485 found binary equal
Tested 999485 values with 16 digits: 545402 found numericaly equal, 545402 found binary equal
小开

据我所知，有一个很好的扩散算法，允许 输出到所需数量的有效数字，这样当扫描字符串返回时，就可以获得原来的浮点值在 dtoa.c的大卫盖伊写，这是可用的 给你在 Netlib (也参见相关的 纸张)。这些代码在 Python，mySQL，Scilab 和许多其他程序中都有使用。


提交答案