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

时间：2013-05-30 15:04:36

标签： c floating-point printf c99 floating-point-precision

是否有printf宽度说明符可以应用于浮点说明符，该说明符会自动将输出格式化为必要数量的有效数字，以便在重新扫描字符串时，获取原始浮点值？

例如，假设我打印float精度为2小数位：

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

当我扫描输出0.94时，我没有符合标准的保证，我将获得原始0.9375浮点值（在本例中，我可能不会）。

我想告诉printf自动将浮点值打印到必要数量的有效数字，以确保可以将其扫描回传递给的原始值printf。

我可以使用float.h到derive the maximum width中的一些宏传递给printf，但是已经有一个说明符可以自动打印到必要数量的有效数字 - 或至少达到最大宽度？

8 个答案:

答案 0 :(得分：71)

我推荐@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.142857 142857 142857 ...”，但我们使用的是有限精度浮点数。 我们假设IEEE 754 double-precision binary。 因此，OneSeventh = 1.0/7.0会产生以下值。还显示了前后可表示的double浮点数。

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

打印double的完全十进制表示形式的用途有限。

C在<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的数字（在C89之后设置＃1宏）？通常，结果是添加3。

现在已知有多少重要的数字，并且已通过<float.h>来驱动。

要打印N 重要十进制数字，可以使用各种格式。

使用"%e"时，精度字段是前导数字和小数点后的位数。 所以- 1是有序的。注意：这个-1 is not in the initial 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是显示默认值，而不是数字的精度。

答案 1 :(得分：52)

无损地打印浮点数的简短答案（这样可以读取它们 返回到完全相同的数字，NaN和Infinity除外）：

  • 如果您的类型是浮点数：请使用printf("%.9g", number)。
  • 如果您的类型是双倍：请使用printf("%.17g", number)。

请勿使用%f，因为它仅指定小数点后的有效位数，并将截断小数字。作为参考，可以在float.h中找到幻数9和17，它定义FLT_DECIMAL_DIG和DBL_DECIMAL_DIG。

答案 2 :(得分：22)

如果您只对位（resp hex模式）感兴趣，可以使用%a格式。这可以保证：

  

在                 如果存在基数2中的精确表示，则默认精度足以精确表示值，否则足够大以区分double类型的值。

我必须补充说，这只有在C99之后才可用。

答案 3 :(得分：11)

不，没有这样的 printf宽度说明符来打印具有最大精度的浮点数。让我解释一下原因。

float和double的最高精确度为变量，并取决于float或{的实际值 {1}}。

召回double和float以sign.exponent.mantissa格式存储。这意味着对于小数而言，分数组件使用的位数比大数字更多。

enter image description here

例如，double可以轻松区分0.0和0.1。

float

但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无法为您处理此问题。

答案 4 :(得分：9)

只需使用<float.h>中的宏和可变宽度转换说明符（".*"）：

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

答案 5 :(得分：0)

在我对答案的一个评论中，我感到遗憾的是，我一直想要某种方式以十进制形式打印浮点值中的所有有效数字，这与问题要求的方式非常相似。好吧，我终于坐下来写了。它不是很完美，这是打印附加信息的演示代码，但它主要适用于我的测试。如果您（即任何人）想要一份驱动它进行测试的整个包装程序的副本，请告诉我。

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]);
}

答案 6 :(得分：0)

我进行了一个小实验，以验证使用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();
        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;
}

我使用Microsoft的C编译器19.00.24215.1和gcc版本6.3.0 20170516（Debian 6.3.0-18 + deb9u1）运行此文件。使用少一位的十进制数字将完全相等的数字减半。 （我还验证了所使用的rand()确实产生了大约一百万个不同的数字。）这是详细的结果。

Microsoft C 

Tested 999523 values with 17 digits: 999523 found numericaly equal, 999523 found binary equal
Tested 999523 values with 16 digits: 549780 found numericaly equal, 549780 found binary equal

海湾合作委员会

Tested 999492 values with 17 digits: 999492 found numericaly equal, 999492 found binary equal
Tested 999492 values with 16 digits: 546615 found numericaly equal, 546615 found binary equal

答案 7 :(得分：0)

据我所知，有一种扩散良好的算法，可以输出到必要数量的有效数字，以便在回扫字符串时，获取{{1中的原始浮点值。 }}由丹尼尔·盖伊（Daniel Gay）编写，可在Netlib上here获得（另请参见相关的paper）。例如，使用此代码。在Python，MySQL，Scilab和许多其他版本中使用。

相关问题
最新问题