Perché double.NaN non è uguale a se stesso?

Question

Qualcuno può spiegarmi questo? In C# Double.NaN non è uguale a Double.NaN

bool huh = double.NaN == double.NaN; // huh = false 
bool huh2 = double.NaN >= 0; // huh2 = false 
bool huh3 = double.NaN <= 0; // huh3 = false 

Cosa costante posso paragonare a una Double.NaN e ottenere vero?

Answer 1

Se siete curiosi, questo è ciò che appare come Double.IsNaN:

public static bool IsNaN(double d) 
{ 
    return (d != d); 
} 

Funky, eh?

Answer 2

Utilizzare .

Answer 3

bool isNaN = Double.IsNaN(yourNumber) 

Answer 4

C'è una funzione specializzata per questo:

double.IsNan(huh); 

Answer 5

Utilizzare il metodo "Double.IsNaN (valore)" per verificare questa condizione.

Answer 6

Utilizzare Double.IsNan() per verificare l'uguaglianza qui. Il motivo è che NaN non è un numero.

Answer 7

Il comportamento è di proposito. Il motivo per cui NaN rappresenta qualcosa che non è un numero e quindi è una specie di catch-all per molte cose.

Il modo corretto per confrontare qualcosa con NaN è utilizzare la funzione IsNaN.

Answer 8

In realtà, è già trovato il modo per verificare se un numero a virgola mobile IEEE-754 è NaN: è l'unico valore in virgola mobile (o intervallo di valori, perché ci sono diversi NaNs) che restituisce False rispetto a stesso, ovvero:

bool isNaN(double v) { 
    return v != v; 
} 

Sotto il cofano, il metodo Double.IsNaN potrebbe effettivamente fare la stessa cosa. Dovresti comunque usarlo, perché il comportamento è abbastanza sorprendente per chiunque non conosca lo standard FP.

Answer 9

L'unica cosa che sappiamo di NaN è che è "Not a Number". Ciò non significa che abbia un valore associabile al suo stato. Per esempio:

∞ + (- ∞) = NaN

0/0 = NaN

(∞ + (- ∞)) <> (0/0)

Ecco qualche C# per dimostrare

var infinity = 100d/0; 
var negInfinity = -100d/0; 

var notANumber = infinity + negInfinity; 
Console.WriteLine("Negative Infinity plus Infinity is NaN: {0}", double.IsNaN(notANumber)); 

var notANumber2 = 0d/0d; 
Console.WriteLine("Zero divided by Zero is NaN: {0}", double.IsNaN(notANumber2)); 

Console.WriteLine("These two are not equal: {0}", notANumber == notANumber2); 

Answer 10

Il motivo di Double.NaN != Double.NaN è simple:

Ti aspetti che lo 0/0 sia lo stesso di Math.Sqrt(-3)? E lo stesso di Math.Sqrt(-7)?

C'è un errore in C# a mio avviso, dove Equals() non è sovrascritto per NaN.

Assert.IsTrue(Double.NaN != Double.NaN); 
Assert.IsTrue(Double.NaN.Equals(Double.NaN)); 

Contemporaneamente

Assert.IsTrue(Double.PositiveInfinity == Double.NegativeInfinity); 
Assert.IsTrue(Double.PositiveInfinity.Equals(Double.PositiveInfinity)); 
// same for Double.NegativeInfinity and Single 

Usa funzioni statiche per Double e Single, ad esempio

Double.IsNaN(value) && Double.IsInfinity(value); 

o più specifiche:

Double.IsPositiveInfinity(value); 
Double.IsNegativeInfinity(value); 

Answer 11

l'operatore di uguaglianza considera due valori NaN di essere diverso da un altro. In generale, non è possibile utilizzare Double operator per confrontare Double.NaN con altri valori Double, sebbene i metodi di confronto (come uguale a e CompareTo) possano. vedi sotto esempi

referenziati da msdn

class Program 
{ 
    static void Main(string[] args) 
    { 
     Double i = Double.NaN; 
     while (!i.Equals(i)) //this would be result in false 
     //while(i != i) // this would result in true. 
     { 
      Console.WriteLine("Hello"); 
     } 
    } 
} 

here è .net violino per lo stesso.