Apakah aman untuk memeriksa nilai floating point untuk kesetaraan ke 0?

Saya tahu Anda tidak dapat mengandalkan persamaan antara nilai tipe ganda atau desimal secara normal, tetapi saya bertanya-tanya apakah 0 adalah kasus khusus.

Meskipun saya dapat memahami ketidaktepatan antara 0,000000000001 dan 0,0000000000000002, 0 sendiri tampaknya cukup sulit untuk dikacaukan karena tidak ada artinya. Jika Anda tidak tepat dalam hal apa pun, itu bukan apa-apa lagi.

Tapi saya tidak tahu banyak tentang topik ini jadi bukan hak saya untuk mengatakannya.

double x = 0.0;
return (x == 0.0) ? true : false;

Akankah itu selalu benar?

Hal ini aman untuk mengharapkan bahwa perbandingan akan kembali truejika dan hanya jika variabel ganda memiliki nilai tepat 0.0(yang pada potongan kode asli Anda, tentu saja, kasus ini). Ini konsisten dengan semantik ==operator. a == bberarti " asama dengan b".

Tidaklah aman (karena tidak benar ) untuk mengharapkan bahwa hasil dari beberapa kalkulasi akan menjadi nol dalam aritmatika ganda (atau lebih umum, floating point) setiap kali hasil kalkulasi yang sama dalam Matematika murni adalah nol. Ini karena ketika kalkulasi dilakukan di lapangan, kesalahan presisi floating point muncul - sebuah konsep yang tidak ada dalam aritmatika bilangan riil dalam Matematika.

Jika Anda perlu melakukan banyak perbandingan "kesetaraan", mungkin ada baiknya untuk menulis sedikit fungsi pembantu atau metode ekstensi di .NET 3.5 untuk membandingkan:

public static bool AlmostEquals(this double double1, double double2, double precision)
{
    return (Math.Abs(double1 - double2) <= precision);
}

Ini dapat digunakan dengan cara berikut:

double d1 = 10.0 * .1;
bool equals = d1.AlmostEquals(0.0, 0.0000001);

Untuk sampel sederhana Anda, pengujian itu tidak masalah. Tapi bagaimana dengan ini:

bool b = ( 10.0 * .1 - 1.0 == 0.0 );

Ingatlah bahwa .1 adalah desimal berulang dalam biner dan tidak dapat direpresentasikan dengan tepat. Kemudian bandingkan dengan kode ini:

double d1 = 10.0 * .1; // make sure the compiler hasn't optimized the .1 issue away
bool b = ( d1 - 1.0 == 0.0 );

Saya biarkan Anda menjalankan pengujian untuk melihat hasil yang sebenarnya: Anda lebih mungkin mengingatnya seperti itu.

Dari entri MSDN untuk Double.Equals :

Presisi dalam Perbandingan

Metode Equals harus digunakan dengan hati-hati, karena dua nilai yang tampaknya setara dapat menjadi tidak sama karena presisi yang berbeda dari kedua nilai tersebut. Contoh berikut melaporkan bahwa nilai ganda .3333 dan Ganda dikembalikan dengan membagi 1 dengan 3 tidak sama.

...

Daripada membandingkan kesetaraan, satu teknik yang direkomendasikan melibatkan penentuan margin perbedaan yang dapat diterima antara dua nilai (seperti 0,01% dari salah satu nilai). Jika nilai absolut dari perbedaan antara kedua nilai kurang dari atau sama dengan margin tersebut, perbedaan tersebut kemungkinan besar disebabkan oleh perbedaan presisi dan, oleh karena itu, nilainya cenderung sama. Contoh berikut menggunakan teknik ini untuk membandingkan 0,33333 dan 1/3, dua nilai ganda yang ditemukan contoh kode sebelumnya tidak sama.

Juga, lihat Double.Epsilon .

Masalahnya muncul saat Anda membandingkan berbagai jenis implementasi nilai floating point, misalnya membandingkan float dengan double. Tapi dengan tipe yang sama, seharusnya tidak menjadi masalah.

float f = 0.1F;
bool b1 = (f == 0.1); //returns false
bool b2 = (f == 0.1F); //returns true

Masalahnya, programmer terkadang lupa bahwa implisit type cast (double to float) terjadi untuk perbandingan dan hasilnya menjadi bug.

Jika nomor itu langsung ditetapkan ke float atau double maka aman untuk menguji nol atau bilangan bulat apa pun yang dapat direpresentasikan dalam 53 bit untuk double atau 24 bit untuk float.

Atau dengan kata lain Anda selalu dapat menetapkan dan nilai integer menjadi ganda dan kemudian membandingkan kembali ganda ke integer yang sama dan dijamin itu akan sama.

Anda juga dapat memulai dengan menetapkan bilangan bulat dan membuat perbandingan sederhana terus bekerja dengan tetap menambahkan, mengurangi, atau mengalikan dengan bilangan bulat (dengan asumsi hasilnya kurang dari 24 bit untuk float abd 53 bit untuk double). Jadi, Anda dapat memperlakukan pelampung dan ganda sebagai bilangan bulat dalam kondisi terkontrol tertentu.

Tidak, ini tidak baik. Apa yang disebut nilai denormalisasi (subnormal), jika dibandingkan dengan 0,0, akan dibandingkan sebagai salah (bukan nol), tetapi bila digunakan dalam persamaan akan dinormalisasi (menjadi 0,0). Jadi, menggunakan ini sebagai mekanisme untuk menghindari pembagian-dengan-nol tidaklah aman. Sebagai gantinya, tambahkan 1.0 dan bandingkan dengan 1.0. Ini akan memastikan bahwa semua subnormal diperlakukan sebagai nol.

Coba ini, dan Anda akan menemukan bahwa == tidak dapat diandalkan untuk double / float.
double d = 0.1 + 0.2; bool b = d == 0.3;

Inilah jawaban dari Quora.

Sebenarnya, saya pikir lebih baik menggunakan kode berikut untuk membandingkan nilai ganda dengan 0,0:

double x = 0.0;
return (Math.Abs(x) < double.Epsilon) ? true : false;

Sama untuk float:

float x = 0.0f;
return (Math.Abs(x) < float.Epsilon) ? true : false;