È sicuro controllare che i valori in virgola mobile siano uguali a 0?

So che normalmente non puoi fare affidamento sull'uguaglianza tra valori di tipo double o decimale, ma mi chiedo se 0 sia un caso speciale.

Anche se posso capire le imprecisioni tra 0,00000000000001 e 0,00000000000002, lo stesso 0 sembra piuttosto difficile da rovinare poiché non è niente. Se sei impreciso su niente, non è più niente.

Ma non so molto di questo argomento, quindi non sta a me dirlo.

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

Tornerà sempre vero?

E ' sicura di aspettarsi che il confronto tornerà truese e solo se la doppia variabile ha un valore di esattamente 0.0(che nel frammento di codice originale è, ovviamente, il caso). Ciò è coerente con la semantica ==dell'operatore. a == bsignifica " aè uguale a b".

Non è sicuro (perché non è corretto ) aspettarsi che il risultato di un calcolo sia zero nell'aritmetica doppia (o più in generale, virgola mobile) ogni volta che il risultato dello stesso calcolo in matematica pura è zero. Questo perché quando i calcoli vengono a galla, appare un errore di precisione in virgola mobile, un concetto che non esiste nell'aritmetica dei numeri reali in matematica.

Se hai bisogno di fare molti confronti di "uguaglianza", potrebbe essere una buona idea scrivere una piccola funzione di supporto o un metodo di estensione in .NET 3.5 per confrontare:

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

Questo potrebbe essere usato nel modo seguente:

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

Per il tuo semplice campione, quel test va bene. Ma che dire di questo:

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

Ricorda che .1 è un decimale ripetuto in binario e non può essere rappresentato esattamente. Quindi confrontalo con questo codice:

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

Ti lascio eseguire un test per vedere i risultati effettivi: è più probabile che tu lo ricordi in questo modo.

Dalla voce MSDN per Double.Equals :

Precisione nei confronti

Il metodo Equals deve essere utilizzato con cautela, poiché due valori apparentemente equivalenti possono essere disuguali a causa della diversa precisione dei due valori. L'esempio seguente riporta che il valore Double .3333 e il Double restituito dividendo 1 per 3 non sono uguali.

...

Piuttosto che confrontare per l'uguaglianza, una tecnica consigliata implica la definizione di un margine di differenza accettabile tra due valori (come lo 0,01% di uno dei valori). Se il valore assoluto della differenza tra i due valori è inferiore o uguale a tale margine, è probabile che la differenza sia dovuta a differenze di precisione e, pertanto, è probabile che i valori siano uguali. Nell'esempio seguente viene utilizzata questa tecnica per confrontare .33333 e 1/3, i due valori Double che nell'esempio di codice precedente erano diversi.

Inoltre, vedere Double.Epsilon .

Il problema nasce quando si confrontano diversi tipi di implementazione di valori in virgola mobile, ad esempio confrontando float con double. Ma con lo stesso tipo, non dovrebbe essere un problema.

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

Il problema è che il programmatore a volte dimentica che il cast di tipo implicito (double to float) sta accadendo per il confronto e il risultato è un bug.

Se il numero è stato assegnato direttamente al float o al double, allora è sicuro testare contro zero o qualsiasi numero intero che può essere rappresentato in 53 bit per un double o 24 bit per un float.

O, in altre parole, puoi sempre assegnare un valore intero a un double e quindi confrontare il double con lo stesso numero intero e ti verrà garantito che sarà uguale.

Puoi anche iniziare assegnando un numero intero e fare in modo che semplici confronti continuino a funzionare attenendoti all'aggiunta, alla sottrazione o alla moltiplicazione per numeri interi (supponendo che il risultato sia inferiore a 24 bit per un float e 53 bit per un doppio). Quindi puoi trattare float e raddoppia come numeri interi in determinate condizioni controllate.

No, non va bene. I cosiddetti valori denormalizzati (subnormali), se paragonati a 0,0, sarebbero falsi (diversi da zero), ma se usati in un'equazione sarebbero normalizzati (diventerebbero 0,0). Pertanto, l'utilizzo di questo come meccanismo per evitare una divisione per zero non è sicuro. Aggiungere invece 1.0 e confrontare con 1.0. Ciò garantirà che tutti i subnormali vengano trattati come zero.

Prova questo e scoprirai che == non è affidabile per double / float.
double d = 0.1 + 0.2; bool b = d == 0.3;

Ecco la risposta di Quora.

In realtà, penso che sia meglio usare i seguenti codici per confrontare un valore doppio con 0,0:

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

Lo stesso per float:

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