Exporter (0) Imprimer
Développer tout
Cet article a fait l'objet d'une traduction automatique. Déplacez votre pointeur sur les phrases de l'article pour voir la version originale de ce texte. Informations supplémentaires.
Traduction
Source

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.

  NomDescription
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreCompareTo(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 publiquePris en charge par XNA FrameworkCompareTo(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 publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreEquals(Double)Retourne une valeur indiquant si cette instance et un objet Double spécifié représentent la même valeur.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreEquals(Object)Renvoie une valeur indiquant si cette instance équivaut à un objet spécifié. (Substitue ValueType.Equals(Object).)
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreGetHashCodeRetourne le code de hachage de cette instance. (Substitue ValueType.GetHashCode().)
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreGetTypeObtient le Type de l'instance actuelle. (Hérité de Object.)
Méthode publiquePris en charge par XNA FrameworkGetTypeCodeRetourne le TypeCode du type valeur Double.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreIsInfinityRetourne une valeur indiquant si le nombre spécifié a pour valeur l'infini négatif ou positif.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreIsNaNRetourne une valeur qui indique si la valeur spécifiée n'est pas un nombre (NaN).
Méthode publiqueMembre statiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreIsNegativeInfinityRetourne une valeur indiquant si le nombre spécifié est équivalent à moins l'infini.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreIsPositiveInfinityRetourne une valeur indiquant si le nombre spécifié est équivalent à plus l'infini.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreParse(String)Convertit la représentation sous forme de chaîne d'un nombre en nombre à virgule flottante double précision équivalent.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreParse(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 publiqueMembre statiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreParse(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 publiqueMembre statiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreParse(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 publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreToString()Convertit la valeur numérique de cette instance en sa représentation équivalente sous forme de chaîne. (Substitue ValueType.ToString().)
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreToString(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 publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreToString(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 publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreToString(String, IFormatProvider)Convertit la valeur numérique de cette instance en sa représentation sous forme de chaîne équivalente à l'aide du format spécifié et des informations de format spécifiques à la culture.
Méthode publiqueMembre statiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreTryParse(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 publiqueMembre statiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreTryParse(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

  NomDescription
Opérateur publicMembre statiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreEqualityRetourne une valeur qui indique si deux valeurs Double spécifiées sont égales.
Opérateur publicMembre statiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreGreaterThanRetourne une valeur qui indique si une valeur Double spécifique est supérieure à une autre valeur Double spécifique.
Opérateur publicMembre statiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreGreaterThanOrEqualRetourne une valeur qui indique si une valeur Double spécifique est supérieure ou égale à une autre valeur Double spécifique.
Opérateur publicMembre statiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreInequalityRetourne une valeur qui indique si deux valeurs Double spécifiées sont différentes.
Opérateur publicMembre statiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreLessThanRetourne une valeur qui indique si une valeur Double spécifiée est inférieure à une autre valeur Double spécifiée.
Opérateur publicMembre statiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreLessThanOrEqualRetourne une valeur qui indique si une valeur Double spécifique est inférieure ou égale à une autre valeur Double spécifique.
Début

  NomDescription
Champ publicMembre statiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreEpsilonReprésente la valeur Double positive la plus petite qui est supérieure à zéro. Ce champ est constant.
Champ publicMembre statiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreMaxValueReprésente la plus grande valeur possible de Double. Ce champ est constant.
Champ publicMembre statiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreMinValueReprésente la plus petite valeur possible de Double. Ce champ est constant.
Champ publicMembre statiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreNaNReprésente une valeur qui n'est pas un nombre (NaN). Ce champ est constant.
Champ publicMembre statiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreNegativeInfinityReprésente l'infini négatif. Ce champ est constant.
Champ publicMembre statiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StorePositiveInfinityReprésente l'infini positif. Ce champ est constant.
Début

  NomDescription
Implémentation d'interface expliciteMéthode privéePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreIComparable.CompareToCompare l'instance actuelle avec un autre objet du même type et retourne un entier qui indique si l'instance actuelle précède ou suit un autre objet ou se trouve à la même position dans l'ordre de tri.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkIConvertible.ToBooleanInfrastructure. Pour obtenir une description de ce membre, consultez IConvertible.ToBoolean.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkIConvertible.ToByteInfrastructure. Pour obtenir une description de ce membre, consultez IConvertible.ToByte.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkIConvertible.ToCharInfrastructure. Cette conversion n'est pas prise en charge. Toute tentative d'utilisation de cette méthode lève un InvalidCastException.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkIConvertible.ToDateTimeInfrastructure. Cette conversion n'est pas prise en charge. Toute tentative d'utilisation de cette méthode lève un InvalidCastException.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkIConvertible.ToDecimalInfrastructure. Pour obtenir une description de ce membre, consultez IConvertible.ToDecimal.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkIConvertible.ToDoubleInfrastructure. Pour obtenir une description de ce membre, consultez IConvertible.ToDouble.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkIConvertible.ToInt16Infrastructure. Pour obtenir une description de ce membre, consultez IConvertible.ToInt16.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkIConvertible.ToInt32Infrastructure. Pour obtenir une description de ce membre, consultez IConvertible.ToInt32.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkIConvertible.ToInt64Infrastructure. Pour obtenir une description de ce membre, consultez IConvertible.ToInt64.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkIConvertible.ToSByteInfrastructure. Pour obtenir une description de ce membre, consultez IConvertible.ToSByte.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkIConvertible.ToSingleInfrastructure. Pour obtenir une description de ce membre, consultez IConvertible.ToSingle.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkIConvertible.ToTypeInfrastructure. Pour obtenir une description de ce membre, consultez IConvertible.ToType.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkIConvertible.ToUInt16Infrastructure. Pour obtenir une description de ce membre, consultez IConvertible.ToUInt16.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkIConvertible.ToUInt32Infrastructure. Pour obtenir une description de ce membre, consultez IConvertible.ToUInt32.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkIConvertible.ToUInt64Infrastructure. Pour obtenir 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 même que de plus zéro à moins zéro, PositiveInfinity, NegativeInfinity, et ne sont pas numériques (NaN). Il est conçu pour représenter les valeurs qui sont très grandes (tels que la distances entre les planètes ou les galaxies) ou très petites (la masse moléculaire d'une substance en kilogrammes) et qui sont souvent imprécises (comme la distance de la terre à un autre système solaire), le type Double est conforme au standard de 60559:1989 de CEI (IEEE 754) pour le calcul à virgule flottante binaire.

Cette rubrique se compose des sections suivantes :

Représentation à virgule flottante et précision

Le type de données Double enregistre des valeurs à virgule flottante avec une précision double dans un format binaire 64 bits, comme indiqué dans le tableau suivant :

Élément

Bits

Significand ou mantisse

0-51

Exposant

52-62

Signe (0 = positif, 1 = négatif)

63

Tout comme les fractions décimales ne peuvent pas représenter avec précision certaines valeurs fractionnaires (telles que 1/3 ou Math.PI), les fractions binaires ne peuvent pas représenter certaines valeurs fractionnaires. Par exemple, 1/10, qui est représenté avec précision par .1 comme fraction décimale, est représenté par .001100110011 comme fraction binaire, avec le modèle « 0011 " répétant à l'infini. Dans ce cas, la valeur à virgule flottante fournit une représentation imprécise du nombre qu'il représente. L'exécution d'opérations mathématiques supplémentaires sur la valeur à virgule flottante d'origine tend souvent à augmenter son manque de précision. Par exemple, si nous comparons le résultat des multiplications .1 par 10 et d'ajouter .1 à .1 neuf fois, nous voyons que l'addition, car elle impliquait huit opérations supplémentaires, donne le résultat le moins précis. Notez que cette disparité est visible uniquement si nous affichons les deux valeurs Double à l'aide de « R » chaîne de format numérique standard, qui affiche si nécessaire chacun des 17 chiffres de précision pris en charge par le type Double.


using System;

public class Example
{
   public static void Main()
   {
      Double value = .1;
      Double result1 = value * 10;
      Double result2 = 0;
      for (int ctr = 1; ctr <= 10; ctr++)
         result2 += value;

      Console.WriteLine(".1 * 10:           {0:R}", result1);
      Console.WriteLine(".1 Added 10 times: {0:R}", result2);
   }
}
// The example displays the following output:
//       .1 * 10:           1
//       .1 Added 10 times: 0.99999999999999989


Étant donné que certains nombres ne peuvent pas être représentés exactement comme valeurs binaires fractionnaires, des nombres à virgule flottante ne peuvent qu'approximer des nombres réels.

Tous les nombres à virgule flottante ont également un nombre limité de chiffres significatifs, qui détermine aussi avec quelle précision une valeur à virgule flottante approxime un nombre réel. Même si 17 chiffres maximum sont gérés en interne, la valeur Double possède non moins de 15 décimales pour assurer la précision. Cela signifie que certaines opérations en virgule flottante peuvent manquer de précision pour modifier une valeur à virgule flottante. L'exemple suivant illustre cette situation. Il définit une valeur à virgule flottante très élevée, puis lui ajoute le produit de Double.Epsilon et d'un quadrillion. Le produit, toutefois, est trop petit pour modifier la valeur à virgule flottante d'origine. Son chiffre le moins significatif correspond aux millièmes, alors que le chiffre le plus significatif dans le produit est 1-312.


using System;

public class Example
{
   public static void Main()
   {
      Double value = 123456789012.34567;
      Double additional = Double.Epsilon * 1e12;
      Console.WriteLine("{0} + {1} = {2}", value, additional, 
                                           value + additional);
   }
}
// The example displays the following output:
//    123456789012.346 + 4.94065645841247E-312 = 123456789012.346


La précision limitée 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. Dans l'exemple suivant, une série de nombres sont ajoutés ensembles, et leur total est comparé à leur total prévu. Bien que les deux valeurs semblent être identiques, un appel à la méthode Equals indique qu'elles ne le sont pas.

    
    using System;
    
    public class Example
    {
       public static void Main()
       {
          Double[] values = { 10.0, 2.88, 2.88, 2.88, 9.0 };
          Double result = 27.64;
          Double total = 0;
          foreach (var value in values)
             total += value;
    
          if (total.Equals(result))
             Console.WriteLine("The sum of the values equals the total.");
          else
             Console.WriteLine("The sum of the values ({0}) does not equal the total ({1}).",
                               total, result); 
       }
    }
    // The example displays the following output:
    //      The sum of the values (36.64) does not equal the total (36.64).   
    //
    // If the index items in the Console.WriteLine statement are changed to {0:R},
    // the example displays the following output:
    //       The sum of the values (27.639999999999997) does not equal the total (27.64).   
    
    
    

    Si vous modifiez les éléments de mise en forme dans l'instruction Console.WriteLine(String, Object, Object) qui provient de {0} et {1} à {0:R} et {1:R} pour afficher tous les chiffres significatifs des deux valeurs Double, il apparaît clairement que les deux valeurs sont inégales en raison d'une perte de précision pendant les opérations d'addition. Dans ce cas, le problème peut être résolu en appelant la méthode Math.Round(Double, Int32) pour arrondir les valeurs Double à la précision voulue avant d'exécuter la comparaison.

  • 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 être égal au nombre décimal. Un exemple précédent a montré cela en affichant le résultat de la multiplications de .1 par 10 et de l'ajout de .1.

    Lorsque l'exactitude dans les opérations numériques avec des valeurs fractionnaires est importante, vous pouvez utiliser Decimal plutôt que le type Double. Lorsque l'exactitude dans les opérations numériques avec des valeurs intégrales hors de portée de Int64 ou lorsque les types UInt64 sont importants, utilisez le type BigInteger.

  • 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 de nouveau 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. Dans l'exemple suivant, trois valeurs de Double sont converties en chaînes et stockées dans un fichier. Comme le montre la sortie cependant, bien que les valeurs semblent être identiques, les valeurs restaurées ne sont pas identiques aux valeurs d'origine.

    
    using System;
    using System.IO;
    
    public class Example
    {
       public static void Main()
       {
          StreamWriter sw = new StreamWriter(@".\Doubles.dat");
          Double[] values = { 2.2/1.01, 1.0/3, Math.PI };
          for (int ctr = 0; ctr < values.Length; ctr++) {
             sw.Write(values[ctr].ToString());
             if (ctr != values.Length - 1)
                sw.Write("|");
          }      
          sw.Close();
    
          Double[] restoredValues = new Double[values.Length];
          StreamReader sr = new StreamReader(@".\Doubles.dat");
          string temp = sr.ReadToEnd();
          string[] tempStrings = temp.Split('|');
          for (int ctr = 0; ctr < tempStrings.Length; ctr++)
             restoredValues[ctr] = Double.Parse(tempStrings[ctr]);   
    
    
          for (int ctr = 0; ctr < values.Length; ctr++)
             Console.WriteLine("{0} {2} {1}", values[ctr], 
                               restoredValues[ctr],
                               values[ctr].Equals(restoredValues[ctr]) ? "=" : "<>");
       }
    }
    // The example displays the following output:
    //       2.17821782178218 <> 2.17821782178218
    //       0.333333333333333 <> 0.333333333333333
    //       3.14159265358979 <> 3.14159265358979
    
    
    

    Dans ce cas, les valeurs peuvent aux être correctement faire un aller-retour à l'aide de « R » chaîne de format numérique standard pour conserver la précision des valeurs Double, comme dans l'exemple suivant.

    
    using System;
    using System.IO;
    
    public class Example
    {
       public static void Main()
       {
          StreamWriter sw = new StreamWriter(@".\Doubles.dat");
          Double[] values = { 2.2/1.01, 1.0/3, Math.PI };
          for (int ctr = 0; ctr < values.Length; ctr++) 
             sw.Write("{0:R}{1}", values[ctr], ctr < values.Length - 1 ? "|" : "" );
    
          sw.Close();
    
          Double[] restoredValues = new Double[values.Length];
          StreamReader sr = new StreamReader(@".\Doubles.dat");
          string temp = sr.ReadToEnd();
          string[] tempStrings = temp.Split('|');
          for (int ctr = 0; ctr < tempStrings.Length; ctr++)
             restoredValues[ctr] = Double.Parse(tempStrings[ctr]);   
    
    
          for (int ctr = 0; ctr < values.Length; ctr++)
             Console.WriteLine("{0} {2} {1}", values[ctr], 
                               restoredValues[ctr],
                               values[ctr].Equals(restoredValues[ctr]) ? "=" : "<>");
       }
    }
    // The example displays the following output:
    //       2.17821782178218 = 2.17821782178218
    //       0.333333333333333 = 0.333333333333333
    //       3.14159265358979 = 3.14159265358979
    
    
    
  • les valeurs Single ont moins de précision que les valeurs Double. Une valeur Single qui est convertie en Double apparemment équivalent n'est souvent pas égale à la valeur Double en raison de différences dans la précision. Dans l'exemple suivant, le résultat des opérations identiques de division est assigné à Double et une valeur Single. Après que la valeur Single soit castée en Double, une comparaison des deux valeurs indique qu'elles ne sont pas égales.

    
    using System;
    
    public class Example
    {
       public static void Main()
       {
          Double value1 = 1/3.0;
          Single sValue2 = 1/3.0f;
          Double value2 = (Double) sValue2;
          Console.WriteLine("{0:R} = {1:R}: {2}", value1, value2, 
                                              value1.Equals(value2));
       }
    }
    // The example displays the following output:
    //        0.33333333333333331 = 0.3333333432674408: False
    
    
    

    Pour éviter ce problème, utilisez soit le Double au lieu du type de données Single, ou utilisez la méthode Round afin que les deux valeurs aient la même précision.

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      


Test de l'égalité

Pour être considérées comme égales, deux valeurs de Double doivent représenter des valeurs identiques. Toutefois, en raison de différences dans la précision entre les valeurs, ou en raison d'une perte de précision par l'une ou les deux valeurs, les valeurs à virgule flottante censées être identique s'avèrent être souvent inégales à cause des différences dans leurs chiffres significatifs les moins signifiants. Par conséquent, les appels à la méthode Equals pour déterminer si deux valeurs sont égales, ou les appels à la méthode CompareTo pour déterminer la relation entre deux valeurs de Double , présentent souvent des résultats inattendus. Cela apparaît de manière évidente dans l'exemple suivant, où deux valeurs apparemmentent égales Double s'avèrent être inégales car la première a 15 chiffres de précision, tandis que la deuxième est 17.


using System;

public class Example
{
   public static void Main()
   {
      double value1 = .333333333333333;
      double value2 = 1.0/3;
      Console.WriteLine("{0:R} = {1:R}: {2}", value1, value2, value1.Equals(value2));
   }
}
// The example displays the following output:
//        0.333333333333333 = 0.33333333333333331: False


Les valeurs calculées qui suivent des chemins de code et qui sont manipulées de différentes façons s'avèrent souvent différentes. Dans l'exemple suivant, une valeur Double est rendue carré, puis la racine carrée est calculée pour restaurer la valeur d'origine. Une deuxième Double est multipliée par 3,51 et rendue carré avant que la racine carrée du résultat ne soit divisée par 3,51 pour restaurer la valeur d'origine. Bien que les deux valeurs semblent être identiques, un appel à la méthode Equals(Double) indique qu'elles ne le sont pas. L'utilisation de la chaîne de format standard « R » pour retourner une chaîne de résultat qui affiche tous les chiffres significatifs de chaque valeur double indique que la deuxième valeur est inférieure de .0000000000001 par rapport à la première.


using System;

public class Example
{
   public static void Main()
   {
      double value1 = 100.10142;
      value1 = Math.Sqrt(Math.Pow(value1, 2));
      double value2 = Math.Pow(value1 * 3.51, 2);
      value2 = Math.Sqrt(value2) / 3.51;
      Console.WriteLine("{0} = {1}: {2}\n", 
                        value1, value2, value1.Equals(value2)); 
      Console.WriteLine("{0:R} = {1:R}", value1, value2); 
   }
}
// The example displays the following output:
//    100.10142 = 100.10142: False
//    
//    100.10142 = 100.10141999999999


Dans les cas où une perte de précision est susceptible d'affecter le résultat d'une comparaison, vous pouvez adopter chacune des ces alternatives à l'appel de la méthode Equals ou de la méthode CompareTo:

  • Appelez la méthode Math.Round pour vérifier que les deux valeurs ont la même précision. L'exemple suivant modifie l'exemple précédent pour utiliser cette approche afin que deux valeurs fractionnaires soient équivalentes.

    
    using System;
    
    public class Example
    {
       public static void Main()
       {
          double value1 = .333333333333333;
          double value2 = 1.0/3;
          int precision = 7;
          value1 = Math.Round(value1, precision);
          value2 = Math.Round(value2, precision);
          Console.WriteLine("{0:R} = {1:R}: {2}", value1, value2, value1.Equals(value2));
       }
    }
    // The example displays the following output:
    //        0.3333333 = 0.3333333: True
    
    
    

    Notez, pourtant, que le problème de précision s'applique toujours à l'arrondi des valeurs du milieu. Pour plus d'informations, consultez la méthode Math.Round(Double, Int32, MidpointRounding).

  • Tester l'égalité approximative plutôt que l'égalité. Cela nécessite que vous définissiez soit une quantité absolue de laquelle les deux valeurs peuvent différer mais être toujours égales, ou que vous définissez une quantité relative par laquelle la valeur inférieure peut différer de la valeur supérieure.

    Mise en gardeAttention

    Double.Epsilon est parfois utilisé comme une mesure absolue de la distance entre deux valeurs Double en testant l'égalité. Toutefois, Double.Epsilon mesure la plus petite valeur possible qui peut être ajoutée à, ou soustraite de, un Double dont la valeur est zéro. Pour les valeurs de Double les plus positives et plus négatives, la valeur de Double.Epsilon est trop petite pour être détectée. Par conséquent, à l'exception des valeurs qui sont à zéro, nous déconseillons son utilisation dans les tests d'égalité.

    L'exemple suivant utilise la dernière approche pour définir une méthode IsApproximatelyEqual qui teste la différence relative entre deux valeurs. Il compare également le résultat des appels à la méthode IsApproximatelyEqual et la méthode Equals(Double).

    
    using System;
    
    public class Example
    {
       public static void Main()
       {
          double one1 = .1 * 10;
          double one2 = 0;
          for (int ctr = 1; ctr <= 10; ctr++)
             one2 += .1;
    
          Console.WriteLine("{0:R} = {1:R}: {2}", one1, one2, one1.Equals(one2));
          Console.WriteLine("{0:R} is approximately equal to {1:R}: {2}", 
                            one1, one2, 
                            IsApproximatelyEqual(one1, one2, .000000001));   
       }
    
       static bool IsApproximatelyEqual(double value1, double value2, double epsilon)
       {
          // If they are equal anyway, just return True.
          if (value1.Equals(value2))
             return true;
    
          // Handle NaN, Infinity.
          if (Double.IsInfinity(value1) | Double.IsNaN(value1))
             return value1.Equals(value2);
          else if (Double.IsInfinity(value2) | Double.IsNaN(value2))
             return value1.Equals(value2);
    
          // Handle zero to avoid division by zero
          double divisor = Math.Max(value1, value2);
          if (divisor.Equals(0)) 
             divisor = Math.Min(value1, value2);
    
          return Math.Abs(value1 - value2)/divisor <= epsilon;           
       } 
    }
    // The example displays the following output:
    //       1 = 0.99999999999999989: False
    //       1 is approximately equal to 0.99999999999999989: True
    
    
    

Valeurs à virgule flottante et exceptions

Contrairement aux opérations avec les types intégraux, qui provoquent des exceptions en cas de dépassement de capacité ou de l'assembly telles que la division par zéro, les opérations avec des valeurs à virgule flottante ne lèvent pas d'exceptions. En revanche, dans les cas exceptionnelles, le résultat d'une opération en virgule flottante est zéro, infini positif, infini négatif, soit pas un nombre (NaN) :

  • Si le résultat d'une opération à virgule flottante est trop petit pour le format de destination, le résultat de l'opération est alors zéro. Cela peut se produire lorsque deux nombres très petits sont multipliés, comme le montre l'exemple suivant.

    
    using System;
    
    public class Example
    {
       public static void Main()
       {
          Double value1 = 1.1632875981534209e-225;
          Double value2 = 9.1642346778e-175;
          Double result = value1 * value2;
          Console.WriteLine("{0} * {1} = {2}", value1, value2, result);
          Console.WriteLine("{0} = 0: {1}", result, result.Equals(0.0));
       }
    }
    // The example displays the following output:
    //       1.16328759815342E-225 * 9.1642346778E-175 = 0
    //       0 = 0: True
    
    
    
  • Si la taille du 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. Le résultat d'une opération qui dépasse Double.MaxValue est PositiveInfinity, et le résultat d'une opération qui dépasse Double.MinValue est NegativeInfinity, comme le montre l'exemple suivant.

    
    using System;
    
    public class Example
    {
       public static void Main()
       {
          Double value1 = 4.565e153;
          Double value2 = 6.9375e172;
          Double result = value1 * value2;
          Console.WriteLine("PositiveInfinity: {0}", 
                             Double.IsPositiveInfinity(result));
          Console.WriteLine("NegativeInfinity: {0}\n", 
                            Double.IsNegativeInfinity(result));
    
          value1 = -value1;
          result = value1 * value2;
          Console.WriteLine("PositiveInfinity: {0}", 
                             Double.IsPositiveInfinity(result));
          Console.WriteLine("NegativeInfinity: {0}", 
                            Double.IsNegativeInfinity(result));
       }
    }                                                                 
    
    // The example displays the following output:
    //       PositiveInfinity: True
    //       NegativeInfinity: False
    //       
    //       PositiveInfinity: False
    //       NegativeInfinity: True
    
    
    

    PositiveInfinity résulte également d'une division par zéro avec un dividende positif, et les résultats NegativeInfinity d'une division par zéro avec un dividende négatif.

  • Si une opération en virgule flottante n'est pas valide, le résultat de l'opération est alors NaN. Par exemple, NaN est le résultat des opérations suivantes :

  • Toute opération à virgule flottante avec une entrée non valide. Par exemple, appeler la méthode Math.Sqrt avec une valeur négative retourne NaN, tout comme appeler la méthode Math.Acos avec une valeur qui est supérieure à un inférieure à moins un.

  • Toute opération avec un argument dont la valeur est Double.NaN.

fonctions à virgule flottante

La structure Double et les types connexes fournissent des méthodes pour effectuer des opérations dans les cas suivants :

  • Comparaison de valeurs. Vous pouvez appeler la méthode Equals pour déterminer si deux valeurs Double sont égales, ou la méthode CompareTo pour déterminer la relation entre deux valeurs.

    La structure Double prend également en charge un jeu complet d'opérateurs de comparaison. Par exemple, vous pouvez tester l'égalité ou l'inégalité, ou déterminer si une valeur est supérieure ou égale à une autre. Si un des opérandes est un type numérique autre que Double, il est converti en un Double avant d'exécuter la comparaison.

    Mise en gardeAttention

    À cause de différences dans la précision, deux valeurs Double que vous pensez égales peuvent s'avérer ne pas l'être, ce qui affecte le résultat de la comparaison. Consultez la section Tester l'égalité pour plus d'informations sur la comparaison de deux Double.

    Vous pouvez également appeler IsNaN, IsInfinity, IsPositiveInfinity, et les méthodes IsNegativeInfinity pour déterminer ces valeurs spéciales.

  • Opérations mathématiques. Les opérations arithmétiques courantes, telles que l'addition, la soustraction, la multiplication, et division, sont implémentées par les compilateurs de langage et les instructions de Common Intermediate Language (CIL), plutôt que par les méthodes Double. Si l'un des opérandes dans une opération mathématique est un type numérique autre que Double, il est converti en un Double avant d'exécuter l'opération. Le résultat de l'opération est également une valeur Double.

    D'autres opérations mathématiques peuvent être exécutées en appelant les méthodes static (Shared en Visual Basic) dans la classe System.Math. Elle inclut des méthodes supplémentaires couramment utilisées pour l'arithmétique (comme par exemple, Math.Abs, Math.Sign, et Math.Sqrt), la géométrie (comme Math.Cos et Math.Sin), et le calcul (comme Math.Log).

    Vous pouvez également manipuler les différents bits en valeur Double. La méthode BitConverter.DoubleToInt64Bits conserve le modèle binaire d'une valeur Double dans un entier 64 bits. La méthode BitConverter.GetBytes(Double) retourne son modèle binaire dans un tableau d'octets.

  • Arrondir. L'arrondi est souvent utilisé comme une technique pour réduire l'impact des différences entre les valeurs dues à des problèmes de représentation à virgule flottante et la précision. Vous pouvez arrondir une valeur Double en appelant la méthode Math.Round.

  • Formatage. Vous pouvez convertir une valeur Double en sa représentation sous forme de chaîne en appelant la méthode ToString ou en utilisant la fonctionnalité de mise en forme composite. Pour plus d'informations sur la façon dont les chaînes de format contrôlent la représentation sous forme de chaîne des valeurs à virgule flottante, consultez les rubriques Chaînes de format numériques standard et Chaînes de format numériques personnalisées.

  • Analyse de chaînes. Vous pouvez convertir la représentation sous forme de chaîne d'une valeur à virgule flottante en une valeur Double en appelant soit la méthode Parse soit TryParse. Si l'opération d'analyse échoue, la méthode Parse lève une exception, tandis que la méthode TryParse retourne false.

  • Conversion de type La structure Double fournit une implémentation d'interface explicite pour l'interface IConvertible, qui prend en charge la conversion entre deux types de données standard quelconques .NET Framework. Les compilateurs de langages prennent également en charge la conversion implicite des valeurs de tous les autres types numériques standard aux valeurs Double. La conversion d'une valeur de tout type numérique standard en un Double est une conversion étendue et ne requiert pas l'utilisateur d'une méthode d'opérateur de casting ou une méthode de conversion,

    Toutefois, la conversion d'un Int64 et les valeurs de Single peuvent impliquer une perte de précision. Le tableau suivant répertorie les différences de précision pour chacun de ces types :

    Type

    Précision maximale

    Précision interne

    Double

    15

    17

    Int64

    19 chiffres décimaux

    19 chiffres décimaux

    Single

    7 chiffres décimaux

    9 chiffres décimaux

    Le problème de précision affecte le plus souvent les valeurs Single qui sont converties en valeurs Double. Dans l'exemple suivant, deux valeurs produites par des opérations identiques de division ne sont pas égales car une des valeurs est une valeur à virgule flottante en simple précision convertie en Double.

    
    using System;
    
    public class Example
    {
       public static void Main()
       {
          Double value = .1;
          Double result1 = value * 10;
          Double result2 = 0;
          for (int ctr = 1; ctr <= 10; ctr++)
             result2 += value;
    
          Console.WriteLine(".1 * 10:           {0:R}", result1);
          Console.WriteLine(".1 Added 10 times: {0:R}", result2);
       }
    }
    // The example displays the following output:
    //       .1 * 10:           1
    //       .1 Added 10 times: 0.99999999999999989
    
    
    

L'exemple de code suivant montre comment utiliser Double :


	// The Temperature class stores the temperature as a Double
	// and delegates most of the functionality to the Double
	// implementation.
	public class Temperature : IComparable, IFormattable 
    {
		// IComparable.CompareTo implementation.
		public int CompareTo(object obj) {
            if (obj == null) return 1;

			Temperature temp = obj as Temperature;
            if (obj != null) 
				return m_value.CompareTo(temp.m_value);
			else
     			throw new ArgumentException("object is not a Temperature");	
		}

		// IFormattable.ToString implementation.
		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);
		}

		// Parses the temperature from a string in the form
		// [ws][sign]digits['F|'C][ws]
		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.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Pris en charge dans : 4, 3.5 SP1

Bibliothèque de classes portable

Pris en charge dans : Bibliothèque de classes portable

.NET pour les applications du Windows Store

Pris en charge dans : Windows 8

.NET pour les applications Windows Phone

Pris en charge dans : Windows Phone 8, Silverlight 8.1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (rôle principal du serveur non pris en charge), Windows Server 2008 R2 (rôle principal du serveur pris en charge avec SP1 ou version ultérieure ; Itanium non pris en charge)

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 cohérence de thread.

Mise en gardeAttention

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.

Ajouts de la communauté

AJOUTER
Afficher:
© 2014 Microsoft