System.Single struct

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

Le Single type valeur représente un nombre 32 bits à précision unique avec des valeurs comprises entre 3,402823e38 et positif 3,402823e38, ainsi que zéro positif ou négatif, PositiveInfinityNegativeInfinityet non un nombre (NaN). Il est destiné à représenter des valeurs extrêmement volumineuses (telles que les distances entre les planètes ou les galaxies) ou extrêmement petites (telles que la masse moléculaire d’une substance en kilogrammes) et qui sont souvent imprécises (comme la distance entre la terre et un autre système solaire). Le Single type est conforme à la norme IEC 60559 :1989 (IEEE 754) pour l’arithmétique à virgule flottante binaire.

System.Single fournit des méthodes pour comparer des instances de ce type, pour convertir la valeur d’une instance en sa représentation sous forme de chaîne et pour 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 Types de mise en forme, Chaînes de format numérique standard et Chaînes de format numérique personnalisées.

Représentation à virgule flottante et précision

Le Single type de données stocke des valeurs à virgule flottante simple précision dans un format binaire 32 bits, comme indiqué dans le tableau suivant :

Élément	Bits
Significand ou mantissa	0-22
Exposant	23-30
Signe (0 = positif, 1 = négatif)	31

Tout comme les fractions décimales ne peuvent pas représenter précisément certaines valeurs fractionnelles (telles que 1/3 ou Math.PI), les fractions binaires ne peuvent pas représenter certaines valeurs fractionnaires. Par exemple, 2/10, qui est représenté précisément par .2 comme fraction décimale, est représenté par .0011111001001100 comme fraction binaire, avec le modèle « 1100 » répétant à l’infini. Dans ce cas, la valeur à virgule flottante fournit une représentation imprécise du nombre qu’elle représente. L’exécution d’opérations mathématiques supplémentaires sur la valeur à virgule flottante d’origine augmente souvent son manque de précision. Par exemple, si vous comparez les résultats de la multiplication de .3 par 10 et l’ajout de .3 à .3 neuf fois, vous verrez que l’ajout produit le résultat moins précis, car il implique huit opérations plus que la multiplication. Notez que cette disparité n’est apparente que si vous affichez les deux Single valeurs à l’aide de la chaîne de format numérique standard « R », qui, si nécessaire, affiche tous les 9 chiffres de précision pris en charge par le Single type.

using System;

public class Example12
{
    public static void Main()
    {
        Single value = .2f;
        Single result1 = value * 10f;
        Single result2 = 0f;
        for (int ctr = 1; ctr <= 10; ctr++)
            result2 += value;

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

let value = 0.2f
let result1 = value * 10f
let mutable result2 = 0f
for _ = 1 to 10 do
    result2 <- result2 + value

printfn $".2 * 10:           {result1:R}"
printfn $".2 Added 10 times: {result2:R}"
// The example displays the following output:
//       .2 * 10:           2
//       .2 Added 10 times: 2.00000024

Module Example13
    Public Sub Main()
        Dim value As Single = 0.2
        Dim result1 As Single = value * 10
        Dim result2 As Single
        For ctr As Integer = 1 To 10
            result2 += value
        Next
        Console.WriteLine(".2 * 10:           {0:R}", result1)
        Console.WriteLine(".2 Added 10 times: {0:R}", result2)
    End Sub
End Module
' The example displays the following output:
'       .2 * 10:           2
'       .2 Added 10 times: 2.00000024

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

Tous les nombres à virgule flottante ont un nombre limité de chiffres significatifs, ce qui détermine également la précision d’une valeur à virgule flottante approximativement un nombre réel. Une Single valeur a jusqu’à 7 chiffres décimaux de précision, bien qu’un maximum de 9 chiffres soit conservé en interne. Cela signifie que certaines opérations à virgule flottante peuvent manquer de précision pour modifier une valeur à virgule flottante. L’exemple suivant définit une valeur à virgule flottante simple précision, puis ajoute le produit d’un Single.Epsilon quadrillion à celui-ci. Toutefois, le produit est trop petit pour modifier la valeur à virgule flottante d’origine. Son chiffre le moins significatif est millième, tandis que le chiffre le plus significatif du produit est de 10 ^{à 30}.

using System;

public class Example13
{
    public static void Main()
    {
        Single value = 123.456f;
        Single additional = Single.Epsilon * 1e15f;
        Console.WriteLine($"{value} + {additional} = {value + additional}");
    }
}
// The example displays the following output:
//    123.456 + 1.401298E-30 = 123.456

open System

let value = 123.456f
let additional = Single.Epsilon * 1e15f
printfn $"{value} + {additional} = {value + additional}"
// The example displays the following output:
//    123.456 + 1.401298E-30 = 123.456

Module Example
   Public Sub Main()
      Dim value As Single = 123.456
      Dim additional As Single = Single.Epsilon * 1e15
      Console.WriteLine($"{value} + {additional} = {value + additional}")
   End Sub
End Module
' The example displays the following output:
'   123.456 + 1.401298E-30 = 123.456

La précision limitée d’un nombre à virgule flottante a plusieurs conséquences :

• Deux nombres à virgule flottante qui apparaissent égaux pour une précision particulière peuvent ne pas l'être parce que leurs chiffres de droite sont différents. Dans l’exemple suivant, une série de nombres est ajoutée ensemble et leur total est comparé à son total attendu. Bien que les deux valeurs semblent être identiques, un appel à la Equals méthode indique qu’ils ne le sont pas.

  using System;
  
  public class Example9
  {
      public static void Main()
      {
          Single[] values = { 10.01f, 2.88f, 2.88f, 2.88f, 9.0f };
          Single result = 27.65f;
          Single total = 0f;
          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 (27.65) does not equal the total (27.65).   
  //
  // 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.6500015) does not equal the total (27.65).
  

  let values = [| 10.01f; 2.88f; 2.88f; 2.88f; 9f |]
  let result = 27.65f
  let mutable total = 0f
  for value in values do
      total <- total + value
  
  if total.Equals result then
      printfn "The sum of the values equals the total."
  else
      printfn "The sum of the values ({total}) does not equal the total ({result})."
  // The example displays the following output:
  //      The sum of the values (27.65) does not equal the total (27.65).   
  //
  // 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.6500015) does not equal the total (27.65).
  

  Module Example10
      Public Sub Main()
          Dim values() As Single = {10.01, 2.88, 2.88, 2.88, 9.0}
          Dim result As Single = 27.65
          Dim total As Single
          For Each value In values
              total += value
          Next
          If total.Equals(result) Then
              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)
          End If
      End Sub
  End Module
  ' The example displays the following output:
  '      The sum of the values (27.65) does not equal the total (27.65).   
  '
  ' 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 format de l’instruction Console.WriteLine(String, Object, Object){0}{1} et vers et {1:R} pour {0:R} afficher tous les chiffres significatifs des deux Single valeurs, il est clair que les deux valeurs sont inégales en raison d’une perte de précision pendant les opérations d’ajout. Dans ce cas, le problème peut être résolu en appelant la Math.Round(Double, Int32) méthode pour arrondir les Single valeurs à la précision souhaitée avant d’effectuer la comparaison.

• Une opération mathématique ou de comparaison qui utilise un nombre à virgule flottante peut ne pas produire le même résultat si un nombre décimal est utilisé, car le nombre à virgule flottante binaire peut ne pas être égal au nombre décimal. Un exemple précédent illustre cela en affichant le résultat de la multiplication de .3 par 10 et l’ajout de .3 à .3 neuf fois.

  Lorsque la précision dans les opérations numériques avec des valeurs fractionnaires est importante, utilisez le Decimal type au lieu du Single type. Lorsque la précision dans les opérations numériques avec des valeurs intégrales au-delà de la Int64 plage du ou UInt64 des types est importante, utilisez le BigInteger type.

• Une valeur peut ne pas aller-retour si un nombre à virgule flottante est impliqué. Une valeur est dite aller-retour si une opération convertit un nombre à virgule flottante d’origine en un autre formulaire, une opération inverse transforme le formulaire converti en nombre à virgule flottante et le nombre à virgule flottante finale est égal au nombre à virgule flottante d’origine. L’aller-retour peut échouer, car un ou plusieurs chiffres significatifs sont perdus ou modifiés dans une conversion. Dans l’exemple suivant, trois Single valeurs sont converties en chaînes et enregistrées dans un fichier. Comme le montre la sortie, bien que les valeurs semblent identiques, les valeurs restaurées ne sont pas égales aux valeurs d’origine.

  using System;
  using System.IO;
  
  public class Example10
  {
      public static void Main()
      {
          StreamWriter sw = new StreamWriter(@".\Singles.dat");
          Single[] values = { 3.2f / 1.11f, 1.0f / 3f, (float)Math.PI };
          for (int ctr = 0; ctr < values.Length; ctr++)
          {
              sw.Write(values[ctr].ToString());
              if (ctr != values.Length - 1)
                  sw.Write("|");
          }
          sw.Close();
  
          Single[] restoredValues = new Single[values.Length];
          StreamReader sr = new StreamReader(@".\Singles.dat");
          string temp = sr.ReadToEnd();
          string[] tempStrings = temp.Split('|');
          for (int ctr = 0; ctr < tempStrings.Length; ctr++)
              restoredValues[ctr] = Single.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.882883 <> 2.882883
  //       0.3333333 <> 0.3333333
  //       3.141593 <> 3.141593
  

  open System
  open System.IO
  
  let values = [| 3.2f / 1.11f; 1f / 3f; MathF.PI |]
  
  do
      use sw = new StreamWriter(@".\Singles.dat")
      for i = 0 to values.Length - 1 do
          sw.Write(string values[i])
          if i <> values.Length - 1 then
              sw.Write "|"
  
  let restoredValues =
      use sr = new StreamReader(@".\Singles.dat")
      sr.ReadToEnd().Split '|'
      |> Array.map Single.Parse
  
  for i = 0 to values.Length - 1 do
      printfn $"""{values[i]} {if values[i].Equals restoredValues[i] then "=" else "<>"} {restoredValues[i]}"""
                      
  // The example displays the following output:
  //       2.882883 <> 2.882883
  //       0.3333333 <> 0.3333333
  //       3.141593 <> 3.141593
  

  Imports System.IO
  
  Module Example11
      Public Sub Main()
          Dim sw As New StreamWriter(".\Singles.dat")
          Dim values() As Single = {3.2 / 1.11, 1.0 / 3, CSng(Math.PI)}
          For ctr As Integer = 0 To values.Length - 1
              sw.Write(values(ctr).ToString())
              If ctr <> values.Length - 1 Then sw.Write("|")
          Next
          sw.Close()
  
          Dim restoredValues(values.Length - 1) As Single
          Dim sr As New StreamReader(".\Singles.dat")
          Dim temp As String = sr.ReadToEnd()
          Dim tempStrings() As String = temp.Split("|"c)
          For ctr As Integer = 0 To tempStrings.Length - 1
              restoredValues(ctr) = Single.Parse(tempStrings(ctr))
          Next
  
          For ctr As Integer = 0 To values.Length - 1
              Console.WriteLine("{0} {2} {1}", values(ctr),
                             restoredValues(ctr),
                             If(values(ctr).Equals(restoredValues(ctr)), "=", "<>"))
          Next
      End Sub
  End Module
  ' The example displays the following output:
  '        2.882883 <> 2.882883
  '        0.3333333 <> 0.3333333
  '        3.141593 <> 3.141593
  

  Dans ce cas, les valeurs peuvent être correctement aller-retour à l’aide de la chaîne de format numérique standard « G9 » pour conserver la précision complète des Single valeurs, comme l’illustre l’exemple suivant.

  using System;
  using System.IO;
  
  public class Example11
  {
      public static void Main()
      {
          StreamWriter sw = new StreamWriter(@".\Singles.dat");
          Single[] values = { 3.2f / 1.11f, 1.0f / 3f, (float)Math.PI };
          for (int ctr = 0; ctr < values.Length; ctr++)
              sw.Write("{0:G9}{1}", values[ctr], ctr < values.Length - 1 ? "|" : "");
  
          sw.Close();
  
          Single[] restoredValues = new Single[values.Length];
          StreamReader sr = new StreamReader(@".\Singles.dat");
          string temp = sr.ReadToEnd();
          string[] tempStrings = temp.Split('|');
          for (int ctr = 0; ctr < tempStrings.Length; ctr++)
              restoredValues[ctr] = Single.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.882883 = 2.882883
  //       0.3333333 = 0.3333333
  //       3.141593 = 3.141593
  

  open System
  open System.IO
  
  let values = [| 3.2f / 1.11f; 1f / 3f; MathF.PI |]
  
  do
      use sw = new StreamWriter(@".\Singles.dat")
      for i = 0 to values.Length - 1 do
          sw.Write $"""{values[i]:G9}{if i < values.Length - 1 then "|" else ""}"""
      
      
  let restoredValues =
      use sr = new StreamReader(@".\Singles.dat")
      sr.ReadToEnd().Split '|'
      |> Array.map Single.Parse
  
  for i = 0 to values.Length - 1 do
      printfn $"""{values[i]} {if values[i].Equals restoredValues[i] then "=" else "<>"} {restoredValues[i]}"""
  // The example displays the following output:
  //       2.882883 = 2.882883
  //       0.3333333 = 0.3333333
  //       3.141593 = 3.141593
  

  Imports System.IO
  
  Module Example12
      Public Sub Main()
          Dim sw As New StreamWriter(".\Singles.dat")
          Dim values() As Single = {3.2 / 1.11, 1.0 / 3, CSng(Math.PI)}
          For ctr As Integer = 0 To values.Length - 1
              sw.Write("{0:G9}{1}", values(ctr),
                    If(ctr < values.Length - 1, "|", ""))
          Next
          sw.Close()
  
          Dim restoredValues(values.Length - 1) As Single
          Dim sr As New StreamReader(".\Singles.dat")
          Dim temp As String = sr.ReadToEnd()
          Dim tempStrings() As String = temp.Split("|"c)
          For ctr As Integer = 0 To tempStrings.Length - 1
              restoredValues(ctr) = Single.Parse(tempStrings(ctr))
          Next
  
          For ctr As Integer = 0 To values.Length - 1
              Console.WriteLine("{0} {2} {1}", values(ctr),
                             restoredValues(ctr),
                             If(values(ctr).Equals(restoredValues(ctr)), "=", "<>"))
          Next
      End Sub
  End Module
  ' The example displays the following output:
  '       2.882883 = 2.882883
  '       0.3333333 = 0.3333333
  '       3.141593 = 3.141593
  

• Single les valeurs ont moins de précision que les Double valeurs. Une Single valeur convertie en un équivalent apparemment équivalent Double ne correspond souvent pas à la Double valeur en raison de différences de précision. Dans l’exemple suivant, le résultat des opérations de division identiques est affecté à une Double valeur et à une Single valeur. Une fois que la Single valeur est convertie en un Double, une comparaison des deux valeurs indique qu’elles sont inégales.

  using System;
  
  public class Example9
  {
      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
  

  open System
  
  let value1 = 1. / 3.
  let sValue2 = 1f /3f
  
  let value2 = double sValue2
  printfn $"{value1:R} = {value2:R}: {value1.Equals value2}"
  // The example displays the following output:
  //        0.33333333333333331 = 0.3333333432674408: False
  

  Module Example10
      Public Sub Main()
          Dim value1 As Double = 1 / 3
          Dim sValue2 As Single = 1 / 3
          Dim value2 As Double = CDbl(sValue2)
          Console.WriteLine("{0} = {1}: {2}", value1, value2, value1.Equals(value2))
      End Sub
  End Module
  ' The example displays the following output:
  '       0.33333333333333331 = 0.3333333432674408: False
  

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

Tester l’égalité

Pour être considérées comme égales, deux Single valeurs doivent représenter des valeurs identiques. Toutefois, en raison de différences de précision entre les valeurs, ou en raison d’une perte de précision par une ou les deux valeurs, les valeurs à virgule flottante censées être identiques se révèlent souvent inégales en raison de différences dans leurs chiffres les moins significatifs. Par conséquent, les appels à la Equals méthode pour déterminer si deux valeurs sont égales ou si elles sont des appels à la CompareTo méthode pour déterminer la relation entre deux Single valeurs, produisent souvent des résultats inattendus. Cela est évident dans l’exemple suivant, où deux valeurs apparemment égales Single s’avèrent inégales, car la première valeur a 7 chiffres de précision, tandis que la deuxième valeur a 9.

using System;

public class Example
{
   public static void Main()
   {
      float value1 = .3333333f;
      float value2 = 1.0f/3;
      Console.WriteLine("{0:R} = {1:R}: {2}", value1, value2, value1.Equals(value2));
   }
}
// The example displays the following output:
//        0.3333333 = 0.333333343: False

let value1 = 0.3333333f
let value2 = 1f / 3f
printfn $"{value1:R} = {value2:R}: {value1.Equals value2}"
// The example displays the following output:
//        0.3333333 = 0.333333343: False

Module Example1
    Public Sub Main()
        Dim value1 As Single = 0.3333333
        Dim value2 As Single = 1 / 3
        Console.WriteLine("{0:R} = {1:R}: {2}", value1, value2, value1.Equals(value2))
    End Sub
End Module
' The example displays the following output:
'       0.3333333 = 0.333333343: False

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

using System;

public class Example1
{
    public static void Main()
    {
        float value1 = 10.201438f;
        value1 = (float)Math.Sqrt((float)Math.Pow(value1, 2));
        float value2 = (float)Math.Pow((float)value1 * 3.51f, 2);
        value2 = ((float)Math.Sqrt(value2)) / 3.51f;
        Console.WriteLine("{0} = {1}: {2}\n",
                          value1, value2, value1.Equals(value2));
        Console.WriteLine("{0:G9} = {1:G9}", value1, value2);
    }
}
// The example displays the following output:
//       10.20144 = 10.20144: False
//       
//       10.201438 = 10.2014389

let value1 = 
    10.201438f ** 2f
    |> sqrt

let value2 =
   ((value1 * 3.51f) ** 2f |> sqrt) / 3.51f

printfn $"{value1} = {value2}: {value1.Equals value2}\n" 
printfn $"{value1:G9} = {value2:G9}"
// The example displays the following output:
//       10.20144 = 10.20144: False
//       
//       10.201438 = 10.2014389

Module Example2
    Public Sub Main()
        Dim value1 As Single = 10.201438
        value1 = CSng(Math.Sqrt(CSng(Math.Pow(value1, 2))))
        Dim value2 As Single = CSng(Math.Pow(value1 * CSng(3.51), 2))
        value2 = CSng(Math.Sqrt(value2) / CSng(3.51))
        Console.WriteLine("{0} = {1}: {2}",
                        value1, value2, value1.Equals(value2))
        Console.WriteLine()
        Console.WriteLine("{0:G9} = {1:G9}", value1, value2)
    End Sub
End Module
' The example displays the following output:
'       10.20144 = 10.20144: False
'       
'       10.201438 = 10.2014389

Dans les cas où une perte de précision est susceptible d’affecter le résultat d’une comparaison, vous pouvez utiliser les techniques suivantes au lieu d’appeler la ou CompareTo la Equals méthode :

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

  using System;
  
  public class Example2
  {
      public static void Main()
      {
          float value1 = .3333333f;
          float value2 = 1.0f / 3;
          int precision = 7;
          value1 = (float)Math.Round(value1, precision);
          value2 = (float)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
  

  open System
  
  let value1 = 0.3333333f
  let value2 = 1f / 3f
  let precision = 7
  let value1r = Math.Round(float value1, precision) |> float32
  let value2r = Math.Round(float value2, precision) |> float32
  printfn $"{value1:R} = {value2:R}: {value1.Equals value2}"
  // The example displays the following output:
  //        0.3333333 = 0.3333333: True
  

  Module Example3
      Public Sub Main()
          Dim value1 As Single = 0.3333333
          Dim value2 As Single = 1 / 3
          Dim precision As Integer = 7
          value1 = CSng(Math.Round(value1, precision))
          value2 = CSng(Math.Round(value2, precision))
          Console.WriteLine("{0:R} = {1:R}: {2}", value1, value2, value1.Equals(value2))
      End Sub
  End Module
  ' The example displays the following output:
  '       0.3333333 = 0.3333333: True
  

  Le problème de précision s’applique toujours à l’arrondi des valeurs de milieu. Pour plus d'informations, voir la méthode Math.Round(Double, Int32, MidpointRounding).

• Testez l’égalité approximative au lieu de l’égalité. Cette technique exige que vous définissiez soit une quantité absolue par laquelle les deux valeurs peuvent différer, mais toujours être égales, soit que vous définissez une quantité relative par laquelle la valeur plus petite peut différer de la valeur la plus grande.

  Avertissement

  Single.Epsilon est parfois utilisé comme mesure absolue de la distance entre deux Single valeurs lors du test de l’égalité. Toutefois, Single.Epsilon mesure la plus petite valeur possible à laquelle ajouter ou soustraire une Single valeur dont la valeur est égale à zéro. Pour la plupart des valeurs positives et négatives Single , la valeur est Single.Epsilon trop petite pour être détectée. Par conséquent, à l’exception des valeurs qui sont égales à zéro, nous ne recommandons pas son utilisation dans les tests d’égalité.

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

  using System;
  
  public class Example3
  {
      public static void Main()
      {
          float one1 = .1f * 10;
          float one2 = 0f;
          for (int ctr = 1; ctr <= 10; ctr++)
              one2 += .1f;
  
          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, .000001f));
      }
  
      static bool IsApproximatelyEqual(float value1, float value2, float 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 = 1.00000012: False
  //       1 is approximately equal to 1.00000012: True
  

  open System
  
  let isApproximatelyEqual value1 value2 epsilon =
      // If they are equal anyway, just return True.
      if value1.Equals value2 then 
          true
      // Handle NaN, Infinity.
      elif Single.IsInfinity value1 || Single.IsNaN value1 then
          value1.Equals value2
      elif Single.IsInfinity value2 || Single.IsNaN value2 then
          value1.Equals value2
      else
          // Handle zero to avoid division by zero
          let divisor = max value1 value2
          let divisor = 
              if divisor.Equals 0 then
                  min value1 value2
              else divisor
          abs (value1 - value2) / divisor <= epsilon           
  
  
  let one1 = 0.1f * 10f
  let mutable one2 = 0f
  for _ = 1 to 10 do
     one2 <- one2 + 0.1f
  
  printfn $"{one1:R} = {one2:R}: {one1.Equals one2}"
  printfn $"{one1:R} is approximately equal to {one2:R}: {isApproximatelyEqual one1 one2 0.000001f}" 
  // The example displays the following output:
  //       1 = 1.00000012: False
  //       1 is approximately equal to 1.00000012: True
  

  Module Example4
      Public Sub Main()
          Dim one1 As Single = 0.1 * 10
          Dim one2 As Single = 0
          For ctr As Integer = 1 To 10
              one2 += CSng(0.1)
          Next
          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, 0.000001))
      End Sub
  
      Function IsApproximatelyEqual(value1 As Single, value2 As Single,
                                   epsilon As Single) As Boolean
          ' If they are equal anyway, just return True.
          If value1.Equals(value2) Then Return True
  
          ' Handle NaN, Infinity.
          If Single.IsInfinity(value1) Or Single.IsNaN(value1) Then
              Return value1.Equals(value2)
          ElseIf Single.IsInfinity(value2) Or Single.IsNaN(value2) Then
              Return value1.Equals(value2)
          End If
  
          ' Handle zero to avoid division by zero
          Dim divisor As Single = Math.Max(value1, value2)
          If divisor.Equals(0) Then
              divisor = Math.Min(value1, value2)
          End If
  
          Return Math.Abs(value1 - value2) / divisor <= epsilon
      End Function
  End Module
  ' The example displays the following output:
  '       1 = 1.00000012: False
  '       1 is approximately equal to 1.00000012: True
  

Valeurs et exceptions à virgule flottante

Les opérations avec des valeurs à virgule flottante ne lèvent pas d’exceptions, contrairement aux opérations avec des types intégraux, qui lèvent des exceptions dans les cas d’opérations illégales telles que la division par zéro ou dépassement de capacité. Au lieu de cela, dans ces situations, le résultat d’une opération à virgule flottante est zéro, l’infini positif, l’infini négatif, ou 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 est égal à zéro. Cela peut se produire lorsque deux nombres à virgule flottante très petits sont multipliés, comme l’illustre l’exemple suivant.

  using System;
  
  public class Example6
  {
      public static void Main()
      {
          float value1 = 1.163287e-36f;
          float value2 = 9.164234e-25f;
          float result = value1 * value2;
          Console.WriteLine("{0} * {1} = {2}", value1, value2, result);
          Console.WriteLine("{0} = 0: {1}", result, result.Equals(0.0f));
      }
  }
  // The example displays the following output:
  //       1.163287E-36 * 9.164234E-25 = 0
  //       0 = 0: True
  

  let value1 = 1.163287e-36f
  let value2 = 9.164234e-25f
  let result = value1 * value2
  printfn $"{value1} * {value2} = {result}"
  printfn $"{result} = 0: {result.Equals(0f)}"
  // The example displays the following output:
  //       1.163287E-36 * 9.164234E-25 = 0
  //       0 = 0: True
  

  Module Example7
      Public Sub Main()
          Dim value1 As Single = 1.163287E-36
          Dim value2 As Single = 9.164234E-25
          Dim result As Single = value1 * value2
          Console.WriteLine("{0} * {1} = {2:R}", value1, value2, result)
          Console.WriteLine("{0} = 0: {1}", result, result.Equals(0))
      End Sub
  End Module
  ' The example displays the following output:
  '       1.163287E-36 * 9.164234E-25 = 0
  '       0 = 0: True
  

• Si l’ampleur du résultat d’une opération à virgule flottante dépasse la plage du format de destination, le résultat de l’opération est PositiveInfinity ou NegativeInfinity, le cas échéant, pour le signe du résultat. Le résultat d’une opération qui dépasse Single.MaxValue est PositiveInfinity, et le résultat d’une opération qui dépasse Single.MinValue , NegativeInfinitycomme l’illustre l’exemple suivant.

  using System;
  
  public class Example7
  {
      public static void Main()
      {
          float value1 = 3.065e35f;
          float value2 = 6.9375e32f;
          float result = value1 * value2;
          Console.WriteLine("PositiveInfinity: {0}",
                             Single.IsPositiveInfinity(result));
          Console.WriteLine("NegativeInfinity: {0}\n",
                            Single.IsNegativeInfinity(result));
  
          value1 = -value1;
          result = value1 * value2;
          Console.WriteLine("PositiveInfinity: {0}",
                             Single.IsPositiveInfinity(result));
          Console.WriteLine("NegativeInfinity: {0}",
                            Single.IsNegativeInfinity(result));
      }
  }
  
  // The example displays the following output:
  //       PositiveInfinity: True
  //       NegativeInfinity: False
  //       
  //       PositiveInfinity: False
  //       NegativeInfinity: True
  

  open System
  
  let value1 = 3.065e35f
  let value2 = 6.9375e32f
  let result = value1 * value2
  printfn $"PositiveInfinity: {Single.IsPositiveInfinity result}" 
  printfn $"NegativeInfinity: {Single.IsNegativeInfinity result}\n"
  
  let value3 = -value1
  let result2 = value3 * value2
  printfn $"PositiveInfinity: {Single.IsPositiveInfinity result}" 
  printfn $"NegativeInfinity: {Single.IsNegativeInfinity result}" 
  
  // The example displays the following output:
  //       PositiveInfinity: True
  //       NegativeInfinity: False
  //       
  //       PositiveInfinity: False
  //       NegativeInfinity: True
  

  Module Example8
      Public Sub Main()
          Dim value1 As Single = 3.065E+35
          Dim value2 As Single = 6.9375E+32
          Dim result As Single = value1 * value2
          Console.WriteLine("PositiveInfinity: {0}",
                           Single.IsPositiveInfinity(result))
          Console.WriteLine("NegativeInfinity: {0}",
                          Single.IsNegativeInfinity(result))
          Console.WriteLine()
          value1 = -value1
          result = value1 * value2
          Console.WriteLine("PositiveInfinity: {0}",
                           Single.IsPositiveInfinity(result))
          Console.WriteLine("NegativeInfinity: {0}",
                          Single.IsNegativeInfinity(result))
      End Sub
  End Module
  ' 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 NegativeInfinity résulte d’une division par zéro avec un dividende négatif.

• Si une opération à virgule flottante n’est pas valide, le résultat de l’opération est NaN. Par exemple, NaN les résultats des opérations suivantes sont les suivants :

  • Division par zéro avec un dividende de zéro. Notez que d’autres cas de division par zéro entraînent l’un ou l’autre PositiveInfinityNegativeInfinitydes résultats.
  • Toute opération à virgule flottante avec une entrée non valide. Par exemple, la tentative de recherche de la racine carrée d’une valeur négative retourne NaN.
  • Toute opération avec un argument dont la valeur est Single.NaN.

Conversions des types

La Single structure ne définit pas d’opérateurs de conversion explicites ou implicites ; à la place, les conversions sont implémentées par le compilateur.

Le tableau suivant répertorie les conversions possibles d’une valeur des autres types numériques primitifs en Single valeur, elle indique également si la conversion est étendue ou étroite et si le résultat Single peut avoir moins de précision que la valeur d’origine.

Conversion de	Élargissement/rétrécissement	Perte possible de précision
Byte	Widening	Non
Decimal	Widening Notez que C# nécessite un opérateur de cast.	Oui. Decimal prend en charge 29 chiffres décimaux de précision ; Single prend en charge 9.
Double	Rétrécissement; Les valeurs hors plage sont converties en Double.NegativeInfinity ou Double.PositiveInfinity.	Oui. Double prend en charge 17 chiffres décimaux de précision ; Single prend en charge 9.
Int16	Widening	Non
Int32	Widening	Oui. Int32 prend en charge 10 chiffres décimaux de précision ; Single prend en charge 9.
Int64	Widening	Oui. Int64 prend en charge 19 chiffres décimaux de précision ; Single prend en charge 9.
SByte	Widening	Non
UInt16	Widening	Non
UInt32	Widening	Oui. UInt32 prend en charge 10 chiffres décimaux de précision ; Single prend en charge 9.
UInt64	Widening	Oui. Int64 prend en charge 20 chiffres décimaux de précision ; Single prend en charge 9.

L’exemple suivant convertit la valeur minimale ou maximale d’autres types numériques primitifs en Single valeur.

using System;

public class Example4
{
    public static void Main()
    {
        dynamic[] values = { Byte.MinValue, Byte.MaxValue, Decimal.MinValue,
                           Decimal.MaxValue, Double.MinValue, Double.MaxValue,
                           Int16.MinValue, Int16.MaxValue, Int32.MinValue,
                           Int32.MaxValue, Int64.MinValue, Int64.MaxValue,
                           SByte.MinValue, SByte.MaxValue, UInt16.MinValue,
                           UInt16.MaxValue, UInt32.MinValue, UInt32.MaxValue,
                           UInt64.MinValue, UInt64.MaxValue };
        float sngValue;
        foreach (var value in values)
        {
            if (value.GetType() == typeof(Decimal) ||
                value.GetType() == typeof(Double))
                sngValue = (float)value;
            else
                sngValue = value;
            Console.WriteLine("{0} ({1}) --> {2:R} ({3})",
                              value, value.GetType().Name,
                              sngValue, sngValue.GetType().Name);
        }
    }
}
// The example displays the following output:
//       0 (Byte) --> 0 (Single)
//       255 (Byte) --> 255 (Single)
//       -79228162514264337593543950335 (Decimal) --> -7.92281625E+28 (Single)
//       79228162514264337593543950335 (Decimal) --> 7.92281625E+28 (Single)
//       -1.79769313486232E+308 (Double) --> -Infinity (Single)
//       1.79769313486232E+308 (Double) --> Infinity (Single)
//       -32768 (Int16) --> -32768 (Single)
//       32767 (Int16) --> 32767 (Single)
//       -2147483648 (Int32) --> -2.14748365E+09 (Single)
//       2147483647 (Int32) --> 2.14748365E+09 (Single)
//       -9223372036854775808 (Int64) --> -9.223372E+18 (Single)
//       9223372036854775807 (Int64) --> 9.223372E+18 (Single)
//       -128 (SByte) --> -128 (Single)
//       127 (SByte) --> 127 (Single)
//       0 (UInt16) --> 0 (Single)
//       65535 (UInt16) --> 65535 (Single)
//       0 (UInt32) --> 0 (Single)
//       4294967295 (UInt32) --> 4.2949673E+09 (Single)
//       0 (UInt64) --> 0 (Single)
//       18446744073709551615 (UInt64) --> 1.84467441E+19 (Single)

open System

let values: obj list = 
    [ Byte.MinValue; Byte.MaxValue; Decimal.MinValue
      Decimal.MaxValue; Double.MinValue; Double.MaxValue
      Int16.MinValue; Int16.MaxValue; Int32.MinValue
      Int32.MaxValue; Int64.MinValue; Int64.MaxValue
      SByte.MinValue; SByte.MaxValue; UInt16.MinValue
      UInt16.MaxValue; UInt32.MinValue; UInt32.MaxValue
      UInt64.MinValue; UInt64.MaxValue ]

for value in values do
    let sngValue = 
        match value with
        | :? byte as v -> float32 v
        | :? decimal as v -> float32 v
        | :? double as v -> float32 v
        | :? int16 as v -> float32 v
        | :? int as v -> float32 v
        | :? int64 as v -> float32 v
        | :? int8 as v -> float32 v
        | :? uint16 as v -> float32 v
        | :? uint as v -> float32 v
        | :? uint64 as v -> float32 v
        | _ -> raise (NotImplementedException "Unknown Type")
    printfn $"{value} ({value.GetType().Name}) --> {sngValue:R} ({sngValue.GetType().Name})"
// The example displays the following output:
//       0 (Byte) --> 0 (Single)
//       255 (Byte) --> 255 (Single)
//       -79228162514264337593543950335 (Decimal) --> -7.92281625E+28 (Single)
//       79228162514264337593543950335 (Decimal) --> 7.92281625E+28 (Single)
//       -1.79769313486232E+308 (Double) --> -Infinity (Single)
//       1.79769313486232E+308 (Double) --> Infinity (Single)
//       -32768 (Int16) --> -32768 (Single)
//       32767 (Int16) --> 32767 (Single)
//       -2147483648 (Int32) --> -2.14748365E+09 (Single)
//       2147483647 (Int32) --> 2.14748365E+09 (Single)
//       -9223372036854775808 (Int64) --> -9.223372E+18 (Single)
//       9223372036854775807 (Int64) --> 9.223372E+18 (Single)
//       -128 (SByte) --> -128 (Single)
//       127 (SByte) --> 127 (Single)
//       0 (UInt16) --> 0 (Single)
//       65535 (UInt16) --> 65535 (Single)
//       0 (UInt32) --> 0 (Single)
//       4294967295 (UInt32) --> 4.2949673E+09 (Single)
//       0 (UInt64) --> 0 (Single)
//       18446744073709551615 (UInt64) --> 1.84467441E+19 (Single)

Module Example5
    Public Sub Main()
        Dim values() As Object = {Byte.MinValue, Byte.MaxValue, Decimal.MinValue,
                                 Decimal.MaxValue, Double.MinValue, Double.MaxValue,
                                 Int16.MinValue, Int16.MaxValue, Int32.MinValue,
                                 Int32.MaxValue, Int64.MinValue, Int64.MaxValue,
                                 SByte.MinValue, SByte.MaxValue, UInt16.MinValue,
                                 UInt16.MaxValue, UInt32.MinValue, UInt32.MaxValue,
                                 UInt64.MinValue, UInt64.MaxValue}
        Dim sngValue As Single
        For Each value In values
            If value.GetType() = GetType(Double) Then
                sngValue = CSng(value)
            Else
                sngValue = value
            End If
            Console.WriteLine("{0} ({1}) --> {2:R} ({3})",
                           value, value.GetType().Name,
                           sngValue, sngValue.GetType().Name)
        Next
    End Sub
End Module
' The example displays the following output:
'       0 (Byte) --> 0 (Single)
'       255 (Byte) --> 255 (Single)
'       -79228162514264337593543950335 (Decimal) --> -7.92281625E+28 (Single)
'       79228162514264337593543950335 (Decimal) --> 7.92281625E+28 (Single)
'       -1.79769313486232E+308 (Double) --> -Infinity (Single)
'       1.79769313486232E+308 (Double) --> Infinity (Single)
'       -32768 (Int16) --> -32768 (Single)
'       32767 (Int16) --> 32767 (Single)
'       -2147483648 (Int32) --> -2.14748365E+09 (Single)
'       2147483647 (Int32) --> 2.14748365E+09 (Single)
'       -9223372036854775808 (Int64) --> -9.223372E+18 (Single)
'       9223372036854775807 (Int64) --> 9.223372E+18 (Single)
'       -128 (SByte) --> -128 (Single)
'       127 (SByte) --> 127 (Single)
'       0 (UInt16) --> 0 (Single)
'       65535 (UInt16) --> 65535 (Single)
'       0 (UInt32) --> 0 (Single)
'       4294967295 (UInt32) --> 4.2949673E+09 (Single)
'       0 (UInt64) --> 0 (Single)
'       18446744073709551615 (UInt64) --> 1.84467441E+19 (Single)

En outre, les Double valeurs Double.NaN, Double.PositiveInfinityet Double.NegativeInfinity convertissent en Single.NaN, Single.PositiveInfinityet Single.NegativeInfinity, respectivement.

Notez que la conversion de la valeur de certains types numériques en valeur Single peut impliquer une perte de précision. Comme l’illustre l’exemple, une perte de précision est possible lors de la conversion Decimal, , , Int32Double, Int64, UInt32et UInt64 des valeurs en Single valeurs.

La conversion d’une Single valeur en valeur Double est une conversion étendue. La conversion peut entraîner une perte de précision si le Double type n’a pas de représentation précise pour la Single valeur.

La conversion d’une Single valeur en valeur d’un type de données numérique primitif autre qu’une Double conversion étroite nécessite un opérateur de cast (en C#) ou une méthode de conversion (en Visual Basic). Les valeurs qui se trouvent en dehors de la plage du type de données cible, qui sont définies par les propriétés et MaxValue le type MinValue cible, se comportent comme indiqué dans le tableau suivant.

Type cible	Result
Tout type intégral	Exception OverflowException si la conversion se produit dans un contexte case activée ed. Si la conversion se produit dans un contexte non case activée ed (valeur par défaut en C#), l’opération de conversion réussit, mais la valeur dépasse.
Decimal	Exception OverflowException ,

En outre, Single.NaNet Single.PositiveInfinitySingle.NegativeInfinity lèvez une OverflowException pour les conversions en entiers dans un contexte case activée ed, mais ces valeurs dépassent lorsqu’elles sont converties en entiers dans un contexte non case activée ed. Pour les conversions en Decimal, ils lèvent toujours un OverflowException. Pour les conversions en Double, ils se convertissent en Double.NaN, Double.PositiveInfinityet Double.NegativeInfinity, respectivement.

Notez qu’une perte de précision peut entraîner la conversion d’une Single valeur en un autre type numérique. Dans le cas de la conversion de valeurs non intégrales, comme le montre la sortie de l’exemple, le composant fractionnaire Single est perdu lorsque la Single valeur est arrondie (comme dans Visual Basic) ou tronquée (comme en C# et F#). Pour les conversions en Decimal valeurs, la Single valeur peut ne pas avoir de représentation précise dans le type de données cible.

L’exemple suivant convertit un certain nombre de Single valeurs en plusieurs autres types numériques. Les conversions se produisent dans un contexte case activée en Visual Basic (valeur par défaut), en C# (en raison du case activée mot clé) et en F# (en raison de l’instructionopen Checked). La sortie de l’exemple montre le résultat des conversions dans une case activée un contexte non case activée ed. Vous pouvez effectuer des conversions dans un contexte non case activée en Visual Basic en compilant avec le commutateur du /removeintchecks+ compilateur, en C# en commentant l’instruction checked et en F# en commentant l’instructionopen Checked.

using System;

public class Example5
{
    public static void Main()
    {
        float[] values = { Single.MinValue, -67890.1234f, -12345.6789f,
                         12345.6789f, 67890.1234f, Single.MaxValue,
                         Single.NaN, Single.PositiveInfinity,
                         Single.NegativeInfinity };
        checked
        {
            foreach (var value in values)
            {
                try
                {
                    Int64 lValue = (long)value;
                    Console.WriteLine("{0} ({1}) --> {2} (0x{2:X16}) ({3})",
                                      value, value.GetType().Name,
                                      lValue, lValue.GetType().Name);
                }
                catch (OverflowException)
                {
                    Console.WriteLine("Unable to convert {0} to Int64.", value);
                }
                try
                {
                    UInt64 ulValue = (ulong)value;
                    Console.WriteLine("{0} ({1}) --> {2} (0x{2:X16}) ({3})",
                                      value, value.GetType().Name,
                                      ulValue, ulValue.GetType().Name);
                }
                catch (OverflowException)
                {
                    Console.WriteLine("Unable to convert {0} to UInt64.", value);
                }
                try
                {
                    Decimal dValue = (decimal)value;
                    Console.WriteLine("{0} ({1}) --> {2} ({3})",
                                      value, value.GetType().Name,
                                      dValue, dValue.GetType().Name);
                }
                catch (OverflowException)
                {
                    Console.WriteLine("Unable to convert {0} to Decimal.", value);
                }

                Double dblValue = value;
                Console.WriteLine("{0} ({1}) --> {2} ({3})",
                                  value, value.GetType().Name,
                                  dblValue, dblValue.GetType().Name);
                Console.WriteLine();
            }
        }
    }
}
// The example displays the following output for conversions performed
// in a checked context:
//       Unable to convert -3.402823E+38 to Int64.
//       Unable to convert -3.402823E+38 to UInt64.
//       Unable to convert -3.402823E+38 to Decimal.
//       -3.402823E+38 (Single) --> -3.40282346638529E+38 (Double)
//
//       -67890.13 (Single) --> -67890 (0xFFFFFFFFFFFEF6CE) (Int64)
//       Unable to convert -67890.13 to UInt64.
//       -67890.13 (Single) --> -67890.12 (Decimal)
//       -67890.13 (Single) --> -67890.125 (Double)
//
//       -12345.68 (Single) --> -12345 (0xFFFFFFFFFFFFCFC7) (Int64)
//       Unable to convert -12345.68 to UInt64.
//       -12345.68 (Single) --> -12345.68 (Decimal)
//       -12345.68 (Single) --> -12345.6787109375 (Double)
//
//       12345.68 (Single) --> 12345 (0x0000000000003039) (Int64)
//       12345.68 (Single) --> 12345 (0x0000000000003039) (UInt64)
//       12345.68 (Single) --> 12345.68 (Decimal)
//       12345.68 (Single) --> 12345.6787109375 (Double)
//
//       67890.13 (Single) --> 67890 (0x0000000000010932) (Int64)
//       67890.13 (Single) --> 67890 (0x0000000000010932) (UInt64)
//       67890.13 (Single) --> 67890.12 (Decimal)
//       67890.13 (Single) --> 67890.125 (Double)
//
//       Unable to convert 3.402823E+38 to Int64.
//       Unable to convert 3.402823E+38 to UInt64.
//       Unable to convert 3.402823E+38 to Decimal.
//       3.402823E+38 (Single) --> 3.40282346638529E+38 (Double)
//
//       Unable to convert NaN to Int64.
//       Unable to convert NaN to UInt64.
//       Unable to convert NaN to Decimal.
//       NaN (Single) --> NaN (Double)
//
//       Unable to convert Infinity to Int64.
//       Unable to convert Infinity to UInt64.
//       Unable to convert Infinity to Decimal.
//       Infinity (Single) --> Infinity (Double)
//
//       Unable to convert -Infinity to Int64.
//       Unable to convert -Infinity to UInt64.
//       Unable to convert -Infinity to Decimal.
//       -Infinity (Single) --> -Infinity (Double)
// The example displays the following output for conversions performed
// in an unchecked context:
//       -3.402823E+38 (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       -3.402823E+38 (Single) --> 9223372036854775808 (0x8000000000000000) (UInt64)
//       Unable to convert -3.402823E+38 to Decimal.
//       -3.402823E+38 (Single) --> -3.40282346638529E+38 (Double)
//
//       -67890.13 (Single) --> -67890 (0xFFFFFFFFFFFEF6CE) (Int64)
//       -67890.13 (Single) --> 18446744073709483726 (0xFFFFFFFFFFFEF6CE) (UInt64)
//       -67890.13 (Single) --> -67890.12 (Decimal)
//       -67890.13 (Single) --> -67890.125 (Double)
//
//       -12345.68 (Single) --> -12345 (0xFFFFFFFFFFFFCFC7) (Int64)
//       -12345.68 (Single) --> 18446744073709539271 (0xFFFFFFFFFFFFCFC7) (UInt64)
//       -12345.68 (Single) --> -12345.68 (Decimal)
//       -12345.68 (Single) --> -12345.6787109375 (Double)
//
//       12345.68 (Single) --> 12345 (0x0000000000003039) (Int64)
//       12345.68 (Single) --> 12345 (0x0000000000003039) (UInt64)
//       12345.68 (Single) --> 12345.68 (Decimal)
//       12345.68 (Single) --> 12345.6787109375 (Double)
//
//       67890.13 (Single) --> 67890 (0x0000000000010932) (Int64)
//       67890.13 (Single) --> 67890 (0x0000000000010932) (UInt64)
//       67890.13 (Single) --> 67890.12 (Decimal)
//       67890.13 (Single) --> 67890.125 (Double)
//
//       3.402823E+38 (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       3.402823E+38 (Single) --> 0 (0x0000000000000000) (UInt64)
//       Unable to convert 3.402823E+38 to Decimal.
//       3.402823E+38 (Single) --> 3.40282346638529E+38 (Double)
//
//       NaN (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       NaN (Single) --> 0 (0x0000000000000000) (UInt64)
//       Unable to convert NaN to Decimal.
//       NaN (Single) --> NaN (Double)
//
//       Infinity (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       Infinity (Single) --> 0 (0x0000000000000000) (UInt64)
//       Unable to convert Infinity to Decimal.
//       Infinity (Single) --> Infinity (Double)
//
//       -Infinity (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       -Infinity (Single) --> 9223372036854775808 (0x8000000000000000) (UInt64)
//       Unable to convert -Infinity to Decimal.
//       -Infinity (Single) --> -Infinity (Double)

open System
open Checked

let values = 
    [ Single.MinValue; -67890.1234f; -12345.6789f
      12345.6789f; 67890.1234f; Single.MaxValue
      Single.NaN; Single.PositiveInfinity
      Single.NegativeInfinity ]

for value in values do
    try
        let lValue = int64 value
        printfn $"{value} ({value.GetType().Name}) --> {lValue} (0x{lValue:X16}) ({lValue.GetType().Name})"
    with :? OverflowException ->
        printfn $"Unable to convert {value} to Int64."
    try
        let ulValue = uint64 value
        printfn $"{value} ({value.GetType().Name}) --> {ulValue} (0x{ulValue:X16}) ({ulValue.GetType().Name})"
    with :? OverflowException ->
        printfn $"Unable to convert {value} to UInt64."
    try
        let dValue = decimal value
        printfn $"{value} ({value.GetType().Name}) --> {dValue} ({dValue.GetType().Name})"
    with :? OverflowException ->
        printfn $"Unable to convert {value} to Decimal."

    let dblValue = double value
    printfn $"{value} ({value.GetType().Name}) --> {dblValue} ({dblValue.GetType().Name})\n"
// The example displays the following output for conversions performed
// in a checked context:
//       Unable to convert -3.402823E+38 to Int64.
//       Unable to convert -3.402823E+38 to UInt64.
//       Unable to convert -3.402823E+38 to Decimal.
//       -3.402823E+38 (Single) --> -3.40282346638529E+38 (Double)
//
//       -67890.13 (Single) --> -67890 (0xFFFFFFFFFFFEF6CE) (Int64)
//       Unable to convert -67890.13 to UInt64.
//       -67890.13 (Single) --> -67890.12 (Decimal)
//       -67890.13 (Single) --> -67890.125 (Double)
//
//       -12345.68 (Single) --> -12345 (0xFFFFFFFFFFFFCFC7) (Int64)
//       Unable to convert -12345.68 to UInt64.
//       -12345.68 (Single) --> -12345.68 (Decimal)
//       -12345.68 (Single) --> -12345.6787109375 (Double)
//
//       12345.68 (Single) --> 12345 (0x0000000000003039) (Int64)
//       12345.68 (Single) --> 12345 (0x0000000000003039) (UInt64)
//       12345.68 (Single) --> 12345.68 (Decimal)
//       12345.68 (Single) --> 12345.6787109375 (Double)
//
//       67890.13 (Single) --> 67890 (0x0000000000010932) (Int64)
//       67890.13 (Single) --> 67890 (0x0000000000010932) (UInt64)
//       67890.13 (Single) --> 67890.12 (Decimal)
//       67890.13 (Single) --> 67890.125 (Double)
//
//       Unable to convert 3.402823E+38 to Int64.
//       Unable to convert 3.402823E+38 to UInt64.
//       Unable to convert 3.402823E+38 to Decimal.
//       3.402823E+38 (Single) --> 3.40282346638529E+38 (Double)
//
//       Unable to convert NaN to Int64.
//       Unable to convert NaN to UInt64.
//       Unable to convert NaN to Decimal.
//       NaN (Single) --> NaN (Double)
//
//       Unable to convert Infinity to Int64.
//       Unable to convert Infinity to UInt64.
//       Unable to convert Infinity to Decimal.
//       Infinity (Single) --> Infinity (Double)
//
//       Unable to convert -Infinity to Int64.
//       Unable to convert -Infinity to UInt64.
//       Unable to convert -Infinity to Decimal.
//       -Infinity (Single) --> -Infinity (Double)
// The example displays the following output for conversions performed
// in an unchecked context:
//       -3.402823E+38 (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       -3.402823E+38 (Single) --> 9223372036854775808 (0x8000000000000000) (UInt64)
//       Unable to convert -3.402823E+38 to Decimal.
//       -3.402823E+38 (Single) --> -3.40282346638529E+38 (Double)
//
//       -67890.13 (Single) --> -67890 (0xFFFFFFFFFFFEF6CE) (Int64)
//       -67890.13 (Single) --> 18446744073709483726 (0xFFFFFFFFFFFEF6CE) (UInt64)
//       -67890.13 (Single) --> -67890.12 (Decimal)
//       -67890.13 (Single) --> -67890.125 (Double)
//
//       -12345.68 (Single) --> -12345 (0xFFFFFFFFFFFFCFC7) (Int64)
//       -12345.68 (Single) --> 18446744073709539271 (0xFFFFFFFFFFFFCFC7) (UInt64)
//       -12345.68 (Single) --> -12345.68 (Decimal)
//       -12345.68 (Single) --> -12345.6787109375 (Double)
//
//       12345.68 (Single) --> 12345 (0x0000000000003039) (Int64)
//       12345.68 (Single) --> 12345 (0x0000000000003039) (UInt64)
//       12345.68 (Single) --> 12345.68 (Decimal)
//       12345.68 (Single) --> 12345.6787109375 (Double)
//
//       67890.13 (Single) --> 67890 (0x0000000000010932) (Int64)
//       67890.13 (Single) --> 67890 (0x0000000000010932) (UInt64)
//       67890.13 (Single) --> 67890.12 (Decimal)
//       67890.13 (Single) --> 67890.125 (Double)
//
//       3.402823E+38 (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       3.402823E+38 (Single) --> 0 (0x0000000000000000) (UInt64)
//       Unable to convert 3.402823E+38 to Decimal.
//       3.402823E+38 (Single) --> 3.40282346638529E+38 (Double)
//
//       NaN (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       NaN (Single) --> 0 (0x0000000000000000) (UInt64)
//       Unable to convert NaN to Decimal.
//       NaN (Single) --> NaN (Double)
//
//       Infinity (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       Infinity (Single) --> 0 (0x0000000000000000) (UInt64)
//       Unable to convert Infinity to Decimal.
//       Infinity (Single) --> Infinity (Double)
//
//       -Infinity (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       -Infinity (Single) --> 9223372036854775808 (0x8000000000000000) (UInt64)
//       Unable to convert -Infinity to Decimal.
//       -Infinity (Single) --> -Infinity (Double)

Module Example6
    Public Sub Main()
        Dim values() As Single = {Single.MinValue, -67890.1234, -12345.6789,
                                 12345.6789, 67890.1234, Single.MaxValue,
                                 Single.NaN, Single.PositiveInfinity,
                                 Single.NegativeInfinity}
        For Each value In values
            Try
                Dim lValue As Long = CLng(value)
                Console.WriteLine("{0} ({1}) --> {2} (0x{2:X16}) ({3})",
                               value, value.GetType().Name,
                               lValue, lValue.GetType().Name)
            Catch e As OverflowException
                Console.WriteLine("Unable to convert {0} to Int64.", value)
            End Try
            Try
                Dim ulValue As UInt64 = CULng(value)
                Console.WriteLine("{0} ({1}) --> {2} (0x{2:X16}) ({3})",
                               value, value.GetType().Name,
                               ulValue, ulValue.GetType().Name)
            Catch e As OverflowException
                Console.WriteLine("Unable to convert {0} to UInt64.", value)
            End Try
            Try
                Dim dValue As Decimal = CDec(value)
                Console.WriteLine("{0} ({1}) --> {2} ({3})",
                               value, value.GetType().Name,
                               dValue, dValue.GetType().Name)
            Catch e As OverflowException
                Console.WriteLine("Unable to convert {0} to Decimal.", value)
            End Try

            Dim dblValue As Double = value
            Console.WriteLine("{0} ({1}) --> {2} ({3})",
                           value, value.GetType().Name,
                           dblValue, dblValue.GetType().Name)
            Console.WriteLine()
        Next
    End Sub
End Module
' The example displays the following output for conversions performed
' in a checked context:
'       Unable to convert -3.402823E+38 to Int64.
'       Unable to convert -3.402823E+38 to UInt64.
'       Unable to convert -3.402823E+38 to Decimal.
'       -3.402823E+38 (Single) --> -3.40282346638529E+38 (Double)
'
'       -67890.13 (Single) --> -67890 (0xFFFFFFFFFFFEF6CE) (Int64)
'       Unable to convert -67890.13 to UInt64.
'       -67890.13 (Single) --> -67890.12 (Decimal)
'       -67890.13 (Single) --> -67890.125 (Double)
'
'       -12345.68 (Single) --> -12346 (0xFFFFFFFFFFFFCFC6) (Int64)
'       Unable to convert -12345.68 to UInt64.
'       -12345.68 (Single) --> -12345.68 (Decimal)
'       -12345.68 (Single) --> -12345.6787109375 (Double)
'
'       12345.68 (Single) --> 12346 (0x000000000000303A) (Int64)
'       12345.68 (Single) --> 12346 (0x000000000000303A) (UInt64)
'       12345.68 (Single) --> 12345.68 (Decimal)
'       12345.68 (Single) --> 12345.6787109375 (Double)
'
'       67890.13 (Single) --> 67890 (0x0000000000010932) (Int64)
'       67890.13 (Single) --> 67890 (0x0000000000010932) (UInt64)
'       67890.13 (Single) --> 67890.12 (Decimal)
'       67890.13 (Single) --> 67890.125 (Double)
'
'       Unable to convert 3.402823E+38 to Int64.
'       Unable to convert 3.402823E+38 to UInt64.
'       Unable to convert 3.402823E+38 to Decimal.
'       3.402823E+38 (Single) --> 3.40282346638529E+38 (Double)
'
'       Unable to convert NaN to Int64.
'       Unable to convert NaN to UInt64.
'       Unable to convert NaN to Decimal.
'       NaN (Single) --> NaN (Double)
'
'       Unable to convert Infinity to Int64.
'       Unable to convert Infinity to UInt64.
'       Unable to convert Infinity to Decimal.
'       Infinity (Single) --> Infinity (Double)
'
'       Unable to convert -Infinity to Int64.
'       Unable to convert -Infinity to UInt64.
'       Unable to convert -Infinity to Decimal.
'       -Infinity (Single) --> -Infinity (Double)
' The example displays the following output for conversions performed
' in an unchecked context:
'       -3.402823E+38 (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
'       -3.402823E+38 (Single) --> 9223372036854775808 (0x8000000000000000) (UInt64)
'       Unable to convert -3.402823E+38 to Decimal.
'       -3.402823E+38 (Single) --> -3.40282346638529E+38 (Double)
'
'       -67890.13 (Single) --> -67890 (0xFFFFFFFFFFFEF6CE) (Int64)
'       -67890.13 (Single) --> 18446744073709483726 (0xFFFFFFFFFFFEF6CE) (UInt64)
'       -67890.13 (Single) --> -67890.12 (Decimal)
'       -67890.13 (Single) --> -67890.125 (Double)
'
'       -12345.68 (Single) --> -12346 (0xFFFFFFFFFFFFCFC6) (Int64)
'       -12345.68 (Single) --> 18446744073709539270 (0xFFFFFFFFFFFFCFC6) (UInt64)
'       -12345.68 (Single) --> -12345.68 (Decimal)
'       -12345.68 (Single) --> -12345.6787109375 (Double)
'
'       12345.68 (Single) --> 12346 (0x000000000000303A) (Int64)
'       12345.68 (Single) --> 12346 (0x000000000000303A) (UInt64)
'       12345.68 (Single) --> 12345.68 (Decimal)
'       12345.68 (Single) --> 12345.6787109375 (Double)
'
'       67890.13 (Single) --> 67890 (0x0000000000010932) (Int64)
'       67890.13 (Single) --> 67890 (0x0000000000010932) (UInt64)
'       67890.13 (Single) --> 67890.12 (Decimal)
'       67890.13 (Single) --> 67890.125 (Double)
'
'       3.402823E+38 (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
'       3.402823E+38 (Single) --> 0 (0x0000000000000000) (UInt64)
'       Unable to convert 3.402823E+38 to Decimal.
'       3.402823E+38 (Single) --> 3.40282346638529E+38 (Double)
'
'       NaN (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
'       NaN (Single) --> 0 (0x0000000000000000) (UInt64)
'       Unable to convert NaN to Decimal.
'       NaN (Single) --> NaN (Double)
'
'       Infinity (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
'       Infinity (Single) --> 0 (0x0000000000000000) (UInt64)
'       Unable to convert Infinity to Decimal.
'       Infinity (Single) --> Infinity (Double)
'
'       -Infinity (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
'       -Infinity (Single) --> 9223372036854775808 (0x8000000000000000) (UInt64)
'       Unable to convert -Infinity to Decimal.
'       -Infinity (Single) --> -Infinity (Double)

Pour plus d’informations sur la conversion de types numériques, consultez Conversion de type dans les tables de conversion de types .NET et Type.

Fonctionnalité à virgule flottante

La Single structure et les types associés fournissent des méthodes pour effectuer les catégories d’opérations suivantes :

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

  La Single structure prend également en charge un ensemble 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 valeur. Si l’un des opérandes est un Double, la Single valeur est convertie en une Double avant d’effectuer la comparaison. Si l’un des opérandes est un type intégral, il est converti en un Single avant d’effectuer la comparaison. Bien que ces conversions s’étendent, elles peuvent impliquer une perte de précision.

  Avertissement

  En raison des différences de précision, deux Single valeurs que vous prévoyez d’être égales peuvent s’avérer inégales, ce qui affecte le résultat de la comparaison. Pour plus d’informations sur la comparaison de deux Single valeurs, consultez la section Test pour l’égalité.

  Vous pouvez également appeler les IsNaNméthodes , et IsInfinityIsPositiveInfinityIsNegativeInfinity les méthodes pour tester ces valeurs spéciales.

• Opérations mathématiques. Les opérations arithmétiques courantes telles que l’ajout, la soustraction, la multiplication et la division sont implémentées par les compilateurs de langage et les instructions CIL (Common Intermediate Language) plutôt que par Single des méthodes. Si l’autre opérande d’une opération mathématique est un Double, il Single est converti en une Double avant d’effectuer l’opération, et le résultat de l’opération est également une Double valeur. Si l’autre opérande est un type intégral, il est converti en un Single avant d’effectuer l’opération, et le résultat de l’opération est également une Single valeur.

  Vous pouvez effectuer d’autres opérations mathématiques en appelant static (Shared en Visual Basic) des méthodes dans la System.Math classe. Il s’agit notamment de méthodes supplémentaires couramment utilisées pour l’arithmétique (par Math.Absexemple, , Math.Signet Math.Sqrt), la géométrie (par Math.Cos exemple et Math.Sin) et le calcul (par Math.Logexemple). Dans tous les cas, la Single valeur est convertie en Double.

  Vous pouvez également manipuler les bits individuels dans une Single valeur. La BitConverter.GetBytes(Single) méthode retourne son modèle de bits dans un tableau d’octets. En passant ce tableau d’octets à la BitConverter.ToInt32 méthode, vous pouvez également conserver le modèle de bits de la Single valeur dans un entier 32 bits.

• Arrondi. L’arrondi est souvent utilisé comme technique pour réduire l’impact des différences entre les valeurs causées par des problèmes de représentation à virgule flottante et de précision. Vous pouvez arrondir une Single valeur en appelant la Math.Round méthode. Toutefois, notez que la Single valeur est convertie en une Double avant l’appel de la méthode et que la conversion peut impliquer une perte de précision.

• Mise en forme. Vous pouvez convertir une Single valeur en sa représentation sous forme de chaîne en appelant la ToString méthode 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 de valeurs à virgule flottante, consultez les rubriques Chaînes de format numérique standard et chaînes de format numérique personnalisées .

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

• Conversion de type. La Single structure fournit une implémentation d’interface explicite pour l’interface, qui prend en charge la IConvertible conversion entre deux types de données .NET standard. Les compilateurs de langage prennent également en charge la conversion implicite de valeurs pour tous les autres types numériques standard, à l’exception de la conversion de Double valeurs Single . La conversion d’une valeur d’un type numérique standard autre qu’un Double type vers un Single est une conversion étendue et ne nécessite pas l’utilisation d’un opérateur de cast ou d’une méthode de conversion.

  Toutefois, la conversion de valeurs entières 32 bits et 64 bits peut impliquer une perte de précision. Le tableau suivant répertorie les différences de précision pour les types 32 bits, 64 bits et Double :

  Type	Précision maximale (en chiffres décimaux)	Précision interne (en chiffres décimaux)
  Double	15	17
  Int32 et UInt32	10	10
  Int64 et UInt64	19	19
  Single	7	9

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

  using System;
  
  public class Example8
  {
      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
  

  let value1 = 1. / 3.
  let sValue2 = 1f / 3f
  let value2 = double sValue2
  printfn $"{value1:R} = {value2:R}: {value1.Equals value2}"
  // The example displays the following output:
  //        0.33333333333333331 = 0.3333333432674408: False
  

  Module Example9
      Public Sub Main()
          Dim value1 As Double = 1 / 3
          Dim sValue2 As Single = 1 / 3
          Dim value2 As Double = CDbl(sValue2)
          Console.WriteLine("{0} = {1}: {2}", value1, value2, value1.Equals(value2))
      End Sub
  End Module
  ' The example displays the following output:
  '       0.33333333333333331 = 0.3333333432674408: False