Printf spécificateur de largeur pour maintenir la précision de la valeur à virgule flottante

La réponse courte à imprimer des nombres à virgule flottante sans perte (tels qu'ils peuvent être lus
de retour à exactement le même nombre, à l'exception de NaN et de l'Infini):

• Si votre type float: utilisation printf("%.9g", number).
• Si votre type est double: utiliser printf("%.17g", number).

Ne PAS utiliser %f, depuis que seuls spécifie le nombre de chiffres significatifs après la virgule et tronques de petits nombres. Pour référence, la magie des nombres 9 et 17 peuvent être trouvés dans float.h qui définit FLT_DECIMAL_DIG et DBL_DECIMAL_DIG.

Non, il n'y a pas une telle printf spécificateur de largeur d'impression à virgule flottante avec un maximum de précision. Laissez-moi vous expliquer pourquoi.

Le maximum de précision de float et double est variable, et dépend de la valeur réelle de la float ou double.

Rappel float et double sont stockés dans signe.l'exposant.mantisse format. Cela signifie que il y a beaucoup plus de bits utilisés pour la fraction de la composante pour les petits nombres que pour les grands nombres.

Par exemple, float peut facilement distinguer entre 0,0 et 0,1.

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

Mais float n'a aucune idée de la différence entre 1e27 et 1e27 + 0.1.

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

C'est parce que toute la précision (qui est limité par le nombre de bits de la mantisse) est utilisé pour la grande partie du nombre, à gauche de la décimale.

La %.f modificateur dit juste combien de valeurs décimales que vous souhaitez imprimer à partir du nombre à virgule autant que mise en forme va. Le fait que le la précision dépend de la taille du nombre est à vous que le programmeur à manipuler. printf ne peut pas/ne gère pas que pour vous.

Dans un de mes commentaires pour la réponse, je déplore que j'ai longtemps voulu d'une certaine façon à l'impression de tous les chiffres significatifs dans une valeur à virgule flottante en forme décimale, de la même façon la question se pose. Eh bien j'ai enfin s'assit et écrivit-il. Ce n'est pas tout à fait parfaite, et c'est le code de démonstration qui imprime des informations supplémentaires, mais il a surtout pour mes tests. S'il vous plaît laissez-moi savoir si vous (c'est à dire n'importe qui) serait comme une copie de l'ensemble du programme d'enveloppe qui l'anime pour le test.

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

À ma connaissance, il est bien diffusée algorithme permettant de de sortie pour le nombre de chiffres significatifs tels que lors de la numérisation de la chaîne de retour dans, l'original de la valeur à virgule flottante est acquis dans dtoa.c écrit par Daniel Gay, qui est disponible ici sur Netlib (voir aussi les associés papier). Ce code est utilisé par exemple en Python, MySQL, Scilab, et beaucoup d'autres.