Single.NaN Campo

Referência

Definição

Namespace:: System

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Origem:: Single.cs

Origem:: Single.cs

Origem:: Single.cs

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

Representa algo que não é um número (NaN). Este campo é constante.

public: float NaN = NaN;

public const float NaN = NaN;

val mutable NaN : single

Public Const NaN As Single  = NaN

Valor do campo

Value = NaN

Single

Exemplos

O exemplo a seguir demonstra a NaN constante.

Single zero = 0;

// This condition will return false.
if ( (0 / zero) == Single::NaN )
{
   Console::WriteLine( "0 / 0 can be tested with Single::NaN." );
}
else
{
   Console::WriteLine( "0 / 0 cannot be tested with Single::NaN; use Single::IsNan() instead." );
}

Single zero = 0;

// This condition will return false.
if ((0 / zero) == Single.NaN)
{
    Console.WriteLine("0 / 0 can be tested with Single.NaN.");
}
else
{
    Console.WriteLine("0 / 0 cannot be tested with Single.NaN; use Single.IsNan() instead.");
}

let zero = 0f

// This condition will return false.
if 0f / zero = Single.NaN then
    printfn "0 / 0 can be tested with Single.NaN."
else
    printfn "0 / 0 cannot be tested with Single.NaN use Single.IsNan() instead."

Dim zero As Single = 0

' This condition will return false.
If (0 / zero) = Single.NaN Then
    Console.WriteLine("0 / 0 can be tested with Single.NaN.")
Else
    Console.WriteLine("0 / 0 cannot be tested with Single.NaN; use Single.IsNan() instead.")
End If

Comentários

Um método ou operador retorna NaN quando o resultado de uma operação é indefinido. Por exemplo, o resultado da divisão de zero por zero é NaN, como mostra o exemplo a seguir. (Mas observe que dividir um número diferente de zero por zero retorna PositiveInfinity ou NegativeInfinity, dependendo do sinal do divisor.)

float zero = 0.0f;
Console.WriteLine("{0} / {1} = {2}", zero, zero, zero/zero);
// The example displays the following output:
//         0 / 0 = NaN

let zero = 0f
printfn $"{zero} / {zero} = {zero / zero}"
// The example displays the following output:
//         0 / 0 = NaN

Dim zero As Single = 0
Console.WriteLine("{0} / {1} = {2}", zero, zero, zero/zero)
' The example displays the following output:
'         0 / 0 = NaN

Além disso, uma chamada de método com um NaN valor ou uma operação em um NaN valor retorna NaN, como mostra o exemplo a seguir.

float nan1 = Single.NaN;

Console.WriteLine("{0} + {1} = {2}", 3, nan1, 3 + nan1);
Console.WriteLine("Abs({0}) = {1}", nan1, Math.Abs(nan1));
// The example displays the following output:
//       3 + NaN = NaN
//       Abs(NaN) = NaN

let nan1 = Single.NaN

printfn $"{3} + {nan1} = {3f + nan1}"
printfn $"Abs({nan1}) = {abs nan1}"
// The example displays the following output:
//       3 + NaN = NaN
//       Abs(NaN) = NaN

Dim nan1 As Single = Single.NaN

Console.WriteLine("{0} + {1} = {2}", 3, nan1, 3 + nan1)
Console.WriteLine("Abs({0}) = {1}", nan1, Math.Abs(nan1))
' The example displays the following output:
'       3 + NaN = NaN
'       Abs(NaN) = NaN

Use o IsNaN método para determinar se um valor não é um número. Em geral, Single os operadores não podem ser usados para comparar Single.NaN com outros Single valores, embora métodos de comparação (como Equals e CompareTo) possam. O exemplo a seguir ilustra a diferença de comportamento entre Single operadores de comparação e métodos.

using System;

public class Example
{
   public static void Main()
   {
      Console.WriteLine("NaN == NaN: {0}", Single.NaN == Single.NaN); 
      Console.WriteLine("NaN != NaN: {0}", Single.NaN != Single.NaN); 
      Console.WriteLine("NaN.Equals(NaN): {0}", Single.NaN.Equals(Single.NaN)); 
      Console.WriteLine("! NaN.Equals(NaN): {0}", ! Single.NaN.Equals(Single.NaN)); 
      Console.WriteLine("IsNaN: {0}", Double.IsNaN(Double.NaN));
      
      Console.WriteLine("\nNaN > NaN: {0}", Single.NaN > Single.NaN); 
      Console.WriteLine("NaN >= NaN: {0}", Single.NaN >= Single.NaN); 
      Console.WriteLine("NaN < NaN: {0}", Single.NaN < Single.NaN);
      Console.WriteLine("NaN < 100.0: {0}", Single.NaN < 100.0f); 
      Console.WriteLine("NaN <= 100.0: {0}", Single.NaN <= 100.0f); 
      Console.WriteLine("NaN >= 100.0: {0}", Single.NaN > 100.0f);
      Console.WriteLine("NaN.CompareTo(NaN): {0}", Single.NaN.CompareTo(Single.NaN)); 
      Console.WriteLine("NaN.CompareTo(100.0): {0}", Single.NaN.CompareTo(100.0f)); 
      Console.WriteLine("(100.0).CompareTo(Single.NaN): {0}", (100.0f).CompareTo(Single.NaN)); 
   }
}
// The example displays the following output:
//       NaN == NaN: False
//       NaN != NaN: True
//       NaN.Equals(NaN): True
//       ! NaN.Equals(NaN): False
//       IsNaN: True
//
//       NaN > NaN: False
//       NaN >= NaN: False
//       NaN < NaN: False
//       NaN < 100.0: False
//       NaN <= 100.0: False
//       NaN >= 100.0: False
//       NaN.CompareTo(NaN): 0
//       NaN.CompareTo(100.0): -1
//       (100.0).CompareTo(Single.NaN): 1

open System

printfn $"NaN == NaN: {Single.NaN = Single.NaN}"
printfn $"NaN != NaN: {Single.NaN <> Single.NaN}"
printfn $"NaN.Equals(NaN): {Single.NaN.Equals Single.NaN}"
printfn $"! NaN.Equals(NaN): {not (Single.NaN.Equals Single.NaN)}"
printfn $"IsNaN: {Double.IsNaN Double.NaN}"

printfn $"\nNaN > NaN: {Single.NaN > Single.NaN}"
printfn $"NaN >= NaN: {Single.NaN >= Single.NaN}"
printfn $"NaN < NaN: {Single.NaN < Single.NaN}"
printfn $"NaN < 100.0: {Single.NaN < 100f}"
printfn $"NaN <= 100.0: {Single.NaN <= 100f}"
printfn $"NaN >= 100.0: {Single.NaN > 100f}"
printfn $"NaN.CompareTo(NaN): {Single.NaN.CompareTo Single.NaN}"
printfn $"NaN.CompareTo(100.0): {Single.NaN.CompareTo 100f}"
printfn $"(100.0).CompareTo(Single.NaN): {100f.CompareTo Single.NaN}"
// The example displays the following output:
//       NaN == NaN: False
//       NaN != NaN: True
//       NaN.Equals(NaN): True
//       ! NaN.Equals(NaN): False
//       IsNaN: True
//
//       NaN > NaN: False
//       NaN >= NaN: False
//       NaN < NaN: False
//       NaN < 100.0: False
//       NaN <= 100.0: False
//       NaN >= 100.0: False
//       NaN.CompareTo(NaN): 0
//       NaN.CompareTo(100.0): -1
//       (100.0).CompareTo(Single.NaN): 1

Module Example
   Public Sub Main()
      Console.WriteLine("NaN = NaN: {0}", Single.NaN = Single.NaN) 
      Console.WriteLine("NaN <> NaN: {0}", Single.NaN <> Single.NaN) 
      Console.WriteLine("NaN.Equals(NaN): {0}", Single.NaN.Equals(Single.NaN)) 
      Console.WriteLine("Not NaN.Equals(NaN): {0}", Not Single.NaN.Equals(Single.NaN)) 
      Console.WriteLine("IsNaN: {0}", Double.IsNaN(Double.NaN))
      Console.WriteLine()
      Console.WriteLine("NaN > NaN: {0}", Single.NaN > 100.0f) 
      Console.WriteLine("NaN >= NaN: {0}", Single.NaN >= 100.0f) 
      Console.WriteLine("NaN < NaN: {0}", Single.NaN < Single.NaN)
      Console.WriteLine("NaN < 100.0: {0}", Single.NaN < 100.0f) 
      Console.WriteLine("NaN <= 100.0: {0}", Single.NaN <= 100.0f) 
      Console.WriteLine("NaN >= 100.0: {0}", Single.NaN > 100.0f)
      Console.WriteLine("NaN.CompareTo(NaN): {0}", Single.NaN.CompareTo(Single.Nan)) 
      Console.WriteLine("NaN.CompareTo(100.0): {0}", Single.NaN.CompareTo(100.0f)) 
      Console.WriteLine("(100.0).CompareTo(Single.NaN): {0}", (100.0f).CompareTo(Single.NaN)) 
   End Sub
End Module
' The example displays the following output:
'       NaN == NaN: False
'       NaN != NaN: True
'       NaN.Equals(NaN): True
'       ! NaN.Equals(NaN): False
'       IsNaN: True
'
'       NaN > NaN: False
'       NaN >= NaN: False
'       NaN < NaN: False
'       NaN < 100.0: False
'       NaN <= 100.0: False
'       NaN >= 100.0: False
'       NaN.CompareTo(NaN): 0
'       NaN.CompareTo(100.0): -1
'       (100.0).CompareTo(Single.NaN): 1

Aplica-se a

Confira também

IsNaN(Single)

Compartilhar via