Métodos System.Double.CompareTo

Observação

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

CompareTo(Double) método

Os valores devem ser idênticos para serem considerados iguais. Particularmente quando os valores de vírgula flutuante dependem de múltiplas operações matemáticas, é comum que percam precisão e que seus valores sejam quase idênticos, exceto por seus dígitos menos significativos. Por causa disso, 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 {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 ele não precisa converter o value parâmetro em um objeto.

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

CompareTo(Object) método

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 Double, independentemente do 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

Este método é implementado para suportar a IComparable interface. Observe que, embora um NaN não seja considerado igual a outro NaN (nem mesmo a si próprio), a interface IComparable exige que A.CompareTo(A) retorne zero.

Ampliando as conversões

Dependendo da sua linguagem de programação, pode ser 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 bits quanto a instância.

Por exemplo, suponha que o tipo de instância é Double e o tipo de parâmetro é Int32. O compilador 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 sua 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 tipo .

Precisão nas comparações

A precisão dos números de ponto flutuante, além da precisão documentada, depende da implementação e 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?

Last updated on 2024-01-30