Double Structure

Définition

Espace de noms:

System

Assemblys:

netstandard.dll, System.Runtime.dll

Source:

Double.cs

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

public value class double : IComparable<double>, IConvertible, IEquatable<double>, IParsable<double>, ISpanParsable<double>, IUtf8SpanParsable<double>, System::Numerics::IAdditionOperators<double, double, double>, System::Numerics::IAdditiveIdentity<double, double>, System::Numerics::IBinaryFloatingPointIeee754<double>, System::Numerics::IBinaryNumber<double>, System::Numerics::IBitwiseOperators<double, double, double>, System::Numerics::IComparisonOperators<double, double, bool>, System::Numerics::IDecrementOperators<double>, System::Numerics::IDivisionOperators<double, double, double>, System::Numerics::IEqualityOperators<double, double, bool>, System::Numerics::IExponentialFunctions<double>, System::Numerics::IFloatingPoint<double>, System::Numerics::IFloatingPointConstants<double>, System::Numerics::IFloatingPointIeee754<double>, System::Numerics::IHyperbolicFunctions<double>, System::Numerics::IIncrementOperators<double>, System::Numerics::ILogarithmicFunctions<double>, System::Numerics::IMinMaxValue<double>, System::Numerics::IModulusOperators<double, double, double>, System::Numerics::IMultiplicativeIdentity<double, double>, System::Numerics::IMultiplyOperators<double, double, double>, System::Numerics::INumber<double>, System::Numerics::INumberBase<double>, System::Numerics::IPowerFunctions<double>, System::Numerics::IRootFunctions<double>, System::Numerics::ISignedNumber<double>, System::Numerics::ISubtractionOperators<double, double, double>, System::Numerics::ITrigonometricFunctions<double>, System::Numerics::IUnaryNegationOperators<double, double>, System::Numerics::IUnaryPlusOperators<double, double>

public readonly struct Double : IComparable<double>, IConvertible, IEquatable<double>, IParsable<double>, ISpanParsable<double>, IUtf8SpanParsable<double>, System.Numerics.IAdditionOperators<double,double,double>, System.Numerics.IAdditiveIdentity<double,double>, System.Numerics.IBinaryFloatingPointIeee754<double>, System.Numerics.IBinaryNumber<double>, System.Numerics.IBitwiseOperators<double,double,double>, System.Numerics.IComparisonOperators<double,double,bool>, System.Numerics.IDecrementOperators<double>, System.Numerics.IDivisionOperators<double,double,double>, System.Numerics.IEqualityOperators<double,double,bool>, System.Numerics.IExponentialFunctions<double>, System.Numerics.IFloatingPoint<double>, System.Numerics.IFloatingPointConstants<double>, System.Numerics.IFloatingPointIeee754<double>, System.Numerics.IHyperbolicFunctions<double>, System.Numerics.IIncrementOperators<double>, System.Numerics.ILogarithmicFunctions<double>, System.Numerics.IMinMaxValue<double>, System.Numerics.IModulusOperators<double,double,double>, System.Numerics.IMultiplicativeIdentity<double,double>, System.Numerics.IMultiplyOperators<double,double,double>, System.Numerics.INumber<double>, System.Numerics.INumberBase<double>, System.Numerics.IPowerFunctions<double>, System.Numerics.IRootFunctions<double>, System.Numerics.ISignedNumber<double>, System.Numerics.ISubtractionOperators<double,double,double>, System.Numerics.ITrigonometricFunctions<double>, System.Numerics.IUnaryNegationOperators<double,double>, System.Numerics.IUnaryPlusOperators<double,double>

type double = struct
    interface IConvertible
    interface IFormattable
    interface IParsable<double>
    interface ISpanFormattable
    interface ISpanParsable<double>
    interface IUtf8SpanFormattable
    interface IUtf8SpanParsable<double>
    interface IAdditionOperators<double, double, double>
    interface IAdditiveIdentity<double, double>
    interface IBinaryFloatingPointIeee754<double>
    interface IBinaryNumber<double>
    interface IBitwiseOperators<double, double, double>
    interface IComparisonOperators<double, double, bool>
    interface IEqualityOperators<double, double, bool>
    interface IDecrementOperators<double>
    interface IDivisionOperators<double, double, double>
    interface IIncrementOperators<double>
    interface IModulusOperators<double, double, double>
    interface IMultiplicativeIdentity<double, double>
    interface IMultiplyOperators<double, double, double>
    interface INumber<double>
    interface INumberBase<double>
    interface ISubtractionOperators<double, double, double>
    interface IUnaryNegationOperators<double, double>
    interface IUnaryPlusOperators<double, double>
    interface IExponentialFunctions<double>
    interface IFloatingPointConstants<double>
    interface IFloatingPoint<double>
    interface ISignedNumber<double>
    interface IFloatingPointIeee754<double>
    interface IHyperbolicFunctions<double>
    interface ILogarithmicFunctions<double>
    interface IPowerFunctions<double>
    interface IRootFunctions<double>
    interface ITrigonometricFunctions<double>
    interface IMinMaxValue<double>

Public Structure Double
Implements IAdditionOperators(Of Double, Double, Double), IAdditiveIdentity(Of Double, Double), IBinaryFloatingPointIeee754(Of Double), IBinaryNumber(Of Double), IBitwiseOperators(Of Double, Double, Double), IComparable(Of Double), IComparisonOperators(Of Double, Double, Boolean), IConvertible, IDecrementOperators(Of Double), IDivisionOperators(Of Double, Double, Double), IEqualityOperators(Of Double, Double, Boolean), IEquatable(Of Double), IExponentialFunctions(Of Double), IFloatingPoint(Of Double), IFloatingPointConstants(Of Double), IFloatingPointIeee754(Of Double), IHyperbolicFunctions(Of Double), IIncrementOperators(Of Double), ILogarithmicFunctions(Of Double), IMinMaxValue(Of Double), IModulusOperators(Of Double, Double, Double), IMultiplicativeIdentity(Of Double, Double), IMultiplyOperators(Of Double, Double, Double), INumber(Of Double), INumberBase(Of Double), IParsable(Of Double), IPowerFunctions(Of Double), IRootFunctions(Of Double), ISignedNumber(Of Double), ISpanParsable(Of Double), ISubtractionOperators(Of Double, Double, Double), ITrigonometricFunctions(Of Double), IUnaryNegationOperators(Of Double, Double), IUnaryPlusOperators(Of Double, Double), IUtf8SpanParsable(Of Double)

Héritage

Object

ValueType

Double

Implémente

IComparable IComparable<Double> IConvertible IEquatable<Double> IFormattable IComparable<TSelf> IEquatable<TSelf> IParsable<Double> IParsable<TSelf> ISpanFormattable ISpanParsable<Double> ISpanParsable<TSelf> IUtf8SpanFormattable IUtf8SpanParsable<Double> IUtf8SpanParsable<TSelf> IAdditionOperators<Double,Double,Double> IAdditionOperators<TSelf,TSelf,TSelf> IAdditiveIdentity<Double,Double> IAdditiveIdentity<TSelf,TSelf> IBinaryFloatingPointIeee754<Double> IBinaryNumber<Double> IBinaryNumber<TSelf> IBitwiseOperators<Double,Double,Double> IBitwiseOperators<TSelf,TSelf,TSelf> IComparisonOperators<Double,Double,Boolean> IComparisonOperators<TSelf,TSelf,Boolean> IDecrementOperators<Double> IDecrementOperators<TSelf> IDivisionOperators<Double,Double,Double> IDivisionOperators<TSelf,TSelf,TSelf> IEqualityOperators<Double,Double,Boolean> IEqualityOperators<TSelf,TOther,TResult> IEqualityOperators<TSelf,TSelf,Boolean> IExponentialFunctions<Double> IExponentialFunctions<TSelf> IFloatingPoint<Double> IFloatingPoint<TSelf> IFloatingPointConstants<Double> IFloatingPointConstants<TSelf> IFloatingPointIeee754<Double> IFloatingPointIeee754<TSelf> IHyperbolicFunctions<Double> IHyperbolicFunctions<TSelf> IIncrementOperators<Double> IIncrementOperators<TSelf> ILogarithmicFunctions<Double> ILogarithmicFunctions<TSelf> IMinMaxValue<Double> IModulusOperators<Double,Double,Double> IModulusOperators<TSelf,TSelf,TSelf> IMultiplicativeIdentity<Double,Double> IMultiplicativeIdentity<TSelf,TSelf> IMultiplyOperators<Double,Double,Double> IMultiplyOperators<TSelf,TSelf,TSelf> INumber<Double> INumber<TSelf> INumberBase<Double> INumberBase<TSelf> IPowerFunctions<Double> IPowerFunctions<TSelf> IRootFunctions<Double> IRootFunctions<TSelf> ISignedNumber<Double> ISignedNumber<TSelf> ISubtractionOperators<Double,Double,Double> ISubtractionOperators<TSelf,TSelf,TSelf> ITrigonometricFunctions<Double> ITrigonometricFunctions<TSelf> IUnaryNegationOperators<Double,Double> IUnaryNegationOperators<TSelf,TSelf> IUnaryPlusOperators<Double,Double> IUnaryPlusOperators<TSelf,TSelf>

Exemples

L’exemple de code suivant illustre l’utilisation de Double:

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

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

    // IFormattable.ToString implementation.
    public string ToString(string format, IFormatProvider provider) {
        if( format != null ) {
            if( format.Equals("F") ) {
                return String.Format("{0}'F", this.Value.ToString());
            }
            if( format.Equals("C") ) {
                return String.Format("{0}'C", this.Celsius.ToString());
            }
        }

        return m_value.ToString(format, provider);
    }

    // Parses the temperature from a string in the form
    // [ws][sign]digits['F|'C][ws]
    public static Temperature Parse(string s, NumberStyles styles, IFormatProvider provider) {
        Temperature temp = new Temperature();

        if( s.TrimEnd(null).EndsWith("'F") ) {
            temp.Value = Double.Parse( s.Remove(s.LastIndexOf('\''), 2), styles, provider);
        }
        else if( s.TrimEnd(null).EndsWith("'C") ) {
            temp.Celsius = Double.Parse( s.Remove(s.LastIndexOf('\''), 2), styles, provider);
        }
        else {
            temp.Value = Double.Parse(s, styles, provider);
        }

        return temp;
    }

    // The value holder
    protected double m_value;

    public double Value {
        get {
            return m_value;
        }
        set {
            m_value = value;
        }
    }

    public double Celsius {
        get {
            return (m_value-32.0)/1.8;
        }
        set {
            m_value = 1.8*value+32.0;
        }
    }
}

// The Temperature class stores the temperature as a Double
// and delegates most of the functionality to the Double
// implementation.
type Temperature() =
    member val Value = 0. with get, set

    member this.Celsius
        with get () = (this.Value - 32.) / 1.8
        and set (value) =
            this.Value <- 1.8 * value + 32.

    // Parses the temperature from a string in the form
    // [ws][sign]digits['F|'C][ws]
    static member Parse(s: string, styles: NumberStyles, provider: IFormatProvider) =
        let temp = Temperature()

        if s.TrimEnd(null).EndsWith "'F" then
            temp.Value <- Double.Parse(s.Remove(s.LastIndexOf '\'', 2), styles, provider)
        elif s.TrimEnd(null).EndsWith "'C" then
            temp.Celsius <- Double.Parse(s.Remove(s.LastIndexOf '\'', 2), styles, provider)
        else
            temp.Value <- Double.Parse(s, styles, provider)
        temp

    interface IComparable with
        // IComparable.CompareTo implementation.
        member this.CompareTo(obj: obj) =
            match obj with 
            | null -> 1
            | :? Temperature as temp ->
                this.Value.CompareTo temp.Value
            | _ ->
                invalidArg "obj" "object is not a Temperature"

    interface IFormattable with
        // IFormattable.ToString implementation.
        member this.ToString(format: string, provider: IFormatProvider) =
            match format with
            | "F" ->
                $"{this.Value}'F"
            | "C" ->
                $"{this.Celsius}'C"
            | _ ->
                this.Value.ToString(format, provider)

' Temperature class stores the value as Double
' and delegates most of the functionality 
' to the Double implementation.
Public Class Temperature
    Implements IComparable, IFormattable

    Public Overloads Function CompareTo(ByVal obj As Object) As Integer _
        Implements IComparable.CompareTo

        If TypeOf obj Is Temperature Then
            Dim temp As Temperature = CType(obj, Temperature)

            Return m_value.CompareTo(temp.m_value)
        End If

        Throw New ArgumentException("object is not a Temperature")
    End Function

    Public Overloads Function ToString(ByVal format As String, ByVal provider As IFormatProvider) As String _
        Implements IFormattable.ToString

        If Not (format Is Nothing) Then
            If format.Equals("F") Then
                Return [String].Format("{0}'F", Me.Value.ToString())
            End If
            If format.Equals("C") Then
                Return [String].Format("{0}'C", Me.Celsius.ToString())
            End If
        End If

        Return m_value.ToString(format, provider)
    End Function

    ' Parses the temperature from a string in form
    ' [ws][sign]digits['F|'C][ws]
    Public Shared Function Parse(ByVal s As String, ByVal styles As NumberStyles, ByVal provider As IFormatProvider) As Temperature
        Dim temp As New Temperature()

        If s.TrimEnd().EndsWith("'F") Then
            temp.Value = Double.Parse(s.Remove(s.LastIndexOf("'"c), 2), styles, provider)
        Else
            If s.TrimEnd().EndsWith("'C") Then
                temp.Celsius = Double.Parse(s.Remove(s.LastIndexOf("'"c), 2), styles, provider)
            Else
                temp.Value = Double.Parse(s, styles, provider)
            End If
        End If
        Return temp
    End Function

    ' The value holder
    Protected m_value As Double

    Public Property Value() As Double
        Get
            Return m_value
        End Get
        Set(ByVal Value As Double)
            m_value = Value
        End Set
    End Property

    Public Property Celsius() As Double
        Get
            Return (m_value - 32) / 1.8
        End Get
        Set(ByVal Value As Double)
            m_value = Value * 1.8 + 32
        End Set
    End Property
End Class

Remarques

Le type de valeur Double représente un nombre double à précision 64 bits avec des valeurs comprises entre 1,79769313486232e308 négatif et 1,79769313486232e308 positif, ainsi que zéro positif ou négatif, PositiveInfinity, NegativeInfinity, et pas 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 Double type est conforme à la norme IEC 60559:1989 (IEEE 754) pour l’arithmétique à virgule flottante binaire.

Représentation à virgule flottante et précision

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

Partie	Bits
Significande ou mantisse	0-51
Exponent	52-62
Signe (0 = Positif, 1 = Négatif)	63

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, 1/10, qui est représenté précisément par .1 comme fraction décimale, est représenté par .001100110011 sous forme de fraction binaire, avec le modèle « 0011 » répétant à l’infini. Dans ce cas, la valeur à virgule flottante fournit une représentation imprécise du nombre qu’elle représente. L’exécution d’opérations mathématiques supplémentaires sur la valeur à virgule flottante d’origine tend souvent à augmenter son manque de précision. Par exemple, si vous comparez le résultat de la multiplication de .1 par 10 et l’ajout de .1 à .1 neuf fois, vous voyez cet ajout, car il a impliqué huit opérations supplémentaires, a produit le résultat moins précis. Avant .NET 10, cette disparité n’est apparente que si vous affichez les deux valeurs Double en utilisant la chaîne de format numérique standard « R », qui affiche jusqu’à 17 chiffres de précision prises en charge par le type .

using System;

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

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

let value = 0.1
let result1 = value * 10.
let mutable result2 = 0.
for i = 1 to 10 do
    result2 <- result2 + value

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

Module Example14
    Public Sub Run()
        Dim value As Double = 0.1
        Dim result1 As Double = value * 10
        Dim result2 As Double
        For ctr As Integer = 1 To 10
            result2 += value
        Next
        Console.WriteLine(".1 * 10:           {0:R}", result1)
        Console.WriteLine(".1 Added 10 times: {0:R}", result2)
    End Sub
End Module
' The example displays the following output:
'       .1 * 10:           1
'       .1 Added 10 times: 0.99999999999999989

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

Tous les nombres à virgule flottante ont également un nombre limité de chiffres significatifs, ce qui détermine également la précision avec laquelle une valeur à virgule flottante peut approcher un nombre réel. Une Double valeur a jusqu’à 15 chiffres décimaux de précision, bien qu’un maximum de 17 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 illustre cette situation. Il définit une valeur à virgule flottante très importante, puis ajoute à celle-ci le produit de Double.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 ^{à 309}.

using System;

public class Example14
{
    public static void Main()
    {
        Double value = 123456789012.34567;
        Double additional = Double.Epsilon * 1e15;
        Console.WriteLine($"{value} + {additional} = {value + additional}");
    }
}
// The example displays the following output:
//    123456789012.346 + 4.94065645841247E-309 = 123456789012.346

open System

let value = 123456789012.34567
let additional = Double.Epsilon * 1e15
printfn $"{value} + {additional} = {value + additional}"
// The example displays the following output:
//    123456789012.346 + 4.94065645841247E-309 = 123456789012.346

Module Example15
    Public Sub Run()
        Dim value As Double = 123456789012.34567
        Dim additional As Double = Double.Epsilon * 1.0E+15
        Console.WriteLine("{0} + {1} = {2}", value, additional,
                                           value + additional)
    End Sub
End Module
' The example displays the following output:
'   123456789012.346 + 4.94065645841247E-309 = 123456789012.346

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.

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

  let values = [ 10.0; 2.88; 2.88; 2.88; 9.0 ]
  let result = 27.64
  let total = List.sum values
  
  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 (36.64) does not equal the total (36.64).
  //
  // If the index items in the Console.WriteLine statement are changed to {0:R},
  // the example displays the following output:
  //       The sum of the values (27.639999999999997) does not equal the total (27.64).
  

  Module Example11
      Public Sub Run()
          Dim values() As Double = {10.0, 2.88, 2.88, 2.88, 9.0}
          Dim result As Double = 27.64
          Dim total As Double
          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 (36.64) does not equal the total (36.64).   
  '
  ' If the index items in the Console.WriteLine statement are changed to {0:R},
  ' the example displays the following output:
  '       The sum of the values (27.639999999999997) does not equal the total (27.64).
  

  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 Double 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 .1 par 10 et l’ajout de .1 fois.

  Lorsque la précision des opérations numériques avec des valeurs fractionnaires est importante, vous pouvez utiliser le Decimal type plutôt que le Double type. Lorsque la précision dans les opérations numériques avec des valeurs intégrales au-delà de la Int128UInt128 plage des types est importante, utilisez le BigInteger type.

• Les valeurs de Single ont moins de précision que celles de Double. Une Single valeur convertie en un équivalent apparemment identique Double n’est souvent pas égale à 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 valeur Double et une valeur Single. 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 Run()
      {
          double value1 = 1 / 3.0;
          float 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 Run()
          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 soit la Double place du type de Single données, soit utilisez la Round méthode afin que les deux valeurs aient la même précision.

En outre, le résultat des opérations arithmétiques et d’affectation avec Double des valeurs peut différer légèrement par plateforme en raison de la perte de précision du Double type. Par exemple, le résultat de l’affectation d’une valeur littérale Double peut différer dans les versions 32 bits et 64 bits de .NET. L’exemple suivant illustre cette différence lorsque la valeur littérale -4.42330604244772E-305 et une variable dont la valeur est -4.42330604244772E-305 sont affectées à une Double variable. Notez que le résultat de la Parse(String) méthode dans ce cas ne souffre pas d’une perte de précision.

double value = -4.42330604244772E-305;

double fromLiteral = -4.42330604244772E-305;
double fromVariable = value;
double fromParse = double.Parse("-4.42330604244772E-305");

Console.WriteLine("Double value from literal: {0,29:R}", fromLiteral);
Console.WriteLine("Double value from variable: {0,28:R}", fromVariable);
Console.WriteLine("Double value from Parse method: {0,24:R}", fromParse);

// The output is:
//    Double value from literal:        -4.42330604244772E-305
//    Double value from variable:       -4.42330604244772E-305
//    Double value from Parse method:   -4.42330604244772E-305

let value = -4.42330604244772E-305

let fromLiteral = -4.42330604244772E-305
let fromVariable = value
let fromParse = Double.Parse "-4.42330604244772E-305"

printfn $"Double value from literal: {fromLiteral,29:R}"
printfn $"Double value from variable: {fromVariable,28:R}"
printfn $"Double value from Parse method: {fromParse,24:R}"
// On 32-bit versions of the .NET Framework, the output is:
//    Double value from literal:        -4.42330604244772E-305
//    Double value from variable:       -4.42330604244772E-305
//    Double value from Parse method:   -4.42330604244772E-305
//
// On other versions of the .NET Framework, the output is:
//    Double value from literal:      -4.4233060424477198E-305
//    Double value from variable:     -4.4233060424477198E-305
//    Double value from Parse method:   -4.42330604244772E-305

Dim value As Double = -4.4233060424477198E-305

Dim fromLiteral As Double = -4.4233060424477198E-305
Dim fromVariable As Double = value
Dim fromParse As Double = Double.Parse("-4.42330604244772E-305")

Console.WriteLine("Double value from literal: {0,29:R}", fromLiteral)
Console.WriteLine("Double value from variable: {0,28:R}", fromVariable)
Console.WriteLine("Double value from Parse method: {0,24:R}", fromParse)

' The output is:
'    Double value from literal:        -4.42330604244772E-305
'    Double value from variable:       -4.42330604244772E-305
'    Double value from Parse method:   -4.42330604244772E-305

Tester l’égalité

Pour être considérées comme égales, deux Double 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 Double, produisent souvent des résultats inattendus. Cela est évident dans l’exemple suivant, où deux valeurs apparemment égales Double s’avèrent inégales, car la première a 15 chiffres de précision, tandis que la seconde a 17.

using System;

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

open System

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

Module Example1
    Public Sub Run()
        Dim value1 As Double = 0.333333333333333
        Dim value2 As Double = 1 / 3
        Console.WriteLine("{0} = {1}: {2}", value1, value2, value1.Equals(value2))
    End Sub
End Module

' The example displays the following output:
'       0.333333333333333 = 0.33333333333333331: False

Dans les cas où une perte de précision est susceptible d’affecter le résultat d’une comparaison, vous pouvez adopter l’une des alternatives suivantes pour appeler la méthode Equals ou CompareTo :

• 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.

  double value1 = .333333333333333;
  double value2 = 1.0 / 3;
  int precision = 7;
  value1 = Math.Round(value1, precision);
  value2 = Math.Round(value2, precision);
  Console.WriteLine($"{value1} = {value2}: {value1.Equals(value2)}");
  
  // The example displays the following output:
  //        0.3333333 = 0.3333333: True
  

  open System
  
  let v1 = 0.333333333333333
  let v2 = 1. / 3.
  let precision = 7
  let value1 = Math.Round(v1, precision)
  let value2 = Math.Round(v2, precision)
  printfn $"{value1:R} = {value2:R}: {value1.Equals value2}"
  // The example displays the following output:
  //        0.3333333 = 0.3333333: True
  

  Module Example3
      Public Sub Run()
          Dim value1 As Double = 0.333333333333333
          Dim value2 As Double = 1 / 3
          Dim precision As Integer = 7
          value1 = Math.Round(value1, precision)
          value2 = Math.Round(value2, precision)
          Console.WriteLine("{0} = {1}: {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 plutôt que l’égalité. Cela nécessite 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 un montant relatif par lequel la plus petite valeur peut différer de la valeur la plus grande.

  Avertissement

  Double.Epsilon est parfois utilisé comme mesure absolue de la distance entre deux Double valeurs lors du test de l’égalité. Toutefois, Double.Epsilon mesure la plus petite valeur possible à laquelle ajouter ou soustraire une Double valeur dont la valeur est égale à zéro. Pour la plupart des valeurs Double positives et négatives, la valeur Double.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. La méthode divise par Math.Max(value1, value2) conséquent la comparaison est relative à la plus grande (par magnitude) des deux valeurs, ce qui place le résultat dans l’ordre de grandeur correct. Si Math.Max retourne zéro (ce qui se produit quand une valeur est zéro et l'autre est négative), la méthode utilise Math.Min(value1, value2) pour prendre la valeur non nulle comme diviseur. Elle contraste également le résultat des appels à la IsApproximatelyEqual méthode et à la Equals(Double) méthode.

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

  open System
  
  let isApproximatelyEqual (value1: double) (value2: double) (epsilon: double) =
      // If they are equal anyway, just return True.
      if value1.Equals value2 then 
          true
      else
          // Handle NaN, Infinity.
          if Double.IsInfinity value1 || Double.IsNaN value1 then 
              value1.Equals value2
          elif Double.IsInfinity value2 || Double.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.1 * 10.
  let mutable one2 = 0.
  for _ = 1 to 10 do
      one2 <- one2 + 0.1
  
  printfn $"{one1:R} = {one2:R}: {one1.Equals one2}"
  printfn $"{one1:R} is approximately equal to {one2:R}: {isApproximatelyEqual one1 one2 0.000000001}"
  
  // The example displays the following output:
  //       1 = 0.99999999999999989: False
  //       1 is approximately equal to 0.99999999999999989: True
  

  Module Example4
      Public Sub Run()
          Dim one1 As Double = 0.1 * 10
          Dim one2 As Double = 0
          For ctr As Integer = 1 To 10
              one2 += 0.1
          Next
          Console.WriteLine("{0} = {1}: {2}", one1, one2, one1.Equals(one2))
          Console.WriteLine("{0} is approximately equal to {1}: {2}",
                          one1, one2,
                          IsApproximatelyEqual(one1, one2, 0.000000001))
      End Sub
  
      Function IsApproximatelyEqual(value1 As Double, value2 As Double,
                                   epsilon As Double) As Boolean
          ' If they are equal anyway, just return True.
          If value1.Equals(value2) Then Return True
  
          ' Handle NaN, Infinity.
          If Double.IsInfinity(value1) Or Double.IsNaN(value1) Then
              Return value1.Equals(value2)
          ElseIf Double.IsInfinity(value2) Or Double.IsNaN(value2) Then
              Return value1.Equals(value2)
          End If
  
          ' Handle zero to avoid division by zero
          Dim divisor As Double = 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 = 0.99999999999999989: False
  '       1 is approximately equal to 0.99999999999999989: True
  

Valeurs à virgule flottante et exceptions

Contrairement aux opérations avec des types intégraux, qui lèvent une DivideByZeroException division par zéro ou un OverflowException dépassement de capacité dans un contexte vérifié, les opérations avec des valeurs à virgule flottante ne lèvent pas d’exceptions. Au lieu de cela, dans des situations exceptionnelles, 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 très petits sont multipliés, comme l’illustre l’exemple suivant.

  using System;
  
  public class Example6
  {
      public static void Main()
      {
          Double value1 = 1.1632875981534209e-225;
          Double value2 = 9.1642346778e-175;
          Double result = value1 * value2;
          Console.WriteLine($"{value1} * {value2} = {result}");
          Console.WriteLine($"{result} = 0: {result.Equals(0.0)}");
      }
  }
  // The example displays the following output:
  //       1.16328759815342E-225 * 9.1642346778E-175 = 0
  //       0 = 0: True
  

  let value1 = 1.1632875981534209e-225
  let value2 = 9.1642346778e-175
  let result = value1 * value2
  printfn $"{value1} * {value2} = {result}"
  printfn $"{result} = 0: {result.Equals 0.0}"
  // The example displays the following output:
  //       1.16328759815342E-225 * 9.1642346778E-175 = 0
  //       0 = 0: True
  

  Module Example7
      Public Sub Run()
          Dim value1 As Double = 1.1632875981534209E-225
          Dim value2 As Double = 9.1642346778E-175
          Dim result As Double = value1 * value2
          Console.WriteLine("{0} * {1} = {2}", value1, value2, result)
          Console.WriteLine("{0} = 0: {1}", result, result.Equals(0.0))
      End Sub
  End Module
  ' The example displays the following output:
  '       1.16328759815342E-225 * 9.1642346778E-175 = 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 Double.MaxValue est PositiveInfinity, et le résultat d’une opération qui dépasse Double.MinValue , NegativeInfinitycomme l’illustre l’exemple suivant.

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

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

  Module Example8
      Public Sub Run()
          Dim value1 As Double = 4.565E+153
          Dim value2 As Double = 6.9375E+172
          Dim result As Double = value1 * value2
          Console.WriteLine("PositiveInfinity: {0}",
                           Double.IsPositiveInfinity(result))
          Console.WriteLine("NegativeInfinity: {0}",
                          Double.IsNegativeInfinity(result))
          Console.WriteLine()
          value1 = -value1
          result = value1 * value2
          Console.WriteLine("PositiveInfinity: {0}",
                           Double.IsPositiveInfinity(result))
          Console.WriteLine("NegativeInfinity: {0}",
                          Double.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, l’appel de la Math.Sqrt méthode avec une valeur négative retourne NaN, comme l’appel de la Math.Acos méthode avec une valeur supérieure ou inférieure à une valeur négative.

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

Conversions des types

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

La conversion de la valeur d’un type numérique primitif en Double est une conversion étendue. Elle n’exige donc pas d’opérateur de cast explicite ou d’appel à une méthode de conversion, sauf si un compilateur l’exige explicitement. Par exemple, le compilateur C# nécessite un opérateur de cast pour les conversions de Decimal vers Double, tandis que le compilateur Visual Basic ne le fait pas. L’exemple suivant convertit la valeur minimale ou maximale d’autres types numériques primitifs en un Double.

dynamic[] values = { Byte.MinValue, Byte.MaxValue, Decimal.MinValue,
                   Decimal.MaxValue, Int16.MinValue, Int16.MaxValue,
                   Int32.MinValue, Int32.MaxValue, Int64.MinValue,
                   Int64.MaxValue, SByte.MinValue, SByte.MaxValue,
                   Single.MinValue, Single.MaxValue, UInt16.MinValue,
                   UInt16.MaxValue, UInt32.MinValue, UInt32.MaxValue,
                   UInt64.MinValue, UInt64.MaxValue };
double dblValue;
foreach (dynamic value in values)
{
    if (value.GetType() == typeof(decimal))
        dblValue = (double)value;
    else
        dblValue = value;
    Console.WriteLine($"{value} ({value.GetType().Name}) --> " +
        $"{dblValue:R} ({dblValue.GetType().Name})");
}

// The example displays the following output:
//    0 (Byte) --> 0 (Double)
//    255 (Byte) --> 255 (Double)
//    -79228162514264337593543950335 (Decimal) --> -7.9228162514264338E+28 (Double)
//    79228162514264337593543950335 (Decimal) --> 7.9228162514264338E+28 (Double)
//    -32768 (Int16) --> -32768 (Double)
//    32767 (Int16) --> 32767 (Double)
//    -2147483648 (Int32) --> -2147483648 (Double)
//    2147483647 (Int32) --> 2147483647 (Double)
//    -9223372036854775808 (Int64) --> -9.2233720368547758E+18 (Double)
//    9223372036854775807 (Int64) --> 9.2233720368547758E+18 (Double)
//    -128 (SByte) --> -128 (Double)
//    127 (SByte) --> 127 (Double)
//    -3.402823E+38 (Single) --> -3.4028234663852886E+38 (Double)
//    3.402823E+38 (Single) --> 3.4028234663852886E+38 (Double)
//    0 (UInt16) --> 0 (Double)
//    65535 (UInt16) --> 65535 (Double)
//    0 (UInt32) --> 0 (Double)
//    4294967295 (UInt32) --> 4294967295 (Double)
//    0 (UInt64) --> 0 (Double)
//    18446744073709551615 (UInt64) --> 1.8446744073709552E+19 (Double)

open System

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

for value in values do
    let dblValue = value :?> double
    printfn $"{value} ({value.GetType().Name}) --> {dblValue:R} ({dblValue.GetType().Name})"
// The example displays the following output:
//    0 (Byte) --> 0 (Double)
//    255 (Byte) --> 255 (Double)
//    -79228162514264337593543950335 (Decimal) --> -7.9228162514264338E+28 (Double)
//    79228162514264337593543950335 (Decimal) --> 7.9228162514264338E+28 (Double)
//    -32768 (Int16) --> -32768 (Double)
//    32767 (Int16) --> 32767 (Double)
//    -2147483648 (Int32) --> -2147483648 (Double)
//    2147483647 (Int32) --> 2147483647 (Double)
//    -9223372036854775808 (Int64) --> -9.2233720368547758E+18 (Double)
//    9223372036854775807 (Int64) --> 9.2233720368547758E+18 (Double)
//    -128 (SByte) --> -128 (Double)
//    127 (SByte) --> 127 (Double)
//    -3.402823E+38 (Single) --> -3.4028234663852886E+38 (Double)
//    3.402823E+38 (Single) --> 3.4028234663852886E+38 (Double)
//    0 (UInt16) --> 0 (Double)
//    65535 (UInt16) --> 65535 (Double)
//    0 (UInt32) --> 0 (Double)
//    4294967295 (UInt32) --> 4294967295 (Double)
//    0 (UInt64) --> 0 (Double)
//    18446744073709551615 (UInt64) --> 1.8446744073709552E+19 (Double)

Module Example5
    Public Sub Run()
        Dim values() As Object = {Byte.MinValue, Byte.MaxValue, Decimal.MinValue,
                                 Decimal.MaxValue, Int16.MinValue, Int16.MaxValue,
                                 Int32.MinValue, Int32.MaxValue, Int64.MinValue,
                                 Int64.MaxValue, SByte.MinValue, SByte.MaxValue,
                                 Single.MinValue, Single.MaxValue, UInt16.MinValue,
                                 UInt16.MaxValue, UInt32.MinValue, UInt32.MaxValue,
                                 UInt64.MinValue, UInt64.MaxValue}
        Dim dblValue As Double
        For Each value In values
            dblValue = value
            Console.WriteLine("{0} ({1}) --> {2:R} ({3})",
                           value, value.GetType().Name,
                           dblValue, dblValue.GetType().Name)
        Next
    End Sub
End Module
' The example displays the following output:
'    0 (Byte) --> 0 (Double)
'    255 (Byte) --> 255 (Double)
'    -79228162514264337593543950335 (Decimal) --> -7.9228162514264338E+28 (Double)
'    79228162514264337593543950335 (Decimal) --> 7.9228162514264338E+28 (Double)
'    -32768 (Int16) --> -32768 (Double)
'    32767 (Int16) --> 32767 (Double)
'    -2147483648 (Int32) --> -2147483648 (Double)
'    2147483647 (Int32) --> 2147483647 (Double)
'    -9223372036854775808 (Int64) --> -9.2233720368547758E+18 (Double)
'    9223372036854775807 (Int64) --> 9.2233720368547758E+18 (Double)
'    -128 (SByte) --> -128 (Double)
'    127 (SByte) --> 127 (Double)
'    -3.402823E+38 (Single) --> -3.4028234663852886E+38 (Double)
'    3.402823E+38 (Single) --> 3.4028234663852886E+38 (Double)
'    0 (UInt16) --> 0 (Double)
'    65535 (UInt16) --> 65535 (Double)
'    0 (UInt32) --> 0 (Double)
'    4294967295 (UInt32) --> 4294967295 (Double)
'    0 (UInt64) --> 0 (Double)
'    18446744073709551615 (UInt64) --> 1.8446744073709552E+19 (Double)

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

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

La conversion d’une valeur Double en valeur d’un autre type de données numérique primitif est une conversion étroite et nécessite un opérateur de conversion (en C#), une méthode de conversion (en Visual Basic) ou un appel à une méthode Convert. 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	Result
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.
Single	Single.NegativeInfinity pour les valeurs négatives. Single.PositiveInfinity pour les valeurs positives.

En outre, Double.NaN, Double.PositiveInfinity et Double.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 Single, ils se convertissent en Single.NaN, Single.PositiveInfinityet Single.NegativeInfinity, respectivement.

Une perte de précision peut entraîner la conversion d’une Double valeur en un autre type numérique. Dans le cas de la conversion en un des types intégraux, comme le montre la sortie de l’exemple, le composant fractionnaire est perdu lorsque la valeur Double est arrondie (comme dans Visual Basic) ou tronquée (comme en C#). Pour les conversions vers Decimal et Single valeurs, la Double 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 Double 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 du module Vérifié ). 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 compilateur /removeintchecks+, 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()
    {
        Double[] values = { Double.MinValue, -67890.1234, -12345.6789,
                          12345.6789, 67890.1234, Double.MaxValue,
                          Double.NaN, Double.PositiveInfinity,
                          Double.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.");
                }
                try
                {
                    Single sValue = (float)value;
                    Console.WriteLine($"{value} ({value.GetType().Name}) --> {sValue} ({sValue.GetType().Name})");
                }
                catch (OverflowException)
                {
                    Console.WriteLine($"Unable to convert {value} to Single.");
                }
                Console.WriteLine();
            }
        }
    }
}
// The example displays the following output for conversions performed
// in a checked context:
//       Unable to convert -1.79769313486232E+308 to Int64.
//       Unable to convert -1.79769313486232E+308 to UInt64.
//       Unable to convert -1.79769313486232E+308 to Decimal.
//       -1.79769313486232E+308 (Double) --> -Infinity (Single)
//
//       -67890.1234 (Double) --> -67890 (0xFFFFFFFFFFFEF6CE) (Int64)
//       Unable to convert -67890.1234 to UInt64.
//       -67890.1234 (Double) --> -67890.1234 (Decimal)
//       -67890.1234 (Double) --> -67890.13 (Single)
//
//       -12345.6789 (Double) --> -12345 (0xFFFFFFFFFFFFCFC7) (Int64)
//       Unable to convert -12345.6789 to UInt64.
//       -12345.6789 (Double) --> -12345.6789 (Decimal)
//       -12345.6789 (Double) --> -12345.68 (Single)
//
//       12345.6789 (Double) --> 12345 (0x0000000000003039) (Int64)
//       12345.6789 (Double) --> 12345 (0x0000000000003039) (UInt64)
//       12345.6789 (Double) --> 12345.6789 (Decimal)
//       12345.6789 (Double) --> 12345.68 (Single)
//
//       67890.1234 (Double) --> 67890 (0x0000000000010932) (Int64)
//       67890.1234 (Double) --> 67890 (0x0000000000010932) (UInt64)
//       67890.1234 (Double) --> 67890.1234 (Decimal)
//       67890.1234 (Double) --> 67890.13 (Single)
//
//       Unable to convert 1.79769313486232E+308 to Int64.
//       Unable to convert 1.79769313486232E+308 to UInt64.
//       Unable to convert 1.79769313486232E+308 to Decimal.
//       1.79769313486232E+308 (Double) --> Infinity (Single)
//
//       Unable to convert NaN to Int64.
//       Unable to convert NaN to UInt64.
//       Unable to convert NaN to Decimal.
//       NaN (Double) --> NaN (Single)
//
//       Unable to convert Infinity to Int64.
//       Unable to convert Infinity to UInt64.
//       Unable to convert Infinity to Decimal.
//       Infinity (Double) --> Infinity (Single)
//
//       Unable to convert -Infinity to Int64.
//       Unable to convert -Infinity to UInt64.
//       Unable to convert -Infinity to Decimal.
//       -Infinity (Double) --> -Infinity (Single)
// The example displays the following output for conversions performed
// in an unchecked context:
//       -1.79769313486232E+308 (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       -1.79769313486232E+308 (Double) --> 9223372036854775808 (0x8000000000000000) (UInt64)
//       Unable to convert -1.79769313486232E+308 to Decimal.
//       -1.79769313486232E+308 (Double) --> -Infinity (Single)
//
//       -67890.1234 (Double) --> -67890 (0xFFFFFFFFFFFEF6CE) (Int64)
//       -67890.1234 (Double) --> 18446744073709483726 (0xFFFFFFFFFFFEF6CE) (UInt64)
//       -67890.1234 (Double) --> -67890.1234 (Decimal)
//       -67890.1234 (Double) --> -67890.13 (Single)
//
//       -12345.6789 (Double) --> -12345 (0xFFFFFFFFFFFFCFC7) (Int64)
//       -12345.6789 (Double) --> 18446744073709539271 (0xFFFFFFFFFFFFCFC7) (UInt64)
//       -12345.6789 (Double) --> -12345.6789 (Decimal)
//       -12345.6789 (Double) --> -12345.68 (Single)
//
//       12345.6789 (Double) --> 12345 (0x0000000000003039) (Int64)
//       12345.6789 (Double) --> 12345 (0x0000000000003039) (UInt64)
//       12345.6789 (Double) --> 12345.6789 (Decimal)
//       12345.6789 (Double) --> 12345.68 (Single)
//
//       67890.1234 (Double) --> 67890 (0x0000000000010932) (Int64)
//       67890.1234 (Double) --> 67890 (0x0000000000010932) (UInt64)
//       67890.1234 (Double) --> 67890.1234 (Decimal)
//       67890.1234 (Double) --> 67890.13 (Single)
//
//       1.79769313486232E+308 (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       1.79769313486232E+308 (Double) --> 0 (0x0000000000000000) (UInt64)
//       Unable to convert 1.79769313486232E+308 to Decimal.
//       1.79769313486232E+308 (Double) --> Infinity (Single)
//
//       NaN (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       NaN (Double) --> 0 (0x0000000000000000) (UInt64)
//       Unable to convert NaN to Decimal.
//       NaN (Double) --> NaN (Single)
//
//       Infinity (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       Infinity (Double) --> 0 (0x0000000000000000) (UInt64)
//       Unable to convert Infinity to Decimal.
//       Infinity (Double) --> Infinity (Single)
//
//       -Infinity (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       -Infinity (Double) --> 9223372036854775808 (0x8000000000000000) (UInt64)
//       Unable to convert -Infinity to Decimal.
//       -Infinity (Double) --> -Infinity (Single)

open System
open Checked

let values = 
    [| Double.MinValue; -67890.1234; -12345.6789
       12345.6789; 67890.1234; Double.MaxValue
       Double.NaN; Double.PositiveInfinity;
       Double.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."
    try
        let sValue = float32 value
        printfn $"{value} ({value.GetType().Name}) --> {sValue} ({sValue.GetType().Name})"
    with :? OverflowException ->
        printfn $"Unable to convert {value} to Single."
    printfn ""
// The example displays the following output for conversions performed
// in a checked context:
//       Unable to convert -1.79769313486232E+308 to Int64.
//       Unable to convert -1.79769313486232E+308 to UInt64.
//       Unable to convert -1.79769313486232E+308 to Decimal.
//       -1.79769313486232E+308 (Double) --> -Infinity (Single)
//
//       -67890.1234 (Double) --> -67890 (0xFFFFFFFFFFFEF6CE) (Int64)
//       Unable to convert -67890.1234 to UInt64.
//       -67890.1234 (Double) --> -67890.1234 (Decimal)
//       -67890.1234 (Double) --> -67890.13 (Single)
//
//       -12345.6789 (Double) --> -12345 (0xFFFFFFFFFFFFCFC7) (Int64)
//       Unable to convert -12345.6789 to UInt64.
//       -12345.6789 (Double) --> -12345.6789 (Decimal)
//       -12345.6789 (Double) --> -12345.68 (Single)
//
//       12345.6789 (Double) --> 12345 (0x0000000000003039) (Int64)
//       12345.6789 (Double) --> 12345 (0x0000000000003039) (UInt64)
//       12345.6789 (Double) --> 12345.6789 (Decimal)
//       12345.6789 (Double) --> 12345.68 (Single)
//
//       67890.1234 (Double) --> 67890 (0x0000000000010932) (Int64)
//       67890.1234 (Double) --> 67890 (0x0000000000010932) (UInt64)
//       67890.1234 (Double) --> 67890.1234 (Decimal)
//       67890.1234 (Double) --> 67890.13 (Single)
//
//       Unable to convert 1.79769313486232E+308 to Int64.
//       Unable to convert 1.79769313486232E+308 to UInt64.
//       Unable to convert 1.79769313486232E+308 to Decimal.
//       1.79769313486232E+308 (Double) --> Infinity (Single)
//
//       Unable to convert NaN to Int64.
//       Unable to convert NaN to UInt64.
//       Unable to convert NaN to Decimal.
//       NaN (Double) --> NaN (Single)
//
//       Unable to convert Infinity to Int64.
//       Unable to convert Infinity to UInt64.
//       Unable to convert Infinity to Decimal.
//       Infinity (Double) --> Infinity (Single)
//
//       Unable to convert -Infinity to Int64.
//       Unable to convert -Infinity to UInt64.
//       Unable to convert -Infinity to Decimal.
//       -Infinity (Double) --> -Infinity (Single)
// The example displays the following output for conversions performed
// in an unchecked context:
//       -1.79769313486232E+308 (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       -1.79769313486232E+308 (Double) --> 9223372036854775808 (0x8000000000000000) (UInt64)
//       Unable to convert -1.79769313486232E+308 to Decimal.
//       -1.79769313486232E+308 (Double) --> -Infinity (Single)
//
//       -67890.1234 (Double) --> -67890 (0xFFFFFFFFFFFEF6CE) (Int64)
//       -67890.1234 (Double) --> 18446744073709483726 (0xFFFFFFFFFFFEF6CE) (UInt64)
//       -67890.1234 (Double) --> -67890.1234 (Decimal)
//       -67890.1234 (Double) --> -67890.13 (Single)
//
//       -12345.6789 (Double) --> -12345 (0xFFFFFFFFFFFFCFC7) (Int64)
//       -12345.6789 (Double) --> 18446744073709539271 (0xFFFFFFFFFFFFCFC7) (UInt64)
//       -12345.6789 (Double) --> -12345.6789 (Decimal)
//       -12345.6789 (Double) --> -12345.68 (Single)
//
//       12345.6789 (Double) --> 12345 (0x0000000000003039) (Int64)
//       12345.6789 (Double) --> 12345 (0x0000000000003039) (UInt64)
//       12345.6789 (Double) --> 12345.6789 (Decimal)
//       12345.6789 (Double) --> 12345.68 (Single)
//
//       67890.1234 (Double) --> 67890 (0x0000000000010932) (Int64)
//       67890.1234 (Double) --> 67890 (0x0000000000010932) (UInt64)
//       67890.1234 (Double) --> 67890.1234 (Decimal)
//       67890.1234 (Double) --> 67890.13 (Single)
//
//       1.79769313486232E+308 (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       1.79769313486232E+308 (Double) --> 0 (0x0000000000000000) (UInt64)
//       Unable to convert 1.79769313486232E+308 to Decimal.
//       1.79769313486232E+308 (Double) --> Infinity (Single)
//
//       NaN (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       NaN (Double) --> 0 (0x0000000000000000) (UInt64)
//       Unable to convert NaN to Decimal.
//       NaN (Double) --> NaN (Single)
//
//       Infinity (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       Infinity (Double) --> 0 (0x0000000000000000) (UInt64)
//       Unable to convert Infinity to Decimal.
//       Infinity (Double) --> Infinity (Single)
//
//       -Infinity (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       -Infinity (Double) --> 9223372036854775808 (0x8000000000000000) (UInt64)
//       Unable to convert -Infinity to Decimal.
//       -Infinity (Double) --> -Infinity (Single)

Module Example6
    Public Sub Run()
        Dim values() As Double = {Double.MinValue, -67890.1234, -12345.6789,
                                 12345.6789, 67890.1234, Double.MaxValue,
                                 Double.NaN, Double.PositiveInfinity,
                                 Double.NegativeInfinity}
        For Each value In values
            Try
                Dim lValue As Int64 = 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
            Try
                Dim sValue As Single = CSng(value)
                Console.WriteLine("{0} ({1}) --> {2} ({3})",
                               value, value.GetType().Name,
                               sValue, sValue.GetType().Name)
            Catch e As OverflowException
                Console.WriteLine("Unable to convert {0} to Single.", value)
            End Try
            Console.WriteLine()
        Next
    End Sub
End Module
' The example displays the following output for conversions performed
' in a checked context:
'       Unable to convert -1.79769313486232E+308 to Int64.
'       Unable to convert -1.79769313486232E+308 to UInt64.
'       Unable to convert -1.79769313486232E+308 to Decimal.
'       -1.79769313486232E+308 (Double) --> -Infinity (Single)
'
'       -67890.1234 (Double) --> -67890 (0xFFFFFFFFFFFEF6CE) (Int64)
'       Unable to convert -67890.1234 to UInt64.
'       -67890.1234 (Double) --> -67890.1234 (Decimal)
'       -67890.1234 (Double) --> -67890.13 (Single)
'
'       -12345.6789 (Double) --> -12346 (0xFFFFFFFFFFFFCFC6) (Int64)
'       Unable to convert -12345.6789 to UInt64.
'       -12345.6789 (Double) --> -12345.6789 (Decimal)
'       -12345.6789 (Double) --> -12345.68 (Single)
'
'       12345.6789 (Double) --> 12346 (0x000000000000303A) (Int64)
'       12345.6789 (Double) --> 12346 (0x000000000000303A) (UInt64)
'       12345.6789 (Double) --> 12345.6789 (Decimal)
'       12345.6789 (Double) --> 12345.68 (Single)
'
'       67890.1234 (Double) --> 67890 (0x0000000000010932) (Int64)
'       67890.1234 (Double) --> 67890 (0x0000000000010932) (UInt64)
'       67890.1234 (Double) --> 67890.1234 (Decimal)
'       67890.1234 (Double) --> 67890.13 (Single)
'
'       Unable to convert 1.79769313486232E+308 to Int64.
'       Unable to convert 1.79769313486232E+308 to UInt64.
'       Unable to convert 1.79769313486232E+308 to Decimal.
'       1.79769313486232E+308 (Double) --> Infinity (Single)
'
'       Unable to convert NaN to Int64.
'       Unable to convert NaN to UInt64.
'       Unable to convert NaN to Decimal.
'       NaN (Double) --> NaN (Single)
'
'       Unable to convert Infinity to Int64.
'       Unable to convert Infinity to UInt64.
'       Unable to convert Infinity to Decimal.
'       Infinity (Double) --> Infinity (Single)
'
'       Unable to convert -Infinity to Int64.
'       Unable to convert -Infinity to UInt64.
'       Unable to convert -Infinity to Decimal.
'       -Infinity (Double) --> -Infinity (Single)
' The example displays the following output for conversions performed
' in an unchecked context:
'       -1.79769313486232E+308 (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
'       -1.79769313486232E+308 (Double) --> 9223372036854775808 (0x8000000000000000) (UInt64)
'       Unable to convert -1.79769313486232E+308 to Decimal.
'       -1.79769313486232E+308 (Double) --> -Infinity (Single)
'
'       -67890.1234 (Double) --> -67890 (0xFFFFFFFFFFFEF6CE) (Int64)
'       -67890.1234 (Double) --> 18446744073709483726 (0xFFFFFFFFFFFEF6CE) (UInt64)
'       -67890.1234 (Double) --> -67890.1234 (Decimal)
'       -67890.1234 (Double) --> -67890.13 (Single)
'
'       -12345.6789 (Double) --> -12346 (0xFFFFFFFFFFFFCFC6) (Int64)
'       -12345.6789 (Double) --> 18446744073709539270 (0xFFFFFFFFFFFFCFC6) (UInt64)
'       -12345.6789 (Double) --> -12345.6789 (Decimal)
'       -12345.6789 (Double) --> -12345.68 (Single)
'
'       12345.6789 (Double) --> 12346 (0x000000000000303A) (Int64)
'       12345.6789 (Double) --> 12346 (0x000000000000303A) (UInt64)
'       12345.6789 (Double) --> 12345.6789 (Decimal)
'       12345.6789 (Double) --> 12345.68 (Single)
'
'       67890.1234 (Double) --> 67890 (0x0000000000010932) (Int64)
'       67890.1234 (Double) --> 67890 (0x0000000000010932) (UInt64)
'       67890.1234 (Double) --> 67890.1234 (Decimal)
'       67890.1234 (Double) --> 67890.13 (Single)
'
'       1.79769313486232E+308 (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
'       1.79769313486232E+308 (Double) --> 0 (0x0000000000000000) (UInt64)
'       Unable to convert 1.79769313486232E+308 to Decimal.
'       1.79769313486232E+308 (Double) --> Infinity (Single)
'
'       NaN (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
'       NaN (Double) --> 0 (0x0000000000000000) (UInt64)
'       Unable to convert NaN to Decimal.
'       NaN (Double) --> NaN (Single)
'
'       Infinity (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
'       Infinity (Double) --> 0 (0x0000000000000000) (UInt64)
'       Unable to convert Infinity to Decimal.
'       Infinity (Double) --> Infinity (Single)
'
'       -Infinity (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
'       -Infinity (Double) --> 9223372036854775808 (0x8000000000000000) (UInt64)
'       Unable to convert -Infinity to Decimal.
'       -Infinity (Double) --> -Infinity (Single)

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 Double structure et les types associés fournissent des méthodes pour effectuer des opérations dans les domaines suivants :

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

  La Double 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. Si l’un des opérandes est un type numérique autre qu’un Double, il est converti en un Double avant d’effectuer la comparaison.

  Avertissement

  En raison des différences de précision, deux Double 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 Double valeurs, consultez la section Test pour égalité .

  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 Double. Si l’un des opérandes d’une opération mathématique est un type numérique autre qu’un Double, il est converti en un Double avant d’effectuer l’opération. Le résultat de l’opération est également une Double valeur.

  D’autres opérations mathématiques peuvent être effectuées en appelant static (Shared en Visual Basic) des méthodes dans la System.Math classe. Il inclut des 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 exemple Math.Log).

  Vous pouvez également manipuler les bits individuels dans une Double valeur. La BitConverter.DoubleToInt64Bits méthode conserve le modèle de bits d’une Double valeur dans un entier 64 bits. La méthode BitConverter.GetBytes(Double) renvoie son schéma binaire dans un tableau d'octets.

• 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 Double valeur en appelant la Math.Round méthode.

• Mise en forme. Vous pouvez convertir une Double 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 à virgule flottante en valeur Double 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 Double fournit une implémentation d’interface explicite pour l’interface IConvertible, qui prend en charge la conversion entre deux types de données .NET standard. Les compilateurs de langage prennent également en charge la conversion implicite de valeurs de tous les autres types numériques standard en Double valeurs. La conversion d’une valeur d’un type numérique standard en un Double est une conversion élargie et ne nécessite pas l’utilisation d’un opérateur de conversion ou d’une méthode de conversion.

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

  Type	Précision maximale	Précision interne
  Double	15	17
  Int64	19 chiffres décimaux	19 chiffres décimaux
  Single	7 chiffres décimaux	9 chiffres décimaux

  Le problème de précision affecte le plus 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 inégales, car l’une des valeurs est une valeur virgule flottante simple précision convertie en Double.

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

  let value = 0.1
  let result1 = value * 10.
  let mutable result2 = 0.
  for i = 1 to 10 do
      result2 <- result2 + value
  
  printfn $".1 * 10:           {result1:R}"
  printfn $".1 Added 10 times: {result2:R}"
  // The example displays the following output:
  //       .1 * 10:           1
  //       .1 Added 10 times: 0.99999999999999989
  

  Module Example14
      Public Sub Run()
          Dim value As Double = 0.1
          Dim result1 As Double = value * 10
          Dim result2 As Double
          For ctr As Integer = 1 To 10
              result2 += value
          Next
          Console.WriteLine(".1 * 10:           {0:R}", result1)
          Console.WriteLine(".1 Added 10 times: {0:R}", result2)
      End Sub
  End Module
  ' The example displays the following output:
  '       .1 * 10:           1
  '       .1 Added 10 times: 0.99999999999999989
  

Champs

Nom	Description
E	Représente la base logarithmique naturelle, spécifiée par la constante, e.
Epsilon	Représente la plus petite valeur positive Double supérieure à zéro. Ce champ est constant.
MaxValue	Représente la plus grande valeur possible d’un Double. Ce champ est constant.
MinValue	Représente la plus petite valeur possible d’un Double. Ce champ est constant.
NaN	Représente une valeur qui n’est pas un nombre (NaN). Ce champ est constant.
NegativeInfinity	Représente l’infini négatif. Ce champ est constant.
NegativeZero	Représente le nombre négatif zéro (-0).
Pi	Représente le rapport de la circonférence d’un cercle à son diamètre, spécifié par la constante, π.
PositiveInfinity	Représente l’infini positif. Ce champ est constant.
Tau	Représente le nombre de radians à un tour, spécifié par la constante, τ.

Méthodes

Nom	Description
Abs(Double)	Calcule l’absolu d’une valeur.
Acos(Double)	Calcule le cosinus arc d’une valeur.
Acosh(Double)	Calcule le cosinus d’arc hyperbolique d’une valeur.
AcosPi(Double)	Calcule le cosinus arc d’une valeur et divise le résultat par pi.
Asin(Double)	Calcule le sinus arc d’une valeur.
Asinh(Double)	Calcule le sinus d’arc hyperbolique d’une valeur.
AsinPi(Double)	Calcule le sinus d’arc d’une valeur et divise le résultat par pi.
Atan(Double)	Calcule la tangente arc d’une valeur.
Atan2(Double, Double)	Calcule la tangente arc du quotient de deux valeurs.
Atan2Pi(Double, Double)	Calcule la tangente arc pour le quotient de deux valeurs et divise le résultat par pi.
Atanh(Double)	Calcule la tangente d’arc hyperbolique d’une valeur.
AtanPi(Double)	Calcule la tangente arc d’une valeur et divise le résultat par pi.
BitDecrement(Double)	Retourne la plus grande valeur qui compare moins qu’une valeur spécifiée.
BitIncrement(Double)	Retourne la plus petite valeur qui compare une valeur supérieure à une valeur spécifiée.
Cbrt(Double)	Calcule la racine du cube d’une valeur.
Ceiling(Double)	Calcule le plafond d’une valeur.
Clamp(Double, Double, Double)	Limite une valeur à une valeur minimale et maximale inclusive.
ClampNative(Double, Double, Double)	Limite une valeur à une valeur minimale et maximale inclusive à l’aide d’un comportement spécifique à la plateforme pour NaN et NegativeZero.
CompareTo(Double)	Compare cette instance à un nombre à virgule flottante double précision spécifié et retourne un entier qui indique si la valeur de cette instance est inférieure, égale ou supérieure à la valeur du nombre à virgule flottante double précision spécifié.
CompareTo(Object)	Compare cette instance à un objet spécifié et retourne un entier qui indique si la valeur de cette instance est inférieure, égale ou supérieure à la valeur de l’objet spécifié.
ConvertToInteger<TInteger>(Double)	Convertit une valeur en type entier spécifié à l’aide de la saturation sur le dépassement de capacité
ConvertToIntegerNative<TInteger>(Double)	Convertit une valeur en type entier spécifié à l’aide d’un comportement spécifique à la plateforme sur le dépassement de capacité.
CopySign(Double, Double)	Copie le signe d’une valeur au signe d’une autre valeur.
Cos(Double)	Calcule le cosinus d’une valeur.
Cosh(Double)	Calcule le cosinus hyperbolique d’une valeur.
CosPi(Double)	Calcule le cosinus d’une valeur qui a été multiple par pi.
CreateChecked<TOther>(TOther)	Crée une instance du type actuel à partir d’une valeur, lève une exception de dépassement de capacité pour toutes les valeurs qui se trouvent en dehors de la plage représentée du type actuel.
CreateSaturating<TOther>(TOther)	Crée une instance du type actuel à partir d’une valeur, en saturant toutes les valeurs qui se trouvent en dehors de la plage représentée du type actuel.
CreateTruncating<TOther>(TOther)	Crée une instance du type actuel à partir d’une valeur, tronqué toutes les valeurs qui se trouvent en dehors de la plage représentée du type actuel.
DegreesToRadians(Double)	Convertit une valeur donnée de degrés en radians.
Equals(Double)	Retourne une valeur indiquant si cette instance et un objet spécifié Double représentent la même valeur.
Equals(Object)	Retourne une valeur indiquant si cette instance est égale à un objet spécifié.
Exp(Double)	Calculs déclenchés E à une puissance donnée.
Exp10(Double)	Calculs déclenchés 10 à une puissance donnée.
Exp10M1(Double)	Calculs déclenchés 10 à une puissance donnée et en soustrait un.
Exp2(Double)	Calculs déclenchés 2 à une puissance donnée.
Exp2M1(Double)	Calculs déclenchés 2 à une puissance donnée et en soustrait un.
ExpM1(Double)	Calculs déclenchés E à une puissance donnée et en soustrait un.
Floor(Double)	Calcule le plancher d’une valeur.
FusedMultiplyAdd(Double, Double, Double)	Calcule l’addition multipliée fusionnée de trois valeurs.
GetHashCode()	Retourne le code de hachage pour cette instance.
GetTypeCode()	Retourne le TypeCode type Doublevaleur .
Hypot(Double, Double)	Calcule l’hypotenuse donnée deux valeurs représentant les longueurs des côtés les plus courts dans un triangle à angle droit.
Ieee754Remainder(Double, Double)	Calcule le reste de deux valeurs, comme spécifié par IEEE 754.
ILogB(Double)	Calcule le logarithme entier d’une valeur.
IsEvenInteger(Double)	Détermine si une valeur représente un nombre intégral pair.
IsFinite(Double)	Détermine si la valeur spécifiée est finie (zéro, subnormal ou normal).
IsInfinity(Double)	Retourne une valeur indiquant si le nombre spécifié est évalué à l’infini négatif ou positif.
IsInteger(Double)	Détermine si une valeur représente une valeur intégrale.
IsNaN(Double)	Retourne une valeur qui indique si la valeur spécifiée n’est pas un nombre (NaN).
IsNegative(Double)	Détermine si la valeur spécifiée est négative.
IsNegativeInfinity(Double)	Retourne une valeur indiquant si le nombre spécifié est évalué à l’infini négatif.
IsNormal(Double)	Détermine si la valeur spécifiée est normale.
IsOddInteger(Double)	Détermine si une valeur représente un nombre intégral impair.
IsPositive(Double)	Détermine si une valeur est positive.
IsPositiveInfinity(Double)	Retourne une valeur indiquant si le nombre spécifié est évalué à l’infini positif.
IsPow2(Double)	Détermine si une valeur est une puissance de deux.
IsRealNumber(Double)	Détermine si une valeur représente un nombre réel.
IsSubnormal(Double)	Détermine si la valeur spécifiée est subnormale.
Lerp(Double, Double, Double)	Effectue une interpolation linéaire entre deux valeurs en fonction du poids donné.
Log(Double, Double)	Calcule le logarithme d’une valeur dans la base spécifiée.
Log(Double)	Calcule le logarithme naturel d’unebase-E valeur.
Log10(Double)	Calcule le logarithme de base 10 d’une valeur.
Log10P1(Double)	Calcule le logarithme de base 10 d’une valeur plus une.
Log2(Double)	Calcule le journal2 d’une valeur.
Log2P1(Double)	Calcule le logarithme de base 2 d’une valeur plus un.
LogP1(Double)	Calcule le logarithme naturel (base-E) d’une valeur plus un.
Max(Double, Double)	Compare deux valeurs au calcul, ce qui est supérieur.
MaxMagnitude(Double, Double)	Compare deux valeurs au calcul, ce qui est supérieur.
MaxMagnitudeNumber(Double, Double)	Compare deux valeurs au calcul qui a la plus grande magnitude et retourne l’autre valeur si une entrée est NaN.
MaxNative(Double, Double)	Compare deux valeurs au calcul qui est plus grande à l’aide d’un comportement spécifique à la plateforme pour NaN et NegativeZero.
MaxNumber(Double, Double)	Compare deux valeurs au calcul qui est supérieure et retourne l’autre valeur si une entrée est NaN.
Min(Double, Double)	Compare deux valeurs au calcul, ce qui est inférieur.
MinMagnitude(Double, Double)	Compare deux valeurs au calcul, ce qui est inférieur.
MinMagnitudeNumber(Double, Double)	Compare deux valeurs au calcul dont la magnitude est inférieure et retourne l’autre valeur si une entrée est NaN.
MinNative(Double, Double)	Compare deux valeurs au calcul, ce qui est inférieur à l’utilisation du comportement spécifique à la plateforme pour NaN et NegativeZero.
MinNumber(Double, Double)	Compare deux valeurs au calcul, ce qui est inférieur et retourne l’autre valeur si une entrée est NaN.
MultiplyAddEstimate(Double, Double, Double)	Calcule une estimation de (left * right) + addend.
Parse(ReadOnlySpan<Byte>, IFormatProvider)	Analyse une étendue de caractères UTF-8 en une valeur.
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)	Analyse une étendue de caractères UTF-8 en une valeur.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Analyse une étendue de caractères en une valeur.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Convertit une étendue de caractères qui contient la représentation sous forme de chaîne d’un nombre dans un style et un format spécifique à la culture spécifiés en nombre à virgule flottante double précision équivalent.
Parse(String, IFormatProvider)	Convertit la représentation sous forme de chaîne d’un nombre dans un format spécifique à la culture spécifié en nombre à virgule flottante double précision équivalent.
Parse(String, NumberStyles, IFormatProvider)	Convertit la représentation sous forme de chaîne d’un nombre dans un style et un format spécifique à la culture spécifiés en nombre à virgule flottante double précision équivalent.
Parse(String, NumberStyles)	Convertit la représentation sous forme de chaîne d’un nombre dans un style spécifié en nombre à virgule flottante double précision équivalent.
Parse(String)	Convertit la représentation sous forme de chaîne d’un nombre en nombre à virgule flottante double précision équivalent.
Pow(Double, Double)	Calcule une valeur élevée à une puissance donnée.
RadiansToDegrees(Double)	Convertit une valeur donnée de radians en degrés.
ReciprocalEstimate(Double)	Calcule une estimation de la réciproque d’une valeur.
ReciprocalSqrtEstimate(Double)	Calcule une estimation de la racine carrée réciproque d’une valeur.
RootN(Double, Int32)	Calcule la n-ième racine d’une valeur.
Round(Double, Int32, MidpointRounding)	Arrondit une valeur à un nombre spécifié de chiffres fractionnaires à l’aide du mode d’arrondi par défaut (ToEven).
Round(Double, Int32)	Arrondit une valeur à un nombre spécifié de chiffres fractionnaires à l’aide du mode d’arrondi par défaut (ToEven).
Round(Double, MidpointRounding)	Arrondit une valeur à l’entier le plus proche à l’aide du mode d’arrondi spécifié.
Round(Double)	Arrondit une valeur à l’entier le plus proche à l’aide du mode d’arrondi par défaut (ToEven).
ScaleB(Double, Int32)	Calcule le produit d’une valeur et son rayon de base élevé à la puissance spécifiée.
Sign(Double)	Calcule le signe d’une valeur.
Sin(Double)	Calcule le sinus d’une valeur.
SinCos(Double)	Calcule le sinus et le cosinus d’une valeur.
SinCosPi(Double)	Calcule le sinus et le cosinus d’une valeur.
Sinh(Double)	Calcule le sinus hyperbolique d’une valeur.
SinPi(Double)	Calcule le sinus d’une valeur multipliée par pi.
Sqrt(Double)	Calcule la racine carrée d’une valeur.
Tan(Double)	Calcule la tangente d’une valeur.
Tanh(Double)	Calcule la tangente hyperbolique d’une valeur.
TanPi(Double)	Calcule la tangente d’une valeur qui a été multiple par pi.
ToString()	Convertit la valeur numérique de cette instance en sa représentation sous forme de chaîne équivalente.
ToString(IFormatProvider)	Convertit la valeur numérique de cette instance en sa représentation sous forme de chaîne équivalente à l’aide des informations de format spécifiques à la culture spécifiées.
ToString(String, IFormatProvider)	Convertit la valeur numérique de cette instance en sa représentation sous forme de chaîne équivalente à l’aide des informations de format spécifiques à la culture et au format spécifiés.
ToString(String)	Convertit la valeur numérique de cette instance en sa représentation sous forme de chaîne équivalente, à l’aide du format spécifié.
Truncate(Double)	Tronque une valeur.
TryFormat(Span<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Tente de mettre en forme la valeur de l’instance actuelle en UTF-8 dans l’étendue fournie d’octets.
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Tente de mettre en forme la valeur de l’instance double actuelle dans l’étendue fournie de caractères.
TryParse(ReadOnlySpan<Byte>, Double)	Tente de convertir une étendue de caractères UTF-8 contenant la représentation sous forme de chaîne d’un nombre en nombre à virgule flottante double précision équivalent.
TryParse(ReadOnlySpan<Byte>, IFormatProvider, Double)	Tente d’analyser une étendue de caractères UTF-8 en une valeur.
TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, Double)	Tente d’analyser une étendue de caractères UTF-8 en une valeur.
TryParse(ReadOnlySpan<Char>, Double)	Convertit la représentation d’étendue d’un nombre dans un style et un format spécifique à la culture spécifiés en nombre à virgule flottante double précision équivalent. Une valeur de retour indique si la conversion a réussi ou échoué.
TryParse(ReadOnlySpan<Char>, IFormatProvider, Double)	Tente d’analyser une étendue de caractères en une valeur.
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Double)	Convertit une étendue de caractères contenant la représentation sous forme de chaîne d’un nombre dans un style et un format spécifique à la culture spécifiés en nombre à virgule flottante double précision équivalent. Une valeur de retour indique si la conversion a réussi ou échoué.
TryParse(String, Double)	Convertit la représentation sous forme de chaîne d’un nombre en nombre à virgule flottante double précision équivalent. Une valeur de retour indique si la conversion a réussi ou échoué.
TryParse(String, IFormatProvider, Double)	Tente d’analyser une chaîne en une valeur.
TryParse(String, NumberStyles, IFormatProvider, Double)	Convertit la représentation sous forme de chaîne d’un nombre dans un style et un format spécifique à la culture spécifiés en nombre à virgule flottante double précision équivalent. Une valeur de retour indique si la conversion a réussi ou échoué.

Opérateurs

Nom	Description
Equality(Double, Double)	Retourne une valeur qui indique si deux valeurs spécifiées sont égales Double .
GreaterThan(Double, Double)	Retourne une valeur qui indique si une valeur spécifiée Double est supérieure à une autre valeur spécifiée Double .
GreaterThanOrEqual(Double, Double)	Retourne une valeur qui indique si une valeur spécifiée Double est supérieure ou égale à une autre valeur spécifiée Double .
Inequality(Double, Double)	Retourne une valeur qui indique si deux valeurs spécifiées ne sont pas égales Double .
LessThan(Double, Double)	Retourne une valeur qui indique si une valeur spécifiée Double est inférieure à une autre valeur spécifiée Double .
LessThanOrEqual(Double, Double)	Retourne une valeur qui indique si une valeur spécifiée Double est inférieure ou égale à une autre valeur spécifiée Double .

Implémentations d’interfaces explicites

Nom	Description
IAdditionOperators<Double,Double,Double>.Addition(Double, Double)	Ajoute deux valeurs ensemble pour calculer leur somme.
IAdditiveIdentity<Double,Double>.AdditiveIdentity	Obtient l’identité additive du type actuel.
IBinaryNumber<Double>.AllBitsSet	Obtient une instance du type binaire dans laquelle tous les bits sont définis.
IBitwiseOperators<Double,Double,Double>.BitwiseAnd(Double, Double)	Calcule les valeurs au niveau du bit et de deux valeurs.
IBitwiseOperators<Double,Double,Double>.BitwiseOr(Double, Double)	Calcule les valeurs au niveau du bit ou de deux valeurs.
IBitwiseOperators<Double,Double,Double>.ExclusiveOr(Double, Double)	Calcule les valeurs exclusives ou de deux valeurs.
IBitwiseOperators<Double,Double,Double>.OnesComplement(Double)	Calcule la représentation complète d’une valeur donnée.
IConvertible.ToBoolean(IFormatProvider)	Pour obtenir une description de ce membre, consultez ToBoolean(IFormatProvider).
IConvertible.ToByte(IFormatProvider)	Pour obtenir une description de ce membre, consultez ToByte(IFormatProvider).
IConvertible.ToChar(IFormatProvider)	Cette conversion n’est pas prise en charge. La tentative d’utilisation de cette méthode lève un InvalidCastException.
IConvertible.ToDateTime(IFormatProvider)	Cette conversion n’est pas prise en charge. La tentative d’utilisation de cette méthode lève un InvalidCastException.
IConvertible.ToDecimal(IFormatProvider)	Pour obtenir une description de ce membre, consultez ToDecimal(IFormatProvider).
IConvertible.ToDouble(IFormatProvider)	Pour obtenir une description de ce membre, consultez ToDouble(IFormatProvider).
IConvertible.ToInt16(IFormatProvider)	Pour obtenir une description de ce membre, consultez ToInt16(IFormatProvider).
IConvertible.ToInt32(IFormatProvider)	Pour obtenir une description de ce membre, consultez ToInt32(IFormatProvider).
IConvertible.ToInt64(IFormatProvider)	Pour obtenir une description de ce membre, consultez ToInt64(IFormatProvider).
IConvertible.ToSByte(IFormatProvider)	Pour obtenir une description de ce membre, consultez ToSByte(IFormatProvider).
IConvertible.ToSingle(IFormatProvider)	Pour obtenir une description de ce membre, consultez ToSingle(IFormatProvider).
IConvertible.ToType(Type, IFormatProvider)	Pour obtenir une description de ce membre, consultez ToType(Type, IFormatProvider).
IConvertible.ToUInt16(IFormatProvider)	Pour obtenir une description de ce membre, consultez ToUInt16(IFormatProvider).
IConvertible.ToUInt32(IFormatProvider)	Pour obtenir une description de ce membre, consultez ToUInt32(IFormatProvider).
IConvertible.ToUInt64(IFormatProvider)	Pour obtenir une description de ce membre, consultez ToUInt64(IFormatProvider).
IDecrementOperators<Double>.Decrement(Double)	Décrémente une valeur.
IDivisionOperators<Double,Double,Double>.Division(Double, Double)	Divise une valeur par une autre pour calculer leur quotient.
IFloatingPoint<Double>.GetExponentByteCount()	Obtient le nombre d’octets qui seront écrits dans le cadre de TryWriteExponentLittleEndian(Span<Byte>, Int32).
IFloatingPoint<Double>.GetExponentShortestBitLength()	Obtient la longueur, en bits, de la représentation complète des deux plus courtes de l’exposant actuel.
IFloatingPoint<Double>.GetSignificandBitLength()	Obtient la longueur, en bits, du signe actuel.
IFloatingPoint<Double>.GetSignificandByteCount()	Obtient le nombre d’octets qui seront écrits dans le cadre de TryWriteSignificandLittleEndian(Span<Byte>, Int32).
IFloatingPoint<Double>.TryWriteExponentBigEndian(Span<Byte>, Int32)	Tente d’écrire l’exposant actuel, au format big-endian, dans une étendue donnée.
IFloatingPoint<Double>.TryWriteExponentLittleEndian(Span<Byte>, Int32)	Tente d’écrire l’exposant actuel, au format little-endian, dans une étendue donnée.
IFloatingPoint<Double>.TryWriteSignificandBigEndian(Span<Byte>, Int32)	Tente d’écrire le significand actuel, au format big-endian, dans une étendue donnée.
IFloatingPoint<Double>.TryWriteSignificandLittleEndian(Span<Byte>, Int32)	Tente d’écrire le significand actuel, au format little-endian, dans une étendue donnée.
IFloatingPointConstants<Double>.E	Obtient la constante emathématique .
IFloatingPointConstants<Double>.Pi	Obtient la constante pimathématique .
IFloatingPointConstants<Double>.Tau	Obtient la constante taumathématique .
IFloatingPointIeee754<Double>.Epsilon	Obtient la valeur la plus petite, telle qu’elle peut être ajoutée à 0 ce qui ne se traduit pas par 0.
IFloatingPointIeee754<Double>.NaN	Obtient une valeur qui représente NaN.
IFloatingPointIeee754<Double>.NegativeInfinity	Obtient une valeur qui représente négatif infinity.
IFloatingPointIeee754<Double>.NegativeZero	Obtient une valeur qui représente négatif zero.
IFloatingPointIeee754<Double>.PositiveInfinity	Obtient une valeur qui représente un positif infinity.
IIncrementOperators<Double>.Increment(Double)	Incrémente une valeur.
IMinMaxValue<Double>.MaxValue	Obtient la valeur maximale du type actuel.
IMinMaxValue<Double>.MinValue	Obtient la valeur minimale du type actuel.
IModulusOperators<Double,Double,Double>.Modulus(Double, Double)	Divise deux valeurs ensemble pour calculer leur module ou leur reste.
IMultiplicativeIdentity<Double,Double>.MultiplicativeIdentity	Obtient l’identité multiplicative du type actuel.
IMultiplyOperators<Double,Double,Double>.Multiply(Double, Double)	Multiplie deux valeurs ensemble pour calculer leur produit.
INumberBase<Double>.IsCanonical(Double)	Détermine si une valeur se trouve dans sa représentation canonique.
INumberBase<Double>.IsComplexNumber(Double)	Détermine si une valeur représente un nombre complexe.
INumberBase<Double>.IsImaginaryNumber(Double)	Détermine si une valeur représente un nombre imaginaire pur.
INumberBase<Double>.IsZero(Double)	Détermine si une valeur est égale à zéro.
INumberBase<Double>.One	Obtient la valeur 1 du type.
INumberBase<Double>.Radix	Obtient le radix, ou la base, pour le type.
INumberBase<Double>.TryConvertFromChecked<TOther>(TOther, Double)	Représente un nombre à virgule flottante double précision.
INumberBase<Double>.TryConvertFromSaturating<TOther>(TOther, Double)	Représente un nombre à virgule flottante double précision.
INumberBase<Double>.TryConvertFromTruncating<TOther>(TOther, Double)	Représente un nombre à virgule flottante double précision.
INumberBase<Double>.TryConvertToChecked<TOther>(Double, TOther)	Tente de convertir une instance du type actuel en un autre type, lève une exception de dépassement de capacité pour toutes les valeurs qui se trouvent en dehors de la plage représentée du type actuel.
INumberBase<Double>.TryConvertToSaturating<TOther>(Double, TOther)	Tente de convertir une instance du type actuel en un autre type, en saturant toutes les valeurs qui se trouvent en dehors de la plage représentée du type actuel.
INumberBase<Double>.TryConvertToTruncating<TOther>(Double, TOther)	Tente de convertir une instance du type actuel en un autre type, en tronqué toutes les valeurs qui se trouvent en dehors de la plage représentée du type actuel.
INumberBase<Double>.Zero	Obtient la valeur 0 du type.
ISignedNumber<Double>.NegativeOne	Obtient la valeur -1 du type.
ISubtractionOperators<Double,Double,Double>.Subtraction(Double, Double)	Soustrait deux valeurs pour calculer leur différence.
IUnaryNegationOperators<Double,Double>.UnaryNegation(Double)	Calcule la négation unaire d’une valeur.
IUnaryPlusOperators<Double,Double>.UnaryPlus(Double)	Calcule le plus unaire d’une valeur.

Cohérence de thread

Tous les membres de ce type sont thread safe. Les membres qui semblent modifier l’état de l’instance retournent réellement une nouvelle instance initialisée avec la nouvelle valeur. Comme pour tout autre type, la lecture et l’écriture dans une variable partagée qui contient une instance de ce type doit être protégée par un verrou pour garantir la sécurité des threads.

Voir aussi

• Decimal
• Single
• exemple : Utilitaire de mise en forme WinForms .NET Core (C#)
• exemple : Utilitaire de mise en forme WinForms .NET Core (Visual Basic)