Cet article a fait l'objet d'une traduction manuelle. Déplacez votre pointeur sur les phrases de l'article pour voir la version originale de ce texte. |
Traduction
Source
|
Double, structure
Représente un nombre à virgule flottante double précision.
Assembly : mscorlib (dans mscorlib.dll)
Le type Double expose les membres suivants.
| Nom | Description | |
|---|---|---|
|
CompareTo(Double) | Compare cette instance à un nombre à virgule flottante double précision spécifié et retourne un entier qui indique si la valeur de cette instance est inférieure, égale ou supérieure à celle du nombre à virgule flottante double précision spécifié. |
|
CompareTo(Object) | Compare cette instance à un objet spécifié et retourne un entier qui indique si la valeur de cette instance est inférieure, égale ou supérieure à la valeur de l'objet spécifié. |
|
Equals(Double) | Retourne une valeur indiquant si cette instance et un objet Double spécifié représentent la même valeur. |
|
Equals(Object) | Retourne une valeur indiquant si cette instance est égale à un objet spécifié. (Substitue ValueType.Equals(Object).) |
|
Finalize | Autorise un objet à tenter de libérer des ressources et d'exécuter d'autres opérations de netto***ge avant qu'il ne soit récupéré par l'opération garbage collection. (Hérité de Object.) |
|
GetHashCode | Retourne le code de hachage pour cette instance. (Substitue ValueType.GetHashCode().) |
|
GetType | Obtient le Type de l'instance actuelle. (Hérité de Object.) |
|
GetTypeCode | Retourne le TypeCode du type valeur Double. |
|
IsInfinity | Retourne une valeur indiquant si le nombre spécifié a pour valeur l'infini négatif ou positif. |
|
IsNaN | Retourne une valeur indiquant si le nombre spécifié a une valeur qui n'est pas un nombre (NaN). |
|
IsNegativeInfinity | Retourne une valeur indiquant si le nombre spécifié est équivalent à moins l'infini. |
|
IsPositiveInfinity | Retourne une valeur indiquant si le nombre spécifié est équivalent à plus l'infini. |
|
MemberwiseClone | Crée une copie superficielle de l'objet Object actif. (Hérité de Object.) |
|
Parse(String) | Convertit la représentation sous forme de chaîne d'un nombre en nombre à virgule flottante double précision équivalent. |
|
Parse(String, NumberStyles) | Convertit la représentation sous forme de chaîne d'un nombre dans un style spécifié en nombre à virgule flottante double précision équivalent. |
|
Parse(String, IFormatProvider) | Convertit la représentation sous forme de chaîne d'un nombre dans un format propre à la culture spécifié en nombre à virgule flottante double précision équivalent. |
|
Parse(String, NumberStyles, IFormatProvider) | Convertit la représentation sous forme de chaîne d'un nombre dans un style et un format propre à la culture spécifiés en nombre à virgule flottante double précision équivalent. |
|
ToString() | Convertit la valeur numérique de cette instance en sa représentation équivalente sous forme de chaîne. (Substitue ValueType.ToString().) |
|
ToString(IFormatProvider) | Convertit la valeur numérique de cette instance en sa représentation sous forme de chaîne équivalente à l'aide des informations de format spécifiques à la culture donnée. |
|
ToString(String) | Convertit la valeur numérique de cette instance en sa représentation sous forme de chaîne équivalente en utilisant le format spécifié. |
|
ToString(String, IFormatProvider) | Convertit la valeur numérique de cette instance en sa représentation sous forme de chaîne équivalente à l'aide de la mise en forme spécifiée et des informations de mise en forme spécifiques à la culture. |
|
TryParse(String, Double) | Convertit la représentation sous forme de chaîne d'un nombre en nombre à virgule flottante double précision équivalent. Une valeur de retour indique si la conversion a réussi ou a échoué. |
|
TryParse(String, NumberStyles, IFormatProvider, Double) | Convertit la représentation sous forme de chaîne d'un nombre dans un style et un format propre à la culture spécifiés en nombre à virgule flottante double précision équivalent. Une valeur de retour indique si la conversion a réussi ou a échoué. |
| Nom | Description | |
|---|---|---|
|
Equality | Retourne une valeur qui indique si deux valeurs Double spécifiées sont égales. |
|
GreaterThan | Retourne une valeur qui indique si une valeur Double spécifique est supérieure à une autre valeur Double spécifique. |
|
GreaterThanOrEqual | Retourne une valeur qui indique si une valeur Double spécifique est supérieure ou égale à une autre valeur Double spécifique. |
|
Inequality | Retourne une valeur qui indique si deux valeurs Double spécifiées sont différentes. |
|
LessThan | Retourne une valeur qui indique si une valeur Double spécifiée est inférieure à une autre valeur Double spécifiée. |
|
LessThanOrEqual | Retourne une valeur qui indique si une valeur Double spécifique est inférieure ou égale à une autre valeur Double spécifique. |
| Nom | Description | |
|---|---|---|
|
Epsilon | Représente la valeur Double positive la plus petite qui est supérieure à zéro. Ce champ est constant. |
|
MaxValue | Représente la plus grande valeur possible de Double. Ce champ est constant. |
|
MinValue | Représente la plus petite valeur possible de Double. Ce champ est constant. |
|
NaN | Représente une valeur qui n'est pas un nombre (NaN). Ce champ est constant. |
|
NegativeInfinity | Représente l'infini négatif. Ce champ est constant. |
|
PositiveInfinity | Représente l'infini positif. Ce champ est constant. |
| Nom | Description | |
|---|---|---|
|
IConvertible.ToBoolean | Infrastructure. Pour obtenir une description de ce membre, consultez IConvertible.ToBoolean. |
|
IConvertible.ToByte | Infrastructure. Pour une description de ce membre, consultez IConvertible.ToByte. |
|
IConvertible.ToChar | Infrastructure. Cette conversion n'est pas prise en charge. Toute tentative d'utilisation de cette méthode lève un InvalidCastException. |
|
IConvertible.ToDateTime | Infrastructure. Cette conversion n'est pas prise en charge. Toute tentative d'utilisation de cette méthode lève un InvalidCastException. |
|
IConvertible.ToDecimal | Infrastructure. Pour obtenir une description de ce membre, consultez IConvertible.ToDecimal. |
|
IConvertible.ToDouble | Infrastructure. Pour obtenir une description de ce membre, consultez IConvertible.ToDouble. |
|
IConvertible.ToInt16 | Infrastructure. Pour une description de ce membre, consultez IConvertible.ToInt16. |
|
IConvertible.ToInt32 | Infrastructure. Pour une description de ce membre, consultez IConvertible.ToInt32. |
|
IConvertible.ToInt64 | Infrastructure. Pour une description de ce membre, consultez IConvertible.ToInt64. |
|
IConvertible.ToSByte | Infrastructure. Pour une description de ce membre, consultez IConvertible.ToSByte. |
|
IConvertible.ToSingle | Infrastructure. Pour obtenir une description de ce membre, consultez IConvertible.ToSingle. |
|
IConvertible.ToType | Infrastructure. Pour une description de ce membre, consultez IConvertible.ToType. |
|
IConvertible.ToUInt16 | Infrastructure. Pour une description de ce membre, consultez IConvertible.ToUInt16. |
|
IConvertible.ToUInt32 | Infrastructure. Pour une description de ce membre, consultez IConvertible.ToUInt32. |
|
IConvertible.ToUInt64 | Infrastructure. Pour une description de ce membre, consultez IConvertible.ToUInt64. |
Le type valeur Double représente un nombre 64 bits double précision dont les valeurs varient de moins 1,79769313486232e308 à plus 1,79769313486232e308, de plus zéro à moins zéro, PositiveInfinity, NegativeInfinity ou ne sont pas numériques (Not-A-Number) (NaN).
Double est conforme à la norme IEC 60559:1989 (IEEE 754) d'arithmétique binaire à virgule flottante.
Double fournit les méthodes permettant de comparer les instances de ce type, de convertir la valeur d'une instance en sa représentation sous forme de chaîne et de convertir la représentation sous forme de chaîne d'un nombre en instance de ce type. Pour plus d'informations sur la façon dont les codes de spécification de format contrôlent la représentation sous forme de chaîne des types valeur, consultez Mise en forme des types, Chaînes de format numériques standard et Chaînes de format numériques personnalisées.
Utilisation de nombres à virgule flottante
Si au cours d'opérations binaires, l'un des opérandes est Double, l'autre opérande doit alors être de type intégral ou de type virgule flottante (Double ou Single). Si, avant d'effectuer l'opération, l'autre opérande n'est pas Double, il est alors converti en Double et l'opération est effectuée à l'aide d'au moins une précision et une plage Double. Si l'opération donne un résultat numérique, le type de ce résultat est alors Double.
Les opérateurs à virgule flottante, y compris les opérateurs d'assignation, ne lèvent pas d'exceptions. Dans des cas exceptionnels, le résultat d'une opération en virgule flottante est zéro, infini ou NaN, comme indiqué ci-dessous :
-
Si le résultat d'une opération en virgule flottante est trop petit pour le format de destination, le résultat de l'opération est alors zéro.
-
Si le résultat d'une opération en virgule flottante est trop grand pour le format de destination, le résultat de l'opération est alors PositiveInfinity ou NegativeInfinity, en fonction du signe du résultat.
-
Si une opération en virgule flottante n'est pas valide, le résultat de l'opération est alors NaN.
-
Si un ou deux opérandes d'une opération en virgule flottante sont NaN, le résultat de l'opération est alors NaN.
Valeurs à virgule flottante et perte de précision
Souvenez-vous qu'un nombre à virgule flottante ne peut se rapprocher qu'approximativement d'un nombre décimal, et que la précision d'un nombre à virgule flottante détermine dans quelle mesure il se rapproche d'un nombre décimal. Même si 17 chiffres maximum sont gérés en interne, la précision de la valeur Double ne comporte par défaut que 15 chiffres décimaux. La précision d'un nombre à virgule flottante a plusieurs conséquences :
-
Deux nombres à virgule flottante qui apparaissent égaux à un niveau de précision particulier peuvent ne pas être égaux parce que leurs chiffres les moins significatifs sont différents.
-
Une opération mathématique ou de comparaison qui utilise un nombre à virgule flottante peut pas avoir le même résultat si un nombre décimal est utilisé, car le nombre à virgule flottante peut ne pas se rapprocher exactement du nombre décimal.
-
Une valeur peut ne pas effectuer un aller-retour si un nombre à virgule flottante est impliqué. Une valeur est décrite comme effectuant un aller-retour si une opération convertit un nombre à virgule flottante d'origine dans une autre forme, si une opération inverse transforme la forme convertie en nombre à virgule flottante, et si le dernier nombre à virgule flottante est égal au nombre à virgule flottante d'origine. L'aller-retour peut échouer parce qu'un ou plusieurs chiffres moins significatifs sont perdus ou modifiés au cours d'une conversion.
De plus, le résultat des opérations arithmétiques et d'assignation avec les valeurs Double peut varier légèrement en fonction de la plateforme en raison de la perte de précision du type Double. Par exemple, le résultat de l'assignation d'une valeur Double littérale peut différer dans les versions 32 bits et 64 bits du .NET Framework. L'exemple suivant illustre cette différence lorsque la valeur littérale -4,42330604244772E-305 et une variable dont la valeur est -4,42330604244772E-305 sont assignées à une variable Double. Notez que le résultat de la méthode Parse(String) dans ce cas ne souffre pas d'une perte de précision.
double value = -4.42330604244772E-305; double fromLiteral = -4.42330604244772E-305; double fromVariable = value; double fromParse = Double.Parse("-4.42330604244772E-305"); Console.WriteLine("Double value from literal: {0,29:R}", fromLiteral); Console.WriteLine("Double value from variable: {0,28:R}", fromVariable); Console.WriteLine("Double value from Parse method: {0,24:R}", fromParse); // On 32-bit versions of the .NET Framework, the output is: // Double value from literal: -4.42330604244772E-305 // Double value from variable: -4.42330604244772E-305 // Double value from Parse method: -4.42330604244772E-305 // // On other versions of the .NET Framework, the output is: // Double value from literal: -4.4233060424477198E-305 // Double value from variable: -4.4233060424477198E-305 // Double value from Parse method: -4.42330604244772E-305
L'exemple de code suivant montre comment utiliser Double :
/// <summary> /// Temperature class stores the value as Double /// and delegates most of the functionality /// to the Double implementation. /// </summary> public class Temperature : IComparable, IFormattable { /// <summary> /// IComparable.CompareTo implementation. /// </summary> public int CompareTo(object obj) { if(obj is Temperature) { Temperature temp = (Temperature) obj; return m_value.CompareTo(temp.m_value); } throw new ArgumentException("object is not a Temperature"); } /// <summary> /// IFormattable.ToString implementation. /// </summary> public string ToString(string format, IFormatProvider provider) { if( format != null ) { if( format.Equals("F") ) { return String.Format("{0}'F", this.Value.ToString()); } if( format.Equals("C") ) { return String.Format("{0}'C", this.Celsius.ToString()); } } return m_value.ToString(format, provider); } /// <summary> /// Parses the temperature from a string in form /// [ws][sign]digits['F|'C][ws] /// </summary> public static Temperature Parse(string s, NumberStyles styles, IFormatProvider provider) { Temperature temp = new Temperature(); if( s.TrimEnd(null).EndsWith("'F") ) { temp.Value = Double.Parse( s.Remove(s.LastIndexOf('\''), 2), styles, provider); } else if( s.TrimEnd(null).EndsWith("'C") ) { temp.Celsius = Double.Parse( s.Remove(s.LastIndexOf('\''), 2), styles, provider); } else { temp.Value = Double.Parse(s, styles, provider); } return temp; } // The value holder protected double m_value; public double Value { get { return m_value; } set { m_value = value; } } public double Celsius { get { return (m_value-32.0)/1.8; } set { m_value = 1.8*value+32.0; } } }
Windows 7, Windows Vista SP1 ou ultérieur, Windows XP SP3, Windows XP SP2 Édition x64, Windows Server 2008 (installation minimale non prise en charge), Windows Server 2008 R2 (installation minimale prise en charge avec SP1 ou version ultérieure), Windows Server 2003 SP2
Le .NET Framework ne prend pas en charge toutes les versions de chaque plateforme. Pour obtenir la liste des versions prises en charge, consultez Configuration requise du .NET Framework.
Tous les membres de ce type sont thread-safe. Les membres qui semblent modifier l'instance d'état retournent, en réalité, une nouvelle instance initialisée avec la nouvelle valeur. Comme avec tout autre type, la lecture et l'écriture sur une variable partagée qui contient une instance de ce type doivent être protégées par un verrou pour garantir la sécurité des threads.
Attention
|
|---|
|
L'assignation d'une instance de ce type n'est pas thread-safe sur toutes les plateformes matérielles car la représentation binaire de cette instance peut être trop grande pour être assignée dans une seule opération atomique. |
Attention