Métodos System.Single.CompareTo

Este artigo fornece observações complementares à documentação de referência para essa API.

Os valores devem ser idênticos para serem considerados iguais. Particularmente quando os valores de ponto flutuante dependem de várias operações matemáticas, é comum que eles percam precisão e que seus valores sejam quase idênticos, exceto por seus dígitos menos significativos. Devido a isso, o valor de retorno do CompareTo método pode parecer surpreendente às vezes. Por exemplo, a multiplicação por um determinado valor seguida de divisão pelo mesmo valor deve produzir o valor original, mas no exemplo a seguir, o valor calculado acaba sendo maior do que o valor original. Mostrar todos os dígitos significativos dos dois valores usando a cadeia de caracteres de formato numérico padrão "R" indica que o valor calculado difere do valor original em seus dígitos menos significativos. Para obter informações sobre como lidar com essas comparações, consulte a seção Comentários do Equals(Single) método.

Embora um objeto cujo valor é não seja considerado igual a outro objeto cujo valor é NaNNaN (mesmo ele mesmo), a IComparable<T> interface requer que A.CompareTo(A) retorne zero.

CompareTo(System.Object)

O value parâmetro deve ser null ou uma instância de Single; caso contrário, uma exceção é lançada. Qualquer instância de , independentemente de Singleseu valor, é considerada maior que null.

using System;

public class Example
{
   public static void Main()
   {
       float value1 = 16.5457f;
       float operand = 3.8899982f;
       object value2 = value1 * operand / operand;
       Console.WriteLine("Comparing {0} and {1}: {2}\n",
                         value1, value2, value1.CompareTo(value2));
       Console.WriteLine("Comparing {0:R} and {1:R}: {2}",
                         value1, value2, value1.CompareTo(value2));
   }
}
// The example displays the following output:
//       Comparing 16.5457 and 16.5457: -1
//       
//       Comparing 16.5457 and 16.545702: -1

let value1 = 16.5457f
let operand = 3.8899982f
let value2 = box (value1 * operand / operand)
printfn $"Comparing {value1} and {value2}: {value1.CompareTo value2}\n"
printfn $"Comparing {value1:R} and {value2:R}: {value1.CompareTo value2}"
// The example displays the following output:
//       Comparing 16.5457 and 16.5457: -1
//       
//       Comparing 16.5457 and 16.545702: -1

Module Example2
    Public Sub Main()
        Dim value1 As Single = 16.5457
        Dim value2 As Object = value1 * CSng(3.8899982) / CSng(3.8899982)
        Console.WriteLine("Comparing {0} and {1}: {2}",
                          value1, value2, value1.CompareTo(value2))
        Console.WriteLine()
        Console.WriteLine("Comparing {0:R} and {1:R}: {2}",
                          value1, value2, value1.CompareTo(value2))
    End Sub
End Module
' The example displays the following output:
'       Comparing 16.5457 and 16.5457: -1
'       
'       Comparing 16.5457 and 16.545702: -1

Este método é implementado para suportar a IComparable interface.

CompareTo(System.Single)

Esse método implementa a interface e executa um pouco melhor do que a System.IComparable<T>Single.CompareTo(Object) sobrecarga porque não precisa converter o value parâmetro em um objeto.

using System;

public class Example2
{
   public static void Main()
   {
       float value1 = 16.5457f;
       float operand = 3.8899982f;
       float value2 = value1 * operand / operand;
       Console.WriteLine("Comparing {0} and {1}: {2}\n",
                         value1, value2, value1.CompareTo(value2));
       Console.WriteLine("Comparing {0:R} and {1:R}: {2}",
                         value1, value2, value1.CompareTo(value2));
   }
}
// The example displays the following output:
//       Comparing 16.5457 and 16.5457: -1
//       
//       Comparing 16.5457 and 16.545702: -1

let value1 = 16.5457f
let operand = 3.8899982f
let value2 = value1 * operand / operand
printfn $"Comparing {value1} and {value2}: {value1.CompareTo value2}\n"
printfn $"Comparing {value1:R} and {value2:R}: {value1.CompareTo value2}"
// The example displays the following output:
//       Comparing 16.5457 and 16.5457: -1
//       
//       Comparing 16.5457 and 16.545702: -1

Module Example
   Public Sub Main()
       Dim value1 As Single = 16.5457
       Dim value2 As Single = value1 * CSng(3.8899982) / CSng(3.8899982)
       Console.WriteLine("Comparing {0} and {1}: {2}",
                         value1, value2, value1.CompareTo(value2))
       Console.WriteLine()
       Console.WriteLine("Comparing {0:R} and {1:R}: {2}",
                         value1, value2, value1.CompareTo(value2))
   End Sub
End Module
' The example displays the following output:
'       Comparing 16.5457 and 16.5457: -1
'       
'       Comparing 16.5457 and 16.545702: -1

Conversões de expansão

Dependendo da linguagem de programação, talvez seja possível codificar um CompareTo método em que o tipo de parâmetro tem menos bits (é mais estreito) do que o tipo de instância. Isso é possível porque algumas linguagens de programação executam uma conversão de ampliação implícita que representa o parâmetro como um tipo com tantos bit quanto a instância.

Por exemplo, suponha que o tipo de instância seja Single e o tipo de parâmetro seja Int32. O compilador do Microsoft C# gera instruções para representar o valor do parâmetro como um objeto e, em seguida, gera um SingleSingle.CompareTo(Single) método que compara os valores da instância e a representação ampliada do parâmetro.

Consulte a documentação da linguagem de programação para determinar se o compilador executa conversões ampliadoras implícitas de tipos numéricos. Para obter mais informações, consulte o tópico Tabelas de conversão de tipo.

Precisão nas comparações

A precisão dos números de ponto flutuante além da precisão documentada é específica para a implementação e a versão do .NET. Consequentemente, uma comparação de dois números específicos pode mudar entre as versões do .NET porque a precisão da representação interna dos números pode mudar.