Structure System.Single

Cet article fournit des remarques supplémentaires à la documentation de référence de 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, PositiveInfinity NegativeInfinityet 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 type de données Single stocke des valeurs à virgule flottante de simple précision dans un format binaire de 32 bits, comme indiqué dans le tableau suivant :

Composant	Bribes
Significande ou mantisse	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:           {result1:R}");
        Console.WriteLine($".2 Added 10 times: {result2:R}");
    }
}
// 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 dans quelle mesure une valeur à virgule flottante peut approcher 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 grande valeur flottante en simple précision, puis y ajoute le produit de Single.Epsilon et d'un quadrillion. 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 être comparés, car leurs chiffres les moins significatifs 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 ({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).

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) de {0} et {1} vers {0:R} et {1:R} pour afficher tous les chiffres significatifs des deux valeurs Single, il est clair que les deux valeurs sont différentes 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 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 plage des types Int64 ou UInt64 est importante, utilisez le type BigInteger.

Il peut arriver qu’une valeur ne soit pas préservée après un aller-retour dans le cas d'un nombre à virgule flottante. 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. Si vous exécutez cet exemple sur .NET Framework, même si les valeurs semblent identiques, les valeurs restaurées ne sont pas égales aux valeurs d’origine. (Cela a depuis été résolu dans .NET, où les valeurs sont correctement préservées après un aller-retour.)

StreamWriter sw = new(@"./Singles.dat");
float[] 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();

float[] restoredValues = new float[values.Length];
StreamReader sr = new(@"./Singles.dat");
string temp = sr.ReadToEnd();
string[] tempStrings = temp.Split('|');
for (int ctr = 0; ctr < tempStrings.Length; ctr++)
    restoredValues[ctr] = float.Parse(tempStrings[ctr]);

for (int ctr = 0; ctr < values.Length; ctr++)
    Console.WriteLine($"{values[ctr]} {(values[ctr].Equals(restoredValues[ctr]) ? "=" : "<>")} {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

Si vous ciblez .NET Framework, les valeurs peuvent être préservées après un aller-retour grâce à l'utilisation de la chaîne de format numérique standard « G9 » pour conserver la précision complète des valeurs Single.

Les valeurs de Single ont moins de précision que celles de Double. 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($"{value1:R} = {value2:R}: {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, remplacez le type de données Double par le type de données Single, ou utilisez la méthode Round pour 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 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 Single, 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($"{value1:R} = {value2:R}: {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 valeur Single est multipliée par 3,51, puis élevée au carré, et la racine carrée du résultat est divisée par 3,51 afin de revenir à 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($"{value1} = {value2}: {value1.Equals(value2)}");
        Console.WriteLine();
        Console.WriteLine($"{value1:G9} = {value2:G9}");
    }
}
// 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, il est possible d’utiliser les techniques suivantes au lieu d’appeler la Equals ou CompareTo 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($"{value1:R} = {value2:R}: {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 intermédiaires. Pour plus d’informations, consultez la Math.Round(Double, Int32, MidpointRounding) méthode.

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 Single positives et négatives, la valeur Single.Epsilon est 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($"{one1:R} = {one2:R}: {one1.Equals(one2)}");
        Console.WriteLine($"{one1:R} is approximately equal to {one2:R}: " +
            $"{IsApproximatelyEqual(one1, one2, .000001f)}");
        
        float negativeOne1 = -1 * one1;
        float negativeOne2 = -1 * one2;

        Console.WriteLine($"{negativeOne1:R} = {negativeOne2:R}: {negativeOne1.Equals(negativeOne2)}");
        Console.WriteLine($"{negativeOne1:R} is approximately equal to {negativeOne2:R}: " +
            $"{IsApproximatelyEqual(negativeOne1, negativeOne2, .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
//       -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 à virgule flottante et exceptions

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($"{value1} * {value2} = {result}");
        Console.WriteLine($"{result} = 0: {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: {Single.IsPositiveInfinity(result)}");
        Console.WriteLine($"NegativeInfinity: {Single.IsNegativeInfinity(result)}");
        Console.WriteLine();

        value1 = -value1;
        result = value1 * value2;
        Console.WriteLine($"PositiveInfinity: {Single.IsPositiveInfinity(result)}");
        Console.WriteLine($"NegativeInfinity: {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 est le résultat des opérations suivantes :
- Division par zéro avec un dividende de zéro. Notez que d’autres cas de division par zéro donnent pour résultat PositiveInfinity ou NegativeInfinity.
- 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	Élargissement	Non
Decimal	Élargissement Sachez que C# nécessite un opérateur de conversion.	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	Élargissement	Non
Int32	Élargissement	Oui. Int32 prend en charge 10 chiffres décimaux de précision ; Single prend en charge 9.
Int64	Élargissement	Oui. Int64 prend en charge 19 chiffres décimaux de précision ; Single prend en charge 9.
SByte	Élargissement	Non
UInt16	Élargissement	Non
UInt32	Élargissement	Oui. UInt32 prend en charge 10 chiffres décimaux de précision ; Single prend en charge 9.
UInt64	Élargissement	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($"{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)

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 des valeurs Decimal, Double, Int32, Int64, UInt32 et UInt64 en valeurs Single.

La conversion d’une valeur Single vers une valeur Double est une conversion large. 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 valeur Single en une valeur d'un type de données numérique primitif autre qu'un Double est une conversion réductrice et nécessite un opérateur de transformation (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, définie par les propriétés MinValue et MaxValue du type cible, se comportent comme indiqué dans le tableau suivant.

Type de cible	Résultat
Tout type intégral	Exception OverflowException si la conversion se produit dans un contexte vérifié. Si la conversion se produit dans un contexte non vérifié (valeur par défaut en C#), l’opération de conversion réussit, mais la valeur est dépassée.
Decimal	Une exception OverflowException,

En outre, Single.NaN, Single.PositiveInfinity et Single.NegativeInfinity lèvent une exception OverflowException dans le cas de conversions en entiers dans un contexte vérifié, mais provoquent un dépassement dans un contexte non vérifié. Pour les conversions en Decimal, ils lancent 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 vérifié en Visual Basic (valeur par défaut), en C# (en raison du mot clé vérifié ) et en F# (en raison de l’instruction open Checked ). La sortie de l'exemple montre le résultat des conversions dans un contexte vérifié et non vérifié. Vous pouvez effectuer des conversions dans un contexte non vérifié dans Visual Basic en compilant avec le commutateur du /removeintchecks+ compilateur, en C# en commentant l’instruction checked et en F# en commentant l’instruction open 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($"{value} ({value.GetType().Name}) --> {lValue} (0x{lValue:X16}) ({lValue.GetType().Name})");
                }
                catch (OverflowException)
                {
                    Console.WriteLine($"Unable to convert {value} to Int64.");
                }
                try
                {
                    UInt64 ulValue = (ulong)value;
                    Console.WriteLine($"{value} ({value.GetType().Name}) --> {ulValue} (0x{ulValue:X16}) ({ulValue.GetType().Name})");
                }
                catch (OverflowException)
                {
                    Console.WriteLine($"Unable to convert {value} to UInt64.");
                }
                try
                {
                    Decimal dValue = (decimal)value;
                    Console.WriteLine($"{value} ({value.GetType().Name}) --> {dValue} ({dValue.GetType().Name})");
                }
                catch (OverflowException)
                {
                    Console.WriteLine($"Unable to convert {value} to Decimal.");
                }

                Double dblValue = value;
                Console.WriteLine($"{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 .NET et Tables de conversion de types.

Fonctionnalité de 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'élargissent, 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 valeurs, consultez la section Single.

Vous pouvez également appeler les méthodes IsNaN, IsInfinity, IsPositiveInfinity et IsNegativeInfinity 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 des méthodes Single. 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 méthode BitConverter.GetBytes(Single) renvoie son schéma binaire 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 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 flottante en une Single valeur en appelant la méthode Parse ou TryParse. 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 structure Single fournit une implémentation d’interface explicite pour l’interface IConvertible, qui prend en charge la conversion entre les 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 valeurs de Double vers Single. La conversion d'une valeur d'un type numérique standard autre qu'un Double en Single est une conversion d'élargissement et ne nécessite pas l'utilisation d'un opérateur de conversion 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 :

Catégorie	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 Single qui sont converties en valeurs Double. Dans l’exemple suivant, deux valeurs produites par des opérations de division identiques sont différentes, car l’une des valeurs est une valeur à virgule flottante de simple précision (single-precision) 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($"{value1:R} = {value2:R}: {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

Commentaires

Cette page a-t-elle été utile ?

Last updated on 2025-06-20