É seguro verificar os valores de ponto flutuante quanto à igualdade de 0?

Eu sei que você não pode confiar na igualdade entre valores de tipo duplo ou decimal normalmente, mas estou me perguntando se 0 é um caso especial.

Embora eu possa entender imprecisões entre 0,00000000000001 e 0,00000000000002, 0 em si parece muito difícil de errar, já que não é nada. Se você for impreciso sobre nada, não é mais nada.

Mas não sei muito sobre esse assunto, então não cabe a mim dizer.

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

Isso sempre retornará verdadeiro?

É seguro esperar que a comparação retornará truese e somente se a variável double tiver um valor de exatamente 0.0(que em seu trecho de código original é, obviamente, o caso). Isso é consistente com a semântica do ==operador. a == bsignifica " aé igual ab ".

Não é seguro (porque não é correto ) esperar que o resultado de algum cálculo seja zero em aritmética dupla (ou mais geralmente, ponto flutuante) sempre que o resultado do mesmo cálculo em matemática pura for zero. Isso ocorre porque quando os cálculos são feitos, o erro de precisão de ponto flutuante aparece - um conceito que não existe na aritmética de números reais na matemática.

Se você precisar fazer muitas comparações de "igualdade", pode ser uma boa ideia escrever uma pequena função auxiliar ou método de extensão no .NET 3.5 para comparar:

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

Isso pode ser usado da seguinte maneira:

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

Para sua amostra simples, esse teste está correto. Mas e quanto a isso:

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

Lembre-se de que .1 é um decimal repetido em binário e não pode ser representado exatamente. Em seguida, compare isso com este código:

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

Vou deixá-lo fazer um teste para ver os resultados reais: é mais provável que você se lembre dessa forma.

Na entrada MSDN para Double.Equals :

Precisão em comparações

O método Equals deve ser usado com cuidado, porque dois valores aparentemente equivalentes podem ser desiguais devido à precisão diferente dos dois valores. O exemplo a seguir relata que o valor de Double .3333 e o Double retornado pela divisão de 1 por 3 são desiguais.

...

Em vez de comparar por igualdade, uma técnica recomendada envolve a definição de uma margem aceitável de diferença entre dois valores (como 0,01% de um dos valores). Se o valor absoluto da diferença entre os dois valores for menor ou igual a essa margem, é provável que a diferença seja devido a diferenças na precisão e, portanto, os valores provavelmente serão iguais. O exemplo a seguir usa essa técnica para comparar 0,33333 e 1/3, os dois valores Double que o exemplo de código anterior considerou desiguais.

Além disso, consulte Double.Epsilon .

O problema surge quando você está comparando diferentes tipos de implementação de valor de ponto flutuante, por exemplo, comparando float com double. Mas com o mesmo tipo, não deve ser um problema.

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

O problema é que o programador às vezes esquece que a conversão de tipo implícito (double to float) está acontecendo para a comparação e isso resulta em um bug.

Se o número foi atribuído diretamente ao float ou double, então é seguro testar contra zero ou qualquer número inteiro que pode ser representado em 53 bits para um double ou 24 bits para um float.

Ou, colocando de outra forma, você sempre pode atribuir um valor inteiro a um duplo e, em seguida, comparar o duplo de volta ao mesmo inteiro e ter a garantia de que será igual.

Você também pode começar atribuindo um número inteiro e fazer comparações simples continuarem a funcionar, aderindo à adição, subtração ou multiplicação por números inteiros (assumindo que o resultado seja inferior a 24 bits para um float abd 53 bits para um duplo). Portanto, você pode tratar floats e doubles como inteiros sob certas condições controladas.

Não, não está bem. Os chamados valores desnormalizados (subnormais), quando comparados iguais a 0,0, seriam comparados como falsos (diferentes de zero), mas quando usados ​​em uma equação seriam normalizados (se tornariam 0,0). Portanto, usar isso como um mecanismo para evitar uma divisão por zero não é seguro. Em vez disso, adicione 1.0 e compare com 1.0. Isso garantirá que todos os subnormais sejam tratados como zero.

Tente isso e você descobrirá que == não é confiável para double / float.
double d = 0.1 + 0.2; bool b = d == 0.3;

Aqui está a resposta do Quora.

Na verdade, acho melhor usar os seguintes códigos para comparar um valor duplo com 0,0:

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

O mesmo para flutuador:

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