Condividi tramite

Metodi System.Double.CompareTo

  • Articolo

Questo articolo fornisce osservazioni supplementari alla documentazione di riferimento per questa API.

Metodo CompareTo(Double)

I valori devono essere identici per essere considerati uguali. In particolare, quando i valori a virgola mobile dipendono da più operazioni matematiche, è comune perdere precisione e per i relativi valori essere quasi identici, ad eccezione delle cifre meno significative. Per questo motivo, il valore restituito del CompareTo metodo a volte può sembrare sorprendente. Ad esempio, la moltiplicazione per un determinato valore seguito dalla divisione per lo stesso valore deve produrre il valore originale. Nell'esempio seguente, tuttavia, il valore calcolato risulta essere maggiore del valore originale. La visualizzazione di tutte le cifre significative dei due valori tramite la stringa di formato numerico standard "R" indica che il valore calcolato differisce dal valore originale nelle cifre meno significative. Per informazioni sulla gestione di tali confronti, vedere la sezione Osservazioni del Equals(Double) metodo .

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

Questo metodo implementa l'interfaccia System.IComparable<T> ed esegue prestazioni leggermente migliori rispetto al Double.CompareTo metodo perché non deve convertire il value parametro in un oggetto .

Si noti che, anche se un oggetto il cui valore non è NaN considerato uguale a un altro oggetto il cui valore è NaN (anche se stesso), l'interfaccia IComparable<T> richiede che restituisca A.CompareTo(A) zero.

Metodo CompareTo(Object)

Il value parametro deve essere null o un'istanza di Double; in caso contrario, viene generata un'eccezione. Qualsiasi istanza di Double, indipendentemente dal relativo valore, viene considerata maggiore di null.

I valori devono essere identici per essere considerati uguali. In particolare, quando i valori a virgola mobile dipendono da più operazioni matematiche, è comune perdere precisione e per i relativi valori essere quasi identici, ad eccezione delle cifre meno significative. Per questo motivo, il valore restituito del CompareTo metodo a volte può sembrare sorprendente. Ad esempio, la moltiplicazione per un determinato valore seguito dalla divisione per lo stesso valore deve produrre il valore originale. Nell'esempio seguente, tuttavia, il valore calcolato risulta essere maggiore del valore originale. La visualizzazione di tutte le cifre significative dei due valori tramite la stringa di formato numerico standard "R" indica che il valore calcolato differisce dal valore originale nelle cifre meno significative. Per informazioni sulla gestione di tali confronti, vedere la sezione Osservazioni del Equals(Double) metodo .

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

Questo metodo viene implementato per supportare l'interfaccia IComparable . Si noti che, anche se un NaN oggetto non è considerato uguale a un altro NaN (anche se stesso), l'interfaccia IComparable richiede che restituisca A.CompareTo(A) zero.

Conversioni di estensione

A seconda del linguaggio di programmazione, potrebbe essere possibile codificare un CompareTo metodo in cui il tipo di parametro ha meno bit (è più piccolo) rispetto al tipo di istanza. Ciò è possibile perché alcuni linguaggi di programmazione eseguono una conversione implicita di estensione che rappresenta il parametro come tipo con il maggior numero di bit dell'istanza.

Si supponga, ad esempio, che il tipo di istanza sia Double e che il tipo di parametro sia Int32. Il compilatore Microsoft C# genera istruzioni per rappresentare il valore del parametro come Double oggetto, quindi genera un Double.CompareTo(Double) metodo che confronta i valori dell'istanza e la rappresentazione estesa del parametro.

Consultare la documentazione del linguaggio di programmazione per determinare se il compilatore esegue conversioni implicite di tipi numerici verso l'ampliamento. Per altre informazioni, vedere l'argomento Tabelle di conversione dei tipi.

Precisione nei confronti

La precisione dei numeri a virgola mobile oltre la precisione documentata è specifica per l'implementazione e la versione di .NET. Di conseguenza, un confronto di due numeri particolari potrebbe cambiare tra le versioni di .NET perché la precisione della rappresentazione interna dei numeri potrebbe cambiare.