Чи безпечно перевіряти значення плаваючої точки на рівність 0?

Я знаю, що ти не можеш покладатися на рівність між подвійними або десятковими значеннями типу, але мені цікаво, чи 0 є особливим випадком.

Хоча я можу зрозуміти неточності між 0,00000000000001 та 0,00000000000002, 0 сам по собі здається досить важким зіпсувати, оскільки це просто нічого. Якщо ви ні до чого не чіткі, то це вже нічого.

Але я мало знаю про цю тему, тому мені це не сказати.

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

Чи завжди це повернеться правдою?

Можна з упевненістю очікувати, що порівняння повернеться trueтоді і лише тоді, коли подвійна змінна має значення точно 0.0(що, звичайно, у вашому вихідному фрагменті коду - це, безумовно, так). Це відповідає семантиці ==оператора. a == bозначає " aдорівнює b".

Це небезпечно (бо це неправильно ) очікувати , що результат деякого розрахунку буде дорівнює нуль в подвійній (або в більш загальному плані , з плаваючою точкою) арифметики , коли результат такого ж розрахунок в чистій математиці дорівнює нуль. Це тому, що коли обчислення потрапляють у землю, з’являється помилка точності з плаваючою точкою - поняття, яке не існує в арифметиці реального числа математики.

Якщо вам потрібно зробити багато порівнянь "рівності", можливо, було б хорошою ідеєю написати трохи допоміжної функції або методу розширення в .NET 3.5 для порівняння:

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

Це можна використати наступним чином:

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

Для вашого простого зразка цей тест добре. А як щодо цього:

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

Пам'ятайте, що .1 - це десятковий повтор у двійковій формі, і його неможливо точно представити. Потім порівняйте це з цим кодом:

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

Я залишу вас пройти тест, щоб побачити фактичні результати: ви швидше пам’ятаєте його таким чином.

З запису MSDN для Double.Equals :

Точність у порівняннях

Метод рівних слід застосовувати обережно, оскільки два, мабуть, еквівалентні значення можуть бути неоднаковими через різну точність двох значень. Наступний приклад повідомляє, що значення подвійного .3333 та подвійне, повернене діленням 1 на 3, є неоднаковими.

...

Замість порівняння для рівності одна рекомендована методика передбачає визначення допустимої різниці між двома значеннями (наприклад, .01% одного із значень). Якщо абсолютна величина різниці між двома значеннями менша або дорівнює цій границі, різниця, ймовірно, буде обумовлена ​​різницею в точності, і, отже, значення, ймовірно, будуть рівні. Наступний приклад використовує цю методику для порівняння .33333 та 1/3, двох значень Double, які попередній приклад коду визнав нерівними.

Також див. Double.Epsilon .

Проблема виникає, коли ви порівнюєте різні типи реалізації значень з плаваючою комою, наприклад, порівняння поплавця з подвійним. Але з тим самим типом це не повинно бути проблемою.

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

Проблема полягає в тому, що програміст іноді забуває, що для порівняння відбувається неявний тип передачі (подвійний плавати), і це призводить до помилок.

Якщо число було прямо присвоєне поплавцю або подвійному, то можна перевірити проти нуля або будь-якого цілого числа, яке може бути представлене в 53 бітах для подвійного або 24 біта для поплавця.

Або кажучи іншим способом, ви завжди можете присвоїти ціле ціле числу подвійному, а потім порівняти подвійне назад з тим же цілим числом і гарантовано воно буде рівним.

Ви також можете почати, призначивши ціле число, і прості порівняння продовжують працювати, дотримуючись додавання, віднімання чи множення на цілі числа (якщо припустити, що результат становить менше 24 біт для поплавця і 53 53 біт на дубль). Таким чином, ви можете ставитися до поплавків і парних чисел як цілих чисел за певних контрольованих умов.

Ні, це не нормально. Так звані денормалізовані значення (субнормальні) при порівнянні дорівнюють 0,0, порівнюються як помилкові (ненульові), але при використанні в рівнянні нормалізуються (стають 0,0). Таким чином, використовувати це як механізм уникнення поділу на нуль не є безпечним. Натомість додайте 1,0 та порівняйте з 1,0. Це забезпечить, що всі субнормальні тварини трактуються як нульові.

Спробуйте це, і ви побачите, що == не є надійним для double / float.
double d = 0.1 + 0.2; bool b = d == 0.3;

Ось відповідь від Quora.

Насправді, я думаю, що краще використовувати наступні коди для порівняння подвійного значення проти 0,0:

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

Те саме для float:

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