Méthodes System.Single.CompareTo

Cet article vous offre des remarques complémentaires à la documentation de référence pour cette API.

Les valeurs doivent être identiques pour être considérées comme égales. En particulier, lorsque les valeurs à virgule flottante dépendent de plusieurs opérations mathématiques, il est courant qu’elles perdent de la précision et que leurs valeurs soient presque identiques, à l’exception de leurs chiffres les moins significatifs. En raison de cela, la valeur de retour de la CompareTo méthode peut sembler surprenante à certains moments. Par exemple, la multiplication par une valeur particulière suivie d’une division par la même valeur doit produire la valeur d’origine, mais dans l’exemple suivant, la valeur calculée s’avère supérieure à la valeur d’origine. L’affichage de tous les chiffres significatifs des deux valeurs à l’aide de la chaîne de format numérique standard « R » indique que la valeur calculée diffère de la valeur d’origine dans ses chiffres les moins significatifs. Pour plus d’informations sur la gestion de ces comparaisons, consultez la section Notes de la Equals(Single) méthode.

Bien qu’un objet dont la valeur n’est NaN pas considérée comme égale à un autre objet dont la valeur est NaN (même elle-même), l’interface IComparable<T> requiert ce A.CompareTo(A) retour zéro.

CompareTo(System.Object)

Le value paramètre doit être null ou une instance de Single; sinon, une exception est levée. Toute instance de Single, quelle que soit sa valeur, est considérée comme supérieure à 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

Cette méthode est implémentée pour prendre en charge l’interface IComparable .

CompareTo(System.Single)

Cette méthode implémente l’interface System.IComparable<T> et effectue légèrement mieux que la Single.CompareTo(Object) surcharge, car elle n’a pas besoin de convertir le value paramètre en objet.

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

Conversions étendues

Selon votre langage de programmation, il peut être possible de coder une CompareTo méthode où le type de paramètre a moins de bits (est plus étroit) que le type d’instance. Cela est possible, car certains langages de programmation effectuent une conversion étendue implicite qui représente le paramètre en tant que type avec autant de bits que l’instance.

Par exemple, supposons que le type d’instance soit Single et que le type de paramètre soit Int32. Le compilateur Microsoft C# génère des instructions pour représenter la valeur du paramètre en tant qu’objet Single , puis génère une Single.CompareTo(Single) méthode qui compare les valeurs de l’instance et la représentation étendue du paramètre.

Consultez la documentation de votre langage de programmation pour déterminer si son compilateur effectue des conversions étendues implicites de types numériques. Pour plus d’informations, consultez la rubrique Tables de conversion de type.

Précision dans les comparaisons

La précision des nombres à virgule flottante au-delà de la précision documentée est spécifique à l’implémentation et à la version de .NET. Par conséquent, une comparaison de deux nombres particuliers peut changer entre les versions de .NET, car la précision de la représentation interne des nombres peut changer.