Métodos System.Double.CompareTo

2025-06-19

Este artigo fornece comentários complementares à documentação de referência para esta API.

método CompareTo(Double)

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 a precisão e que seus valores sejam quase idênticos, exceto por seus dígitos menos significativos. Por isso, o valor retornado do CompareTo método às vezes pode parecer surpreendente. Por exemplo, a multiplicação por um valor específico seguido pela divisão pelo mesmo valor deve produzir o valor original. No exemplo a seguir, no entanto, o valor computado acaba sendo maior 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(Double) método.

using System;

public class Example
{
    public static void Main()
    {
        double value1 = 6.185;
        double value2 = value1 * .1 / .1;
        Console.WriteLine($"Comparing {value1} and {value2}: {value1.CompareTo(value2)}{Environment.NewLine}");
        Console.WriteLine($"Comparing {value1:R} and {value2:R}: {value1.CompareTo(value2)}");
    }
}
// The example displays the following output:
//       Comparing 6.185 and 6.185: -1
//
//       Comparing 6.185 and 6.1850000000000005: -1

let value1 = 6.185
let value2 = value1 * 0.1 / 0.1
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 6.185 and 6.185: -1
//
//       Comparing 6.185 and 6.1850000000000005: -1

Module Example
   Public Sub Main()
       Dim value1 As Double = 6.185
       Dim value2 As Double = value1 * .1 / .1
       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 6.185 and 6.185: -1
'       
'       Comparing 6.185 and 6.1850000000000005: -1

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

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

método CompareTo(Object)

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

using System;

public class Example3
{
    public static void Main()
    {
        double value1 = 6.185;
        object value2 = value1 * .1 / .1;
        Console.WriteLine($"Comparing {value1} and {value2}: {value1.CompareTo(value2)}{Environment.NewLine}");
        Console.WriteLine($"Comparing {value1:R} and {value2:R}: {value1.CompareTo(value2)}");
    }
}
// The example displays the following output:
//       Comparing 6.185 and 6.185: -1
//
//       Comparing 6.185 and 6.1850000000000005: -1

let value1 = 6.185
let value2 = value1 * 0.1 / 0.1 |> box
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 6.185 and 6.185: -1
//
//       Comparing 6.185 and 6.1850000000000005: -1

Module Example2
   Public Sub Main()
       Dim value1 As Double = 6.185
       Dim value2 As Object = value1 * .1 / .1
       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 6.185 and 6.185: -1
'       
'       Comparing 6.185 and 6.1850000000000005: -1

Esse método é implementado para dar suporte à IComparable interface. Observe que, embora um NaN não seja considerado igual a outro NaN (mesmo ele mesmo), a IComparable interface requer que A.CompareTo(A) retorne zero.

Conversões de expansão

Dependendo da linguagem de programação, pode ser possível codificar um CompareTo método em que o tipo de parâmetro tenha 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 bits quanto a instância.

Por exemplo, suponha que o tipo de instância seja Double 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 Double objeto e, em seguida, gera um Double.CompareTo(Double) 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 implícitas de ampliação de tipos numéricos. Para obter mais informações, consulte o tópico Tabelas de Conversão de Tipos .

Precisão em comparações

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

Comentários

Esta página foi útil?