Printf width specifier to maintain precision of floating-point value

Question

Is there a printf width specifier which can be applied to a floating point specifier that would automatically format the output to the necessary number of significant digits such that when scanning the string back in  the original floating point value is acquired   For example  suppose I print a float to a precision of 2 decimal places   float foobar   0 9375  printf    2f   foobar         prints out 0 94   When I scan the output 0 94  I have no standards-compliant guarantee that I ll get the original 0 9375 floating-point value back  in this example  I probably won t    I would like a way tell printf to automatically print the floating-point value to the necessary number of significant digits to ensure that it can be scanned back to the original value passed to printf   I could use some of the macros in float h to derive the maximum width to pass to printf  but is there already a specifier to automatically print to the necessary number of significant digits -- or at least to the maximum width

User · Answer

I run a small experiment to verify that printing with DBL_DECIMAL_DIG does indeed exactly preserve the number's binary representation. It turned out that for the compilers and C libraries I tried, DBL_DECIMAL_DIG is indeed the number of digits required, and printing with even one digit less creates a significant 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++)
            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;
}

I run this with Microsoft's C compiler 19.00.24215.1 and gcc version 7.4.0 20170516 (Debian 6.3.0-18+deb9u1). Using one less decimal digit halves the number of numbers that compare exactly equal. (I also verified that rand() as used indeed produces about one million different numbers.) Here are the detailed results.

Microsoft 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

GCC

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

User · Answer

No  there is no such printf width specifier to print floating-point with maximum precision   Let me explain why   The maximum precision of float and double is variable  and dependent on the actual value of the float or double   Recall float and double are stored in sign exponent mantissa format   This means that there are many more bits used for the fractional component for small numbers than for big numbers     For example  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 float has no idea of 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 the precision  which is limited by the number of mantissa bits  is used up for the large part of the number  left of the decimal   The   f modifier just says how many decimal values you want to print from the float number as far as formatting goes   The fact that the accuracy available depends on the size of the number is up to you as the programmer to handle   printf can t doesn t handle that for you

User · Answer

Simply use the macros from  lt float h gt  and the variable-width conversion specifier          float f   3 14159265358979323846  printf     f n   FLT DIG  f

User · Answer

In one of my comments to an answer I lamented that I ve long wanted some way to print all the significant digits in a floating point value in decimal form  in much the same way the as the question asks   Well I finally sat down and wrote it   It s not quite perfect  and this is demo code that prints additional information  but it mostly works for my tests   Please let me know if you  i e  anyone  would like a copy of the whole wrapper program which drives 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                                   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   gt   0 1  amp  amp                     fabs d   lt   flintmax                    dplaces    int   sigdig -  size t  lrint ceil log10 ceil fabs d                        if  dplaces  lt  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   lt  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  gt  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   gt  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   gt    5   amp  amp  df sigdig   lt    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  gt  gt   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  lt  PowersOf10 r              from the result                      r     msb v    1233   gt  gt  12    1           return r -  v  lt  PowersOf10 r

User · Answer

I recommend  Jens Gustedt hexadecimal solution  use  a   OP wants    print with maximum precision  or at least to the most significant decimal       A simple example would be to print one seventh as in    include  lt float h gt  int Digs   DECIMAL DIG  double OneSeventh   1 0 7 0  printf     e n   Digs  OneSeventh      1 428571428571428492127e-01     But let s dig deeper      Mathematically  the answer is  0 142857 142857 142857       but we are using finite precision floating point numbers  Let s assume IEEE 754 double-precision binary   So the OneSeventh   1 0 7 0 results in the value below   Also shown are the preceding and following representable double floating point numbers   OneSeventh before   0 1428571428571428 214571170656199683435261249542236328125 OneSeventh          0 1428571428571428 49212692681248881854116916656494140625 OneSeventh after    0 1428571428571428 769682682968777953647077083587646484375   Printing the exact decimal representation of a double has limited uses   C has 2 families of macros in  lt float h gt  to help us  The first set is the number of significant digits to print in a string in decimal so when scanning the string back  we get the original floating point   There are shown with the C spec s minimum value and a sample C11 compiler   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 a string may be scanned into a floating point and then the FP printed  still retaining the same string presentation   There are shown with the C spec s minimum value and a sample C11 compiler   I believe available pre-C99   FLT DIG   6  6  float  DBL DIG  10  15  double  LDBL DIG 10  18  long double    The first set of macros seems to meet OP s goal of significant digits   But that 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   The    3  was the crux of my previous answer  Its centered on if knowing the round-trip conversion string-FP-string  set  2 macros available C89   how would one determine the digits for FP-string-FP  set  1 macros available post C89    In general  add 3 was the result   Now how many significant digits to print is known and driven via  lt float h gt      To print N significant decimal digits one may use various formats     With   e   the precision field is the number of digits after the lead digit and decimal point  So - 1 is in order   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  one would need OP DBL Digs   6 to see all the significant digits   printf     f n   OP DBL Digs      OneSeventh      0 14285714285714285 printf     f n   OP DBL Digs   6  OneSeventh 1000000 0      0 00000014285714285714285   Note  Many are use to   f    That displays 6 digits after the decimal point  6 is the display default  not the precision of the number

User · Answer

If you are only interested in the bit  resp hex pattern  you could use the  a format  This guarantees you      The                 default  precision suffices for an exact representation of the value if an exact representation in base 2 exists and otherwise is sufficiently large to distinguish values of type double    I d have to add that this is only available since C99

User · Answer

The short answer to print floating point numbers losslessly  such that they can be read back in to exactly the same 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  since that only specifies how many significant digits after the decimal and will truncate small numbers  For reference  the magic numbers 9 and 17 can be found in float h which defines FLT DECIMAL DIG and DBL DECIMAL DIG

User · Answer

To my knowledge  there is a well diffused algorithm allowing to output to the necessary number of significant digits such that when scanning the string back in  the original floating point value is acquired in dtoa c written by Daniel Gay  which is available here on Netlib  see also the associated paper   This code is used e g  in Python  MySQL  Scilab  and many others

[c] Printf width specifier to maintain precision of floating-point value

Microsoft C

GCC

Examples related to c

Examples related to floating-point

Examples related to printf

Examples related to c99

Examples related to floating-point-precision