浮動小数点値の精度を維持するためのprintf幅指定子
出力を必要な数の有効数字に自動的にフォーマットする浮動小数点指定子に適用できるprintf幅指定子がありますか？文字列を元に戻すと、元の浮動小数点値が取得されますか？
たとえば、小数点以下の2の精度でfloatを出力するとします。
float foobar = 0.9375;
printf("%.2f", foobar); // prints out 0.94
出力0.94をスキャンするとき、元の0.9375浮動小数点値を戻すという標準に準拠した保証はありません（この例では、おそらくそうしません）。
printfに自動的に浮動小数点値を必要な数の有効桁数に出力するように指示して、 printfに渡された元の値。
float.hのマクロのいくつかを使用して 最大幅を導出 からprintfに渡すことができますが、必要な数に自動的に印刷する指定子が既にありますdigit-または少なくとも最大幅まで？
@Jens Gustedt 16進ソリューションをお勧めします。％aを使用します。
OPは、「最大精度（または少なくとも最上位の10進数まで）で印刷する」ことを望んでいます。
簡単な例は、次のように7分の1を印刷します。
#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倍精度バイナリ と仮定しましょう。したがって、OneSeventh = 1.0/7.0は以下の値になります。前後の表現可能なdouble浮動小数点数も示しています。
OneSeventh before = 0.1428571428571428 214571170656199683435261249542236328125
OneSeventh = 0.1428571428571428 49212692681248881854116916656494140625
OneSeventh after = 0.1428571428571428 769682682968777953647077083587646484375
doubleのexact10進表現の印刷には、用途が限られています。
Cには<float.h>に2つのマクロファミリがあります。
最初のセットは、10進数で文字列に印刷するsignificant桁数です。したがって、文字列をスキャンして戻すと、元の浮動小数点。 C仕様のminimum値とsampleC11コンパイラが示されています。
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)
2番目のセットは、有効な桁の数です。文字列をスキャンして浮動小数点にし、FPを印刷します。同じストリング表示。 C仕様のminimum値とsampleC11コンパイラが示されています。 C99より前のバージョンが利用できると思います。
FLT_Dig 6, 6 (float)
DBL_Dig 10, 15 (double)
LDBL_Dig 10, 18 (long double)
マクロの最初のセットはsignificant桁のOPの目標を満たしているようです。ただし、そのmacroは常に使用できるとは限りません。
#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-文字列（C89で利用可能なセット＃2マクロ）を知っている場合、FP-string-FP（C＃で利用可能なセット＃1マクロ）の桁をどのように決定するのでしょうか？一般に、追加3が結果でした。
これで、印刷する有効桁数桁数がわかり、<float.h>を介して駆動されます。
Nsignificant10進数を印刷するには、さまざまな形式を使用できます。
"%e"の場合、precisionフィールドは桁数afterリード数字と小数点。したがって、- 1は整然としています。注：この-1 is not in the initialint Digs = DECIMAL_Dig; `
printf("%.*e\n", OP_DBL_Digs - 1, OneSeventh);
// 1.4285714285714285e-01
"%f"の場合、precisionフィールドは桁数after小数ポイント。 OneSeventh/1000000.0のような数値の場合、すべてのsignificant数字を見るには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は表示のデフォルトであり、数値の精度ではありません。
浮動小数点数をロスレスで印刷するための簡単な答え（NaNとInfinityを除き、まったく同じ数に読み返すことができるように）：
- タイプがfloatの場合：
printf("%.9g", number)を使用します。 - タイプがdoubleの場合：
printf("%.17g", number)を使用します。
%fを使用しないでください。これは、小数点以下の有効桁数を指定するだけで、小さな数値を切り捨てます。参考のため、マジックナンバー9と17はfloat.hとFLT_DECIMAL_Digを定義するDBL_DECIMAL_Digにあります。
ビット（それぞれ16進パターン）のみに関心がある場合は、%a形式を使用できます。これにより、以下が保証されます。
基数2の正確な表現が存在し、それ以外の場合はdouble型の値を区別するのに十分な大きさであれば、デフォルトの精度で値の正確な表現で十分です。
これはC99以降でのみ利用可能であることを付け加える必要があります。
いいえ、そのような最大精度で浮動小数点を印刷するprintf幅指定子はありません。理由を説明させてください。
floatおよびdoubleの最大精度はvariableであり、floatまたはdoubleの実際の値に依存します。
リコールfloatおよびdoubleは sign.exponent.mantissa 形式で保存されます。これは、小さな数値の小数部に使用されるビットが多いが大きな数値よりも多いことを意味します。
たとえば、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修飾子は、 formatting の範囲内で、浮動小数点数から印刷する10進値の数を指定するだけです。 精度が数値のサイズに依存するという事実は、あなたがプログラマとして処理するまでです。 printfは、あなたのためにそれを処理できない/処理しません。
<float.h>のマクロと可変幅変換指定子（".*"）を使用するだけです：
float f = 3.14159265358979323846;
printf("%.*f\n", FLT_Dig, f);
DBL_DECIMAL_Digを使用した印刷が実際に数値のバイナリ表現を正確に保持することを確認するために、小さな実験を実行しました。私が試したコンパイラーとCライブラリーでは、DBL_DECIMAL_Digが実際に必要な桁数であり、1桁少ない印刷でも重大な問題が発生することが判明しました。
#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）で実行します。小数点以下1桁を使用すると、比較する数字の数が半分になります。 （使用されているRand()が実際に約100万の異なる数値を生成することも確認しました。）詳細な結果を次に示します。
Microsoft C
[。
GCC
[。
回答に対する私のコメントの1つで、質問が尋ねるのとほぼ同じ方法で、浮動小数点値のすべての有効数字を10進形式で印刷する方法が長い間欲しかったと嘆きました。さて、ついに座って書いた。完璧ではありません。これは追加情報を出力するデモコードですが、ほとんどの場合、私のテストで機能します。あなた（つまり、誰でも）がテスト用のラッパープログラム全体のコピーを希望する場合は、お知らせください。
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]);
}