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
Ce sujet n'a pas encore été évalué - Évaluez ce sujet

Double, structure

Représente un nombre à virgule flottante double précision.

Espace de noms :  System
Assembly :  mscorlib (dans mscorlib.dll)
[SerializableAttribute]
[ComVisibleAttribute(true)]
public struct Double : IComparable, IFormattable, 
	IConvertible, IComparable<double>, IEquatable<double>

Le type Double expose les membres suivants.

  Nom Description
Méthode publique Pris en charge par XNA Framework 643eft0t.PortableClassLibrary(fr-fr,VS.100).gif 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é.
Méthode publique Pris en charge par XNA Framework 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é.
Méthode publique Pris en charge par XNA Framework 643eft0t.PortableClassLibrary(fr-fr,VS.100).gif Equals(Double) Retourne une valeur indiquant si cette instance et un objet Double spécifié représentent la même valeur.
Méthode publique Pris en charge par XNA Framework 643eft0t.PortableClassLibrary(fr-fr,VS.100).gif Equals(Object) Retourne une valeur indiquant si cette instance est égale à un objet spécifié. (Substitue ValueType.Equals(Object).)
Méthode protégée Pris en charge par XNA Framework 643eft0t.PortableClassLibrary(fr-fr,VS.100).gif 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.)
Méthode publique Pris en charge par XNA Framework 643eft0t.PortableClassLibrary(fr-fr,VS.100).gif GetHashCode Retourne le code de hachage pour cette instance. (Substitue ValueType.GetHashCode().)
Méthode publique Pris en charge par XNA Framework 643eft0t.PortableClassLibrary(fr-fr,VS.100).gif GetType Obtient le Type de l'instance actuelle. (Hérité de Object.)
Méthode publique Pris en charge par XNA Framework GetTypeCode Retourne le TypeCode du type valeur Double.
Méthode publique Membre statique Pris en charge par XNA Framework 643eft0t.PortableClassLibrary(fr-fr,VS.100).gif IsInfinity Retourne une valeur indiquant si le nombre spécifié a pour valeur l'infini négatif ou positif.
Méthode publique Membre statique Pris en charge par XNA Framework 643eft0t.PortableClassLibrary(fr-fr,VS.100).gif IsNaN Retourne une valeur indiquant si le nombre spécifié a une valeur qui n'est pas un nombre (NaN).
Méthode publique Membre statique Pris en charge par XNA Framework 643eft0t.PortableClassLibrary(fr-fr,VS.100).gif IsNegativeInfinity Retourne une valeur indiquant si le nombre spécifié est équivalent à moins l'infini.
Méthode publique Membre statique Pris en charge par XNA Framework 643eft0t.PortableClassLibrary(fr-fr,VS.100).gif IsPositiveInfinity Retourne une valeur indiquant si le nombre spécifié est équivalent à plus l'infini.
Méthode protégée Pris en charge par XNA Framework 643eft0t.PortableClassLibrary(fr-fr,VS.100).gif MemberwiseClone Crée une copie superficielle de l'objet Object actif. (Hérité de Object.)
Méthode publique Membre statique Pris en charge par XNA Framework Parse(String) Convertit la représentation sous forme de chaîne d'un nombre en nombre à virgule flottante double précision équivalent.
Méthode publique Membre statique Pris en charge par XNA Framework 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.
Méthode publique Membre statique Pris en charge par XNA Framework 643eft0t.PortableClassLibrary(fr-fr,VS.100).gif 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.
Méthode publique Membre statique Pris en charge par XNA Framework 643eft0t.PortableClassLibrary(fr-fr,VS.100).gif 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.
Méthode publique Pris en charge par XNA Framework 643eft0t.PortableClassLibrary(fr-fr,VS.100).gif ToString() Convertit la valeur numérique de cette instance en sa représentation équivalente sous forme de chaîne. (Substitue ValueType.ToString().)
Méthode publique Pris en charge par XNA Framework 643eft0t.PortableClassLibrary(fr-fr,VS.100).gif 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.
Méthode publique Pris en charge par XNA Framework 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é.
Méthode publique Pris en charge par XNA Framework 643eft0t.PortableClassLibrary(fr-fr,VS.100).gif 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.
Méthode publique Membre statique 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é.
Méthode publique Membre statique 643eft0t.PortableClassLibrary(fr-fr,VS.100).gif 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é.
Début
  Nom Description
Opérateur public Membre statique Equality Retourne une valeur qui indique si deux valeurs Double spécifiées sont égales.
Opérateur public Membre statique GreaterThan Retourne une valeur qui indique si une valeur Double spécifique est supérieure à une autre valeur Double spécifique.
Opérateur public Membre statique GreaterThanOrEqual Retourne une valeur qui indique si une valeur Double spécifique est supérieure ou égale à une autre valeur Double spécifique.
Opérateur public Membre statique Inequality Retourne une valeur qui indique si deux valeurs Double spécifiées sont différentes.
Opérateur public Membre statique LessThan Retourne une valeur qui indique si une valeur Double spécifiée est inférieure à une autre valeur Double spécifiée.
Opérateur public Membre statique LessThanOrEqual Retourne une valeur qui indique si une valeur Double spécifique est inférieure ou égale à une autre valeur Double spécifique.
Début
  Nom Description
Champ public Membre statique Pris en charge par XNA Framework 643eft0t.PortableClassLibrary(fr-fr,VS.100).gif Epsilon Représente la valeur Double positive la plus petite qui est supérieure à zéro. Ce champ est constant.
Champ public Membre statique Pris en charge par XNA Framework 643eft0t.PortableClassLibrary(fr-fr,VS.100).gif MaxValue Représente la plus grande valeur possible de Double. Ce champ est constant.
Champ public Membre statique Pris en charge par XNA Framework 643eft0t.PortableClassLibrary(fr-fr,VS.100).gif MinValue Représente la plus petite valeur possible de Double. Ce champ est constant.
Champ public Membre statique Pris en charge par XNA Framework 643eft0t.PortableClassLibrary(fr-fr,VS.100).gif NaN Représente une valeur qui n'est pas un nombre (NaN). Ce champ est constant.
Champ public Membre statique Pris en charge par XNA Framework 643eft0t.PortableClassLibrary(fr-fr,VS.100).gif NegativeInfinity Représente l'infini négatif. Ce champ est constant.
Champ public Membre statique Pris en charge par XNA Framework 643eft0t.PortableClassLibrary(fr-fr,VS.100).gif PositiveInfinity Représente l'infini positif. Ce champ est constant.
Début
  Nom Description
Implémentation d'interface explicite Méthode privée Pris en charge par XNA Framework IConvertible.ToBoolean Infrastructure. Pour obtenir une description de ce membre, consultez IConvertible.ToBoolean.
Implémentation d'interface explicite Méthode privée Pris en charge par XNA Framework IConvertible.ToByte Infrastructure. Pour une description de ce membre, consultez IConvertible.ToByte.
Implémentation d'interface explicite Méthode privée Pris en charge par XNA Framework IConvertible.ToChar Infrastructure. Cette conversion n'est pas prise en charge. Toute tentative d'utilisation de cette méthode lève un InvalidCastException.
Implémentation d'interface explicite Méthode privée Pris en charge par XNA Framework IConvertible.ToDateTime Infrastructure. Cette conversion n'est pas prise en charge. Toute tentative d'utilisation de cette méthode lève un InvalidCastException.
Implémentation d'interface explicite Méthode privée Pris en charge par XNA Framework IConvertible.ToDecimal Infrastructure. Pour obtenir une description de ce membre, consultez IConvertible.ToDecimal.
Implémentation d'interface explicite Méthode privée Pris en charge par XNA Framework IConvertible.ToDouble Infrastructure. Pour obtenir une description de ce membre, consultez IConvertible.ToDouble.
Implémentation d'interface explicite Méthode privée Pris en charge par XNA Framework IConvertible.ToInt16 Infrastructure. Pour une description de ce membre, consultez IConvertible.ToInt16.
Implémentation d'interface explicite Méthode privée Pris en charge par XNA Framework IConvertible.ToInt32 Infrastructure. Pour une description de ce membre, consultez IConvertible.ToInt32.
Implémentation d'interface explicite Méthode privée Pris en charge par XNA Framework IConvertible.ToInt64 Infrastructure. Pour une description de ce membre, consultez IConvertible.ToInt64.
Implémentation d'interface explicite Méthode privée Pris en charge par XNA Framework IConvertible.ToSByte Infrastructure. Pour une description de ce membre, consultez IConvertible.ToSByte.
Implémentation d'interface explicite Méthode privée Pris en charge par XNA Framework IConvertible.ToSingle Infrastructure. Pour obtenir une description de ce membre, consultez IConvertible.ToSingle.
Implémentation d'interface explicite Méthode privée Pris en charge par XNA Framework IConvertible.ToType Infrastructure. Pour une description de ce membre, consultez IConvertible.ToType.
Implémentation d'interface explicite Méthode privée Pris en charge par XNA Framework IConvertible.ToUInt16 Infrastructure. Pour une description de ce membre, consultez IConvertible.ToUInt16.
Implémentation d'interface explicite Méthode privée Pris en charge par XNA Framework IConvertible.ToUInt32 Infrastructure. Pour une description de ce membre, consultez IConvertible.ToUInt32.
Implémentation d'interface explicite Méthode privée Pris en charge par XNA Framework IConvertible.ToUInt64 Infrastructure. Pour une description de ce membre, consultez IConvertible.ToUInt64.
Début

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;
			}
		}
	}


.NET Framework

Pris en charge dans : 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Pris en charge dans : 4, 3.5 SP1

Pris en charge dans :

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.

Remarque Attention 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.

Cela vous a-t-il été utile ?
(1500 caractères restants)
Contenu de la communauté Ajouter
Annotations FAQ