Print width specifier to maintain floating point precision

Question

Is there a printf width specifier that can be applied to a floating point specifier that automatically formats the output to the required number of significant digits, so that when scanning a string back to its original value, the original floating point value is acquired?

For example, suppose I print a float accurate to 2 decimal places:

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

When I look at the output of 0.94 , I have no standard compatibility with the guarantee that I will return my original value of 0.9375 floating point (in this example, I probably will not).

I would like to tell printf to automatically print the floating point value to the required number of significant digits, to make sure that it can be scanned to the original value passed to printf .

I could use some macros in float.h to get the maximum width to go to printf , but is there already a specifier for automatically printing to the required number of significant digits - or at least to the maximum width?

Answer 1

I recommend using the @Jens Gustedt hex solution: use% a.

OP wants to "print with maximum precision (or at least to the most significant decimal place)."

A simple example would be the seventh seal, as in:

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

---

But let me dig deeper ...

Mathematically, the answer is "0.142857 142857 142857 ...", but we use floating point numbers with finite precision. Suppose IEEE 754 double precision binary code . Thus, the value of OneSeventh = 1.0/7.0 leads to the value below. The previous and next representable double floating point numbers are also shown.

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

Printing the exact decimal representation of double has limited use.

C has 2 macro families in <float.h> to help us.
The first set is the number of significant digits to print per line in decimal value, so when we scan the line back, we get the original floating point. The minimum C spec and sample C11 compiler are shown.

 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) 

The second set is the number of significant digits that a string can be scanned at a floating point, and then printed by FP, while maintaining the same line presentation. The minimum C spec and sample C11 compiler are shown. I find the pre-C99 affordable.

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

The first set of macros seems to match the OP goal for significant digits. But this macro is not always available.

 #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" was the highlight of my previous answer. It focuses on knowing the conversion string in the opposite direction - FP string (macro set # 2 for C89), how to define numbers for FP-string-FP (set macro # 1 after C89)? In general, the addition of 3 was the result.

Now, how many significant digits to print are known and managed through <float.h> .

To print N significant decimal digits, you can use various formats.

With "%e" the precision field is the number of digits after the digit and decimal point. So, - 1 is fine. Note: This -1 is not in the initial int Digs = DECIMAL_DIG; `

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

With "%f" the precision field is the number of digits after the decimal point. For a number like OneSeventh/1000000.0 , you would OP_DBL_Digs + 6 to see all the significant numbers.

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

Note. Many of them are used for "%f" . It displays 6 digits after the decimal point; 6 is the default value, not the accuracy of the number.

Answer 2

Short answer for printing lossless floating point numbers (so that they can be read back to the exact number except NaN and Infinity):

• If your type is float: use printf("%.9g", number) .
• If your type is double: use printf("%.17g", number) .

DO NOT use %f , as this only determines how many significant digits after the decimal number and truncate small numbers. For reference, magic numbers 9 and 17 can be found in float.h , which defines FLT_DECIMAL_DIG and DBL_DECIMAL_DIG .

Answer 3

If you are only interested in the bit (resp hex pattern), you can use the %a format. This guarantees you:

the default accuracy is sufficient for an accurate representation of the value if there is an exact representation in base 2 and otherwise large enough to distinguish between double values.

I must add that this is only available with C99.

Answer 4

No, such a print width specifier for floating point printing does not exist with maximum precision . Let me explain why.

The maximum precision of float and double is variable and depends on the actual value of float or double .

Recall that float and double are stored in the format sign.exponent.mantissa . This means that many more bits are used for the fractional component for small numbers than for large numbers.

For example, a float can easily distinguish between 0.0 and 0.1.

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

But the float has no idea about the difference between 1e27 and 1e27 + 0.1 .

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

This is because all precision (which is limited by the number of mantissa bits) is used for most of the number to the left of the decimal.

The %.f modifier simply says how many decimal values ​​you want to print from a floating-point number, as far as formatting goes. The fact that the accuracy available depends on the size of the number is up to you as a programmer. printf can't / can't handle this for you.

Answer 5

Just use the macros from <float.h> and the variable width conversion specifier ( ".*" ):

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

Answer 6

I did a little experiment to make sure that printing with DBL_DECIMAL_DIG does indeed accurately preserve the binary representation of the number. It turned out that for the C compilers and libraries I tried, DBL_DECIMAL_DIG is really the required number of digits, and printing even with one less digit creates a serious problem.

 #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++) us[j] = rand(); if (isnan(ud)) continue; n++; sprintf(buff, "%.*g", digits, ud); sscanf(buff, "%lg", &d2); if (ud == 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; } 

I run this with the Microsoft C compiler 19.00.24215.1 and gcc version 6.3.0 20170516 (Debian 6.3.0-18 + deb9u1). Using one decimal digit less than half reduces the number of numbers that are compared. (I also verified that rand() in the form in which it is used, does yield about a million different numbers.) Here are the detailed results.

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

NKU

 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

Answer 7

In one of my comments on the answer, I lamented that I had long wanted to somehow print all significant digits in a floating point value in decimal form, in much the same way as the question asks. Well, finally, I sat down and wrote. This is not entirely ideal, and it is a demo code that prints additional information, but mostly works for my tests. Please let me know if you want (that is, anyone) to copy the entire shell program that runs it for testing.

 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) * * * NB: 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))))); /* ie 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", * ie 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]); } 

Answer 8

As far as I know, there is a well-known algorithm that allows you to output up to the required number of significant digits, so when you scan the string back, the original floating-point value is obtained in dtoa.c , written by Daniel Guy, which is available here on Netlib (see also paper article) . This code is used, for example, in Python, MySQL, Scilab and many others.