Безопасно ли е да проверявате стойностите с плаваща запетая за равенство на 0?

Безопасно е да очаквате, че сравнението ще върне 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 е повтарящ се десетичен знак в двоична система и не може да бъде представен точно, същото като да се опитвате да напишете 1/3 като десетичен знак с основа 10. Сега сравнете това с този код:

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:

Прецизност в сравненията

Методът Equals трябва да се използва с повишено внимание, тъй като две привидно еквивалентни стойности може да не са равни поради различната точност на двете стойности. Следващият пример съобщава, че стойността Double .3333 и Double, върнати чрез разделяне на 1 на 3, са неравни.

...

Вместо да се сравнява за равенство, една препоръчителна техника включва определяне на приемлива разлика между две стойности (като 0,01% от една от стойностите). Ако абсолютната стойност на разликата между двете стойности е по-малка или равна на тази граница, разликата вероятно се дължи на разлики в прецизността и следователно стойностите вероятно са равни. Следващият пример използва тази техника за сравняване на .33333 и 1/3, двете стойности на Double, за които предишният пример с код установи, че са неравни.

Вижте също Double.Epsilon.

Проблемът идва, когато сравнявате различни видове имплементация на стойност с плаваща запетая, напр. сравняване на float с double. Но със същия тип не би трябвало да е проблем.

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

Проблемът е, че програмистът понякога забравя, че неявното преобразуване на типа (double to float) се случва за сравнението и това води до грешка.

Ако числото е директно присвоено на float или double, тогава е безопасно да се тества срещу нула или всяко цяло число, което може да бъде представено в 53 бита за double или 24 бита за float.

Или казано по друг начин, винаги можете да присвоите и цяло число на двойно и след това да сравните двойното обратно със същото цяло число и да сте сигурни, че ще бъде равно.

Можете също така да започнете, като зададете цяло число и простите сравнения да продължат да работят, като се придържате към добавяне, изваждане или умножение с цели числа (ако приемем, че резултатът е по-малък от 24 бита за число с плаваща единица и 53 бита за двойно). Така че можете да третирате float и double като цели числа при определени контролирани условия.

Не, не е наред. Така наречените денормализирани стойности (субнормални), когато се сравняват, равни на 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;