Métodos System.Double.CompareTo

Artigo
01/30/2024

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

Método CompareTo(Double)

Os valores devem ser idênticos para serem considerados iguais. Particularmente quando os valores de ponto flutuante dependem de múltiplas 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 às vezes pode parecer surpreendente. Por exemplo, a multiplicação por um determinado valor seguida de divisão pelo mesmo valor deve produzir o valor original. No exemplo a seguir, no entanto, 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(Double) método.

using System;

public class Example
{
    public static void Main()
    {
        double value1 = 6.185;
        double value2 = value1 * .1 / .1;
        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 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 método porque ele não precisa converter o valueDouble.CompareTo parâmetro em um objeto.

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

Método CompareTo(Object)

O value parâmetro deve ser null ou uma instância de Double; caso contrário, uma exceção é lançada. Qualquer instância de , independentemente de Doubleseu 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 {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 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

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

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 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 objeto e, em seguida, gera um Double 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 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.

Compartilhar via

Métodos System.Double.CompareTo

Método CompareTo(Double)

Método CompareTo(Object)

Conversões de expansão

Precisão nas comparações

Recursos adicionais