Penentu lebar printf untuk menjaga ketepatan nilai floating-point

Apakah ada printfpenentu lebar yang dapat diterapkan ke penentu titik mengambang yang secara otomatis akan memformat keluaran ke jumlah digit signifikan yang diperlukan sehingga saat memindai string kembali, nilai titik mengambang asli diperoleh?

Misalnya, saya mencetak floatdengan presisi 2tempat desimal:

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

Ketika saya memindai output 0.94, saya tidak memiliki jaminan yang sesuai standar bahwa saya akan mendapatkan 0.9375kembali nilai floating-point asli (dalam contoh ini, saya mungkin tidak akan).

Saya ingin cara memberitahu printfuntuk secara otomatis mencetak nilai floating-point ke jumlah digit signifikan yang diperlukan untuk memastikan bahwa itu dapat dipindai kembali ke nilai asli yang diteruskan printf.

Saya dapat menggunakan beberapa makro float.huntuk mendapatkan lebar maksimum untuk diteruskan printf, tetapi apakah sudah ada penentu untuk mencetak secara otomatis ke jumlah digit signifikan yang diperlukan - atau setidaknya ke lebar maksimum?

Saya merekomendasikan solusi heksadesimal @Jens Gustedt: gunakan% a.

OP menginginkan "mencetak dengan presisi maksimum (atau setidaknya hingga desimal paling signifikan)".

Contoh sederhananya adalah mencetak satu ketujuh seperti di:

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

Tapi mari kita gali lebih dalam ...

Secara matematis, jawabannya adalah "0.142857 142857 142857 ...", tetapi kami menggunakan angka floating point presisi hingga. Mari kita asumsikan biner presisi ganda IEEE 754 . Jadi OneSeventh = 1.0/7.0hasilnya di nilai dibawah ini. Juga ditampilkan doublebilangan floating point sebelum dan sesudahnya.

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

Mencetak representasi desimal yang tepat dari a doublememiliki kegunaan terbatas.

C memiliki 2 keluarga makro <float.h>untuk membantu kami.
Set pertama adalah jumlah digit signifikan untuk dicetak dalam string dalam desimal sehingga saat memindai string kembali, kami mendapatkan titik mengambang asli. Ada yang ditampilkan dengan nilai minimum spesifikasi C dan kompiler C11 sampel .

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)

Set kedua adalah jumlah digit signifikan sebuah string dapat dipindai menjadi floating point dan kemudian FP dicetak, masih mempertahankan presentasi string yang sama. Ada yang ditampilkan dengan nilai minimum spesifikasi C dan kompiler C11 sampel . Saya yakin tersedia pra-C99.

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

Set makro pertama tampaknya memenuhi tujuan OP untuk digit signifikan . Tetapi makro itu tidak selalu tersedia.

#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" adalah inti dari jawaban saya sebelumnya. Ini berpusat pada jika mengetahui konversi bolak-balik string-FP-string (set # 2 makro tersedia C89), bagaimana cara menentukan digit FP-string-FP (set # 1 makro tersedia pos C89)? Secara umum, tambahkan 3 adalah hasilnya.

Sekarang berapa banyak angka penting yang akan dicetak diketahui dan didorong <float.h>.

Untuk mencetak N digit desimal signifikan, seseorang dapat menggunakan berbagai format.

Dengan "%e", bidang presisi adalah jumlah digit setelah digit awal dan titik desimal. Begitu - 1juga dengan ketertiban. Catatan: Ini -1bukan di awalint Digs = DECIMAL_DIG;

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

Dengan "%f", bidang presisi adalah jumlah digit setelah koma desimal. Untuk angka seperti OneSeventh/1000000.0, seseorang perlu OP_DBL_Digs + 6melihat semua angka penting .

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

Catatan: Banyak yang terbiasa "%f". Itu menampilkan 6 digit setelah koma desimal; 6 adalah tampilan default, bukan ketepatan angka.

Jawaban singkat untuk mencetak angka floating point tanpa kehilangan (sehingga bisa dibaca kembali ke angka yang persis sama, kecuali NaN dan Infinity):

• Jika tipe Anda float: gunakan printf("%.9g", number).
• Jika tipe Anda ganda: gunakan printf("%.17g", number).

JANGAN gunakan %f, karena itu hanya menentukan berapa banyak angka penting setelah desimal dan akan memotong angka kecil. Untuk referensi, angka ajaib 9 dan 17 dapat ditemukan di float.hmana mendefinisikan FLT_DECIMAL_DIGdan DBL_DECIMAL_DIG.

Jika Anda hanya tertarik pada bit (pola resp hex) Anda dapat menggunakan %aformat. Ini menjamin Anda:

Presisi default cukup untuk representasi nilai yang tepat jika representasi yang tepat di basis 2 ada dan jika tidak cukup besar untuk membedakan nilai tipe ganda.

Saya harus menambahkan bahwa ini hanya tersedia sejak C99.

Tidak, tidak ada penentu lebar printf untuk mencetak floating-point dengan presisi maksimum . Izinkan saya menjelaskan alasannya.

Ketepatan maksimum dari floatdan doubleadalah variabel , dan bergantung pada nilai sebenarnya dari floatatau double.

Ingat floatdan doubledisimpan dalam format sign.exponent.mantissa . Ini berarti ada lebih banyak bit yang digunakan untuk komponen pecahan untuk bilangan kecil daripada bilangan besar.

Misalnya, floatdapat dengan mudah membedakan antara 0,0 dan 0,1.

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

Tetapi floattidak tahu perbedaan antara 1e27dan 1e27 + 0.1.

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

Ini karena semua presisi (yang dibatasi oleh jumlah bit mantissa) digunakan untuk sebagian besar bilangan, di kiri desimal.

The %.fpengubah hanya mengatakan berapa banyak nilai desimal Anda ingin mencetak dari nomor float sejauh format pergi. Fakta bahwa akurasi yang tersedia tergantung pada ukuran nomor itu terserah Anda sebagai programmer untuk menangani. printftidak bisa / tidak menangani itu untuk Anda.

Cukup gunakan makro dari <float.h>dan penentu konversi lebar-variabel ( ".*"):

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

Saya menjalankan percobaan kecil untuk memverifikasi bahwa pencetakan dengan DBL_DECIMAL_DIGmemang benar-benar mempertahankan representasi biner nomor tersebut. Ternyata untuk kompiler dan pustaka C yang saya coba, DBL_DECIMAL_DIGjumlah digitnya memang diperlukan, dan mencetak bahkan dengan satu digit kurang menciptakan masalah yang signifikan.

#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;
}

Saya menjalankan ini dengan kompiler C Microsoft 19.00.24215.1 dan gcc versi 7.4.0 20170516 (Debian 6.3.0-18 + deb9u1). Menggunakan satu digit desimal kurang membagi dua jumlah angka yang perbandingannya sama persis. (Saya juga memverifikasi bahwa yang rand()digunakan memang menghasilkan sekitar satu juta angka yang berbeda.) Berikut adalah detail hasil.

Microsoft C

Uji 999507 nilai dengan 17 digit: 999507 ditemukan numerik sama, 999507 ditemukan biner sama
Uji 999507 nilai dengan 16 digit: 545389 ditemukan numerik sama, 545389 ditemukan biner sama

GCC

Uji 999485 nilai dengan 17 digit: 999485 ditemukan numerik sama, 999485 ditemukan biner sama
Uji 999485 nilai dengan 16 digit: 545402 ditemukan numerik sama, 545402 ditemukan biner sama

Dalam salah satu komentar saya untuk sebuah jawaban, saya menyesali bahwa saya sudah lama menginginkan cara untuk mencetak semua digit signifikan dalam nilai floating point dalam bentuk desimal, dengan cara yang sama seperti pertanyaan yang diajukan. Akhirnya saya duduk dan menulisnya. Ini tidak cukup sempurna, dan ini adalah kode demo yang mencetak informasi tambahan, tetapi sebagian besar berfungsi untuk pengujian saya. Tolong beritahu saya jika Anda (yaitu siapa saja) menginginkan salinan seluruh program pembungkus yang mendorongnya untuk pengujian.

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

Sepengetahuan saya, ada algoritma yang tersebar dengan baik yang memungkinkan untuk menghasilkan jumlah digit signifikan yang diperlukan sehingga ketika memindai string kembali, nilai floating point asli diperoleh secara dtoa.ctertulis oleh Daniel Gay, yang tersedia di sini di Netlib (lihat juga kertas terkait ). Kode ini digunakan misalnya di Python, MySQL, Scilab, dan banyak lainnya.