Double Struktur

Definition

Namespace:

System

Assembly:

System.Runtime.dll

Stellt eine Gleitkommazahl mit doppelter Genauigkeit dar.

public value class double : IComparable<double>, IConvertible, IEquatable<double>, IParsable<double>, ISpanParsable<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>, 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 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)

Vererbung

Object

ValueType

Double

Implementiert

IComparable IComparable<Double> IConvertible IEquatable<Double> IFormattable ISpanFormattable IComparable<TSelf> IEquatable<TSelf> IParsable<Double> IParsable<TSelf> ISpanParsable<Double> ISpanParsable<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>

Beispiele

Im folgenden Codebeispiel wird die Verwendung von Doubleveranschaulicht:

// The Temperature class stores the temperature as a Double
// and delegates most of the functionality to the Double 
// implementation.
public ref class Temperature: public IComparable, public IFormattable
{
   // IComparable.CompareTo implementation.
public:
   virtual int CompareTo( Object^ obj )
   {
      if (obj == nullptr) return 1;
      
      if (dynamic_cast<Temperature^>(obj) )
      {
         Temperature^ temp = (Temperature^)(obj);
         return m_value.CompareTo( temp->m_value );
      }
      throw gcnew ArgumentException( "object is not a Temperature" );
   }

   // IFormattable.ToString implementation.
   virtual String^ ToString( String^ format, IFormatProvider^ provider )
   {
      if ( format != nullptr )
      {
         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]
   static Temperature^ Parse( String^ s, NumberStyles styles, IFormatProvider^ provider )
   {
      Temperature^ temp = gcnew Temperature;

      if ( s->TrimEnd(nullptr)->EndsWith( "'F" ) )
      {
         temp->Value = Double::Parse( s->Remove( s->LastIndexOf( '\'' ), 2 ), styles, provider );
      }
      else
      if ( s->TrimEnd(nullptr)->EndsWith( "'C" ) )
      {
         temp->Celsius = Double::Parse( s->Remove( s->LastIndexOf( '\'' ), 2 ), styles, provider );
      }
      else
      {
         temp->Value = Double::Parse( s, styles, provider );
      }
      return temp;
   }

protected:
   double m_value;

public:
   property double Value 
   {
      double get()
      {
         return m_value;
      }

      void set( double value )
      {
         m_value = value;
      }
   }

   property double Celsius 
   {
      double get()
      {
         return (m_value - 32.0) / 1.8;
      }

      void set( double value )
      {
         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.
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(Nothing).EndsWith("'F") Then
            temp.Value = Double.Parse(s.Remove(s.LastIndexOf("'"c), 2), styles, provider)
        Else
            If s.TrimEnd(Nothing).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

Hinweise

Der Double Werttyp stellt eine 64-Bit-Zahl mit doppelter Genauigkeit dar, deren Werte von negativem 1.79769313486232e308 bis positivem 1.79769313486232e308 sowie positiver oder negativer Nullwert, PositiveInfinity, NegativeInfinityund nicht einer Zahl (NaN) entsprechen. Sie soll Werte darstellen, die extrem groß (z. B. Entfernungen zwischen Planeten oder Galaxien) oder extrem klein (z. B. die Molekularmasse einer Substanz in Kilogramm) und oft ungenau sind (z. B. die Entfernung von der Erde zu einem anderen Sonnensystem). Der Double Typ entspricht der NORM IEC 60559:1989 (IEEE 754) für binäre Gleitkommaarithmetik.

Dieses Thema enthält folgende Abschnitte:

• Gleitkommadarstellung und Genauigkeit

• Testen auf Gleichheit

• Gleitkommawerte und Ausnahmen

• Typkonvertierungen und die Double-Struktur

• Gleitkommafunktionalität

Floating-Point Darstellung und Genauigkeit

Der Double Datentyp speichert Gleitkommawerte mit doppelter Genauigkeit in einem 64-Bit-Binärformat, wie in der folgenden Tabelle gezeigt:

Teil	Bits
Significand oder Mantissa	0-51
Exponent	52-62
Vorzeichen (0 = Positiv, 1 = Negativ)	63

So wie Dezimalbrüche einige Bruchwerte (z. B. 1/3 oder Math.PI) nicht präzise darstellen können, können binäre Brüche einige Bruchwerte nicht darstellen. Beispielsweise wird 1/10, die genau durch .1 als Dezimalbruch dargestellt wird, durch .001100110011 als binärer Fraktion dargestellt, wobei das Muster "0011" bis unendlich wiederholt wird. In diesem Fall bietet der Gleitkommawert eine ungenaue Darstellung der Zahl, die er darstellt. Das Ausführen zusätzlicher mathematischer Vorgänge auf dem ursprünglichen Gleitkommawert führt häufig dazu, die fehlende Genauigkeit zu erhöhen. Wenn wir z. B. das Ergebnis der Multiplikation von .1 mit 10 vergleichen und neunmal .1 zu .1 hinzufügen, sehen wir, dass der Zusatz, da er acht weitere Vorgänge umfasst hat, das weniger präzise Ergebnis erzeugt hat. Beachten Sie, dass diese Diskrepanz nur sichtbar ist, wenn wir die beiden Double Werte mithilfe der numerischen Standardformatzeichenfolge "R" anzeigen, die bei Bedarf alle 17 Vom Typ unterstützten Double Genauigkeitsstellen anzeigt.

using System;

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

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

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 Example
   Public Sub Main()
      Dim value As Double = .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

Da einige Zahlen nicht genau als Bruchbinärwerte dargestellt werden können, können Gleitkommazahlen nur annähernd reelle Zahlen darstellen.

Alle Gleitkommazahlen haben auch eine begrenzte Anzahl signifikanter Ziffern, wodurch auch bestimmt wird, wie genau ein Gleitkommawert einer reellen Zahl annähert. Ein Double Wert weist eine Genauigkeit von bis zu 15 Dezimalstellen auf, obwohl maximal 17 Ziffern intern beibehalten werden. Dies bedeutet, dass bei einigen Gleitkommavorgängen möglicherweise die Genauigkeit fehlt, um einen Gleitkommawert zu ändern. Dies wird im folgenden Beispiel veranschaulicht. Es definiert einen sehr großen Gleitkommawert und fügt dann das Produkt und Double.Epsilon eine Billiarde hinzu. Das Produkt ist jedoch zu klein, um den ursprünglichen Gleitkommawert zu ändern. Die am wenigsten signifikante Ziffer ist Tausendstel, während die wichtigste Ziffer im Produkt ^10-309 ist.

using System;

public class Example
{
   public static void Main()
   {
      Double value = 123456789012.34567;
      Double additional = Double.Epsilon * 1e15;
      Console.WriteLine("{0} + {1} = {2}", 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 Example
   Public Sub Main()
      Dim value As Double = 123456789012.34567
      Dim additional As Double = Double.Epsilon * 1e15
      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

Die begrenzte Genauigkeit einer Gleitkommazahl hat mehrere Folgen:

• Zwei Gleitkommazahlen, die für eine bestimmte Genauigkeit identisch zu sein scheinen, können sich als unterschiedlich erweisen, wenn sich die zwei letzten Ziffern unterscheiden. Im folgenden Beispiel wird eine Reihe von Zahlen addiert, und ihre Summe wird mit der erwarteten Summe verglichen. Obwohl die beiden Werte identisch zu sein scheinen, gibt ein Aufruf der Equals -Methode an, dass sie nicht sind.

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

  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 Example
     Public Sub Main()
        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).
  

  Wenn Sie die Formatelemente in der Console.WriteLine(String, Object, Object) Anweisung von {0} und {1} in {0:R} ändern und {1:R} alle wichtigen Ziffern der beiden Double Werte anzeigen, ist klar, dass die beiden Werte aufgrund eines Genauigkeitsverlusts während der Additionsvorgänge ungleich sind. In diesem Fall kann das Problem behoben werden, indem die Math.Round(Double, Int32) -Methode aufgerufen wird, um die Double Werte vor dem Vergleich auf die gewünschte Genauigkeit zu runden.

• Ein mathematischer Oder Vergleichsvorgang, der eine Gleitkommazahl verwendet, liefert möglicherweise nicht das gleiche Ergebnis, wenn eine Dezimalzahl verwendet wird, da die binäre Gleitkommazahl möglicherweise nicht der Dezimalzahl entspricht. In einem vorherigen Beispiel wurde dies veranschaulicht, indem das Ergebnis der Multiplikation von .1 mit 10 und dem Hinzufügen von .1-Mal angezeigt wurde.

  Wenn die Genauigkeit in numerischen Vorgängen mit Bruchwerten wichtig ist, können Sie anstelle des Decimal Typs den Double verwenden. Wenn genauigkeit in numerischen Vorgängen mit integralen Werten außerhalb des Bereichs der Int64 Typen oder UInt64 wichtig ist, verwenden Sie den BigInteger Typ.

• Ein Wert ist möglicherweise nicht roundtrip, wenn eine Gleitkommazahl betroffen ist. Ein Wert wird als Roundtrip bezeichnet, wenn ein Vorgang eine ursprüngliche Gleitkommazahl in eine andere Form konvertiert, ein umgekehrter Vorgang das konvertierte Formular zurück in eine Gleitkommazahl transformiert und die letzte Gleitkommazahl nicht gleich der ursprünglichen Gleitkommazahl ist. Die Rundreise schlägt möglicherweise fehl, weil eine oder mehrere wichtige Ziffern verloren gehen oder bei einer Konvertierung geändert werden. Im folgenden Beispiel werden drei Double Werte in Zeichenfolgen konvertiert und in einer Datei gespeichert. Wie die Ausgabe zeigt, sind die wiederhergestellten Werte jedoch nicht gleich den ursprünglichen Werten, obwohl die Werte identisch zu sein scheinen.

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

  open System
  open System.IO
  
  let values = [ 2.2 / 1.01; 1. / 3.; Math.PI ]
  
  using (new StreamWriter(@".\Doubles.dat")) (fun sw ->
      for i = 0 to values.Length - 1 do
          sw.Write(string values[i])
          if i <> values.Length - 1 then
              sw.Write "|")
  
  using (new StreamReader(@".\Doubles.dat")) (fun sr ->
      let temp = sr.ReadToEnd()
      let tempStrings = temp.Split '|'
  
      let restoredValues =
          [ for i = 0 to tempStrings.Length - 1 do
                Double.Parse tempStrings[i] ]
  
      for i = 0 to values.Length - 1 do
          printfn $"""{values[i]} {if values[ i ].Equals restoredValues[i] then "=" else "<>"} {restoredValues[i]}""")
  
  // The example displays the following output:
  //       2.17821782178218 <> 2.17821782178218
  //       0.333333333333333 <> 0.333333333333333
  //       3.14159265358979 <> 3.14159265358979
  

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

  In diesem Fall können die Werte erfolgreich gerundet werden, indem die numerische Standardformatzeichenfolge "G17" verwendet wird, um die volle Genauigkeit der Double Werte beizubehalten, wie im folgenden Beispiel gezeigt.

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

  open System
  open System.IO
  
  let values = [ 2.2 / 1.01; 1. / 3.; Math.PI ]
  
  using (new StreamWriter(@".\Doubles.dat")) (fun sw -> 
      for i = 0 to values.Length - 1 do
          sw.Write $"""{values[i]:G17}{if i < values.Length - 1 then "|" else ""}""")
  
  using (new StreamReader(@".\Doubles.dat")) (fun sr ->
      let temp = sr.ReadToEnd()
      let tempStrings = temp.Split '|'
      
      let restoredValues = 
        [ for i = 0 to tempStrings.Length - 1 do
              Double.Parse tempStrings[i] ]
  
      for i = 0 to values.Length - 1 do
          printfn $"""{restoredValues[i]} {if values[i].Equals restoredValues[i] then "=" else "<>"} {values[i]}""")
  
  // The example displays the following output:
  //       2.17821782178218 = 2.17821782178218
  //       0.333333333333333 = 0.333333333333333
  //       3.14159265358979 = 3.14159265358979
  

  Imports System.IO
  
  Module Example
     Public Sub Main()
        Dim sw As New StreamWriter(".\Doubles.dat")
        Dim values() As Double = { 2.2/1.01, 1.0/3, Math.PI }
        For ctr As Integer = 0 To values.Length - 1
           sw.Write("{0:G17}{1}", values(ctr), 
                    If(ctr < values.Length - 1, "|", ""))
        Next      
        sw.Close()
        
        Dim restoredValues(values.Length - 1) As Double
        Dim sr As New StreamReader(".\Doubles.dat")
        Dim temp As String = sr.ReadToEnd()
        Dim tempStrings() As String = temp.Split("|"c)
        For ctr As Integer = 0 To tempStrings.Length - 1
           restoredValues(ctr) = Double.Parse(tempStrings(ctr))   
        Next 
  
        For ctr As Integer = 0 To values.Length - 1
           Console.WriteLine("{0} {2} {1}", values(ctr), 
                             restoredValues(ctr),
                             If(values(ctr).Equals(restoredValues(ctr)), "=", "<>"))
        Next
     End Sub
  End Module
  ' The example displays the following output:
  '       2.17821782178218 = 2.17821782178218
  '       0.333333333333333 = 0.333333333333333
  '       3.14159265358979 = 3.14159265358979
  

Wichtig

Bei Verwendung mit einem Double Wert kann der Formatbezeichner "R" in einigen Fällen den ursprünglichen Wert nicht erfolgreich roundtripen. Verwenden Sie den Formatbezeichner "G17", um sicherzustellen, dass Double die Werte erfolgreich roundtripen.

• Single Werte haben eine geringere Genauigkeit als Double Werte. Ein Single Wert, der in einen scheinbar gleichwertigen Double Wert konvertiert wird, entspricht oft aufgrund von Genauigkeitsunterschieden nicht dem Double Wert. Im folgenden Beispiel wird das Ergebnis identischer Divisionsvorgänge einem Double und einem Single Wert zugewiesen. Nachdem der Single Wert in ein Doubleumgewandelt wurde, zeigt ein Vergleich der beiden Werte, dass sie ungleich sind.

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

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

  Um dieses Problem zu vermeiden, verwenden Sie entweder anstelle Double des Datentyps Single oder die Round -Methode, damit beide Werte die gleiche Genauigkeit aufweisen.

Darüber hinaus kann das Ergebnis von Arithmetik- und Zuordnungsvorgängen mit Double Werten aufgrund des Genauigkeitsverlusts des Double Typs je nach Plattform geringfügig abweichen. Beispielsweise kann sich das Ergebnis der Zuweisung eines Literalwerts Double in den 32-Bit- und 64-Bit-Versionen des .NET Framework unterscheiden. Im folgenden Beispiel wird dieser Unterschied veranschaulicht, wenn der Literalwert -4.42330604244772E-305 und eine Variable mit -4,42330604244772E-305 einer Double Variablen zugewiesen werden. Beachten Sie, dass das Ergebnis der Parse(String) Methode in diesem Fall keinen Genauigkeitsverlust aufweist.

double value = -4.42330604244772E-305;

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

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

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.42330604244772E-305

Dim fromLiteral As Double = -4.42330604244772E-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)      
' 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

Testen auf Gleichheit

Um als gleich angesehen zu werden, müssen zwei Double Werte identische Werte darstellen. Aufgrund von Genauigkeitsunterschieden zwischen Werten oder aufgrund eines Genauigkeitsverlusts um einen oder beide Werte erweisen sich Gleitkommawerte, von denen erwartet wird, dass sie identisch sind, oft aufgrund von Unterschieden in ihren am wenigsten signifikanten Ziffern ungleich. Daher führen Aufrufe der Equals -Methode, um zu bestimmen, ob zwei Werte gleich sind, oder Aufrufe der CompareTo -Methode, um die Beziehung zwischen zwei Double Werten zu bestimmen, oft zu unerwarteten Ergebnissen. Dies wird im folgenden Beispiel deutlich, in dem sich zwei scheinbar gleiche Double Werte als ungleich erweisen, da der erste eine Genauigkeit von 15 Ziffern hat, während der zweite 17 hat.

using System;

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

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 Example
   Public Sub Main()
      Dim value1 As Double = .333333333333333
      Dim value2 As Double = 1/3
      Console.WriteLine("{0:R} = {1:R}: {2}", value1, value2, value1.Equals(value2))
   End Sub
End Module
' The example displays the following output:
'       0.333333333333333 = 0.33333333333333331: False

Berechnete Werte, die unterschiedlichen Codepfaden folgen und auf unterschiedliche Weise bearbeitet werden, erweisen sich häufig als ungleich. Im folgenden Beispiel ist ein Double Wert quadratisch, und dann wird die Quadratwurzel berechnet, um den ursprünglichen Wert wiederherzustellen. Eine Sekunde Double wird mit 3,51 multipliziert und im Quadrat angegeben, bevor die Quadratwurzel des Ergebnisses durch 3,51 geteilt wird, um den ursprünglichen Wert wiederherzustellen. Obwohl die beiden Werte identisch zu sein scheinen, gibt ein Aufruf der Equals(Double) -Methode an, dass sie nicht gleich sind. Wenn Sie die Standardformatzeichenfolge "R" verwenden, um eine Ergebniszeichenfolge zurückzugeben, die alle wichtigen Ziffern jedes Double-Werts anzeigt, zeigt, dass der zweite Wert .0000000000001 kleiner als der erste ist.

using System;

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

open System

let value1 = 
    Math.Pow(100.10142, 2)
    |> sqrt

let value2 = 
    let v = pown (value1 * 3.51) 2
    (Math.Sqrt v) / 3.51

printfn $"{value1} = {value2}: {value1.Equals value2}\n"
printfn $"{value1:R} = {value2:R}"
// The example displays the following output:
//    100.10142 = 100.10142: False
//
//    100.10142 = 100.10141999999999

Module Example
   Public Sub Main()
      Dim value1 As Double = 100.10142
      value1 = Math.Sqrt(Math.Pow(value1, 2))
      Dim value2 As Double = Math.Pow(value1 * 3.51, 2)
      value2 = Math.Sqrt(value2) / 3.51
      Console.WriteLine("{0} = {1}: {2}", 
                        value1, value2, value1.Equals(value2)) 
      Console.WriteLine()
      Console.WriteLine("{0:R} = {1:R}", value1, value2) 
   End Sub
End Module
' The example displays the following output:
'    100.10142 = 100.10142: False
'    
'    100.10142 = 100.10141999999999

In Fällen, in denen sich ein Genauigkeitsverlust wahrscheinlich auf das Ergebnis eines Vergleichs auswirkt, können Sie eine der folgenden Alternativen zum Aufrufen der -Methode oder CompareTo übernehmenEquals:

• Rufen Sie die Math.Round -Methode auf, um sicherzustellen, dass beide Werte die gleiche Genauigkeit aufweisen. Im folgenden Beispiel wird ein vorheriges Beispiel so geändert, dass dieser Ansatz verwendet wird, sodass zwei Bruchwerte gleichwertig sind.

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

  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 Example
     Public Sub Main()
        Dim value1 As Double = .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:R} = {1:R}: {2}", value1, value2, value1.Equals(value2))
     End Sub
  End Module
  ' The example displays the following output:
  '       0.3333333 = 0.3333333: True
  

  Das Problem der Genauigkeit gilt weiterhin für die Rundung von Mittelpunktwerten. Weitere Informationen finden Sie unter der Methode Math.Round(Double, Int32, MidpointRounding).

• Testen Sie die ungefähre Gleichheit anstelle der Gleichheit. Dies erfordert, dass Sie entweder einen absoluten Betrag definieren, um den sich die beiden Werte unterscheiden können, aber dennoch gleich sind, oder dass Sie einen relativen Betrag definieren, um den der kleinere Wert vom größeren Wert abweichen kann.

  Warnung

  Double.Epsilon wird manchmal als absolutes Maß für den Abstand zwischen zwei Double Werten verwendet, wenn auf Gleichheit getestet wird. Misst jedoch den kleinstmöglichen Wert, Double.Epsilon der einem hinzugefügt oder subtrahiert werden kann, Double dessen Wert 0 ist. Für die meisten positiven und negativen Double Werte ist der Wert von Double.Epsilon zu klein, um erkannt zu werden. Daher wird mit Ausnahme von Werten, die null sind, die Verwendung in Tests auf Gleichheit abgeraten.

  Im folgenden Beispiel wird der letztere Ansatz verwendet, um eine IsApproximatelyEqual Methode zu definieren, die den relativen Unterschied zwischen zwei Werten testet. Außerdem wird das Ergebnis von Aufrufen der IsApproximatelyEqual -Methode und der Equals(Double) -Methode kontrastiert.

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

  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 Example
     Public Sub Main()
        Dim one1 As Double = .1 * 10
        Dim one2 As Double = 0
        For ctr As Integer = 1 To 10
           one2 += .1
        Next
        Console.WriteLine("{0:R} = {1:R}: {2}", one1, one2, one1.Equals(one2))
        Console.WriteLine("{0:R} is approximately equal to {1:R}: {2}", 
                          one1, one2, 
                          IsApproximatelyEqual(one1, one2, .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)
        Else If Double.IsInfinity(value2) Or Double.IsNaN(value2)
           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
  

Floating-Point Werte und Ausnahmen

Im Gegensatz zu Vorgängen mit integralen Typen, die Ausnahmen bei Überlauf oder unzulässigen Vorgängen wie division by zero auslösen, werden bei Vorgängen mit Gleitkommawerten keine Ausnahmen ausgelöst. Stattdessen ist das Ergebnis einer Gleitkommaoperation in Ausnahmesituationen Null, positive Unendlichkeit, negative Unendlichkeit oder keine Zahl (NaN):

• Wenn das Ergebnis eines Gleitkommavorgangs für das Zielformat zu klein ist, ist das Ergebnis null. Dies kann auftreten, wenn zwei sehr kleine Zahlen multipliziert werden, wie im folgenden Beispiel gezeigt.

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

  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 Example
     Public Sub Main()
        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
  

• Wenn die Größe des Ergebnisses eines Gleitkommavorgangs den Bereich des Zielformats überschreitet, lautet PositiveInfinity das Ergebnis des Vorgangs oder NegativeInfinity, je nach Vorzeichen des Ergebnisses. Das Ergebnis eines Vorgangs Double.MaxValue , der überläuft, ist PositiveInfinity, und das Ergebnis eines Vorgangs Double.MinValue , der überläuft, wie NegativeInfinityim folgenden Beispiel gezeigt.

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

  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 Example
     Public Sub Main()
        Dim value1 As Double = 4.565e153
        Dim value2 As Double = 6.9375e172
        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 ergibt sich auch aus einer Division um 0 (null) mit einer positiven Dividende und NegativeInfinity aus einer Division mit einer negativen Dividende.

• Wenn ein Gleitkommavorgang ungültig ist, ist NaNdas Ergebnis des Vorgangs . Beispiel: NaN Ergebnisse aus den folgenden Vorgängen:

  • Division durch 0 (null) mit einer Dividende von 0 (null). Beachten Sie, dass andere Fälle der Division durch null entweder PositiveInfinity oder führen NegativeInfinity.

• Jeder Gleitkommavorgang mit einer ungültigen Eingabe. Wenn Sie z. B. die Math.Sqrt -Methode mit einem negativen Wert aufrufen, wird zurückgegeben NaN, ebenso wie das Aufrufen der Math.Acos -Methode mit einem Wert, der größer als ein oder kleiner als ein negativer Wert ist.

• Jeder Vorgang mit einem Argument, dessen Wert ist Double.NaN.

Typkonvertierungen und die Double-Struktur

Die Double -Struktur definiert keine expliziten oder impliziten Konvertierungsoperatoren. Stattdessen werden Konvertierungen vom Compiler implementiert.

Die Konvertierung des Werts eines primitiven numerischen Typs in eine Double ist eine Erweiterungskonvertierung und erfordert daher keinen expliziten Umwandlungsoperator oder Aufruf einer Konvertierungsmethode, es sei denn, ein Compiler erfordert dies explizit. Beispielsweise erfordert der C#-Compiler einen Umwandlungsoperator für Konvertierungen von Decimal in Double, während der Visual Basic-Compiler dies nicht tut. Im folgenden Beispiel wird der minimale oder maximale Wert anderer primitiver numerischer Typen in eine Doublekonvertiert.

using System;

public class Example
{
   public static void Main()
   {
      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 (var value in values) {
         if (value.GetType() == typeof(Decimal))
            dblValue = (Double) value;
         else
            dblValue = value;
         Console.WriteLine("{0} ({1}) --> {2:R} ({3})",
                           value, value.GetType().Name,
                           dblValue, 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 Example
   Public Sub Main()
      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)

Darüber hinaus werden die Single Werte Single.NaN, Single.PositiveInfinityund Single.NegativeInfinity in Double.NaN, Double.PositiveInfinityund Double.NegativeInfinitybzw. konvertiert.

Beachten Sie, dass die Konvertierung des Werts einiger numerischer Typen in einen Double Wert einen Genauigkeitsverlust mit sich bringen kann. Wie das Beispiel veranschaulicht, ist ein Genauigkeitsverlust möglich, wenn Werte, Int64, und UInt64 in Double Werte konvertiert Decimalwerden.

Die Konvertierung eines Double Werts in einen Wert eines anderen primitiven numerischen Datentyps ist eine einschränkende Konvertierung und erfordert einen Umwandlungsoperator (in C#), eine Konvertierungsmethode (in Visual Basic) oder einen Aufruf einer Convert Methode. Werte außerhalb des Bereichs des Zieldatentyps, die durch die Eigenschaften und MaxValue des Zieltyps MinValue definiert werden, verhalten sich wie in der folgenden Tabelle dargestellt.

Zieltyp	Ergebnis
Beliebiger integraler Typ	Eine OverflowException Ausnahme, wenn die Konvertierung in einem überprüften Kontext erfolgt. Wenn die Konvertierung in einem nicht überprüften Kontext erfolgt (der Standard in C#), ist der Konvertierungsvorgang erfolgreich, aber der Wert überläuft.
Decimal	Eine OverflowException-Ausnahme.
Single	Single.NegativeInfinity für negative Werte. Single.PositiveInfinity für positive Werte.

Darüber hinaus Double.NaNlösen , Double.PositiveInfinityund Double.NegativeInfinity eine OverflowException für Konvertierungen in Ganze Zahlen in einem überprüften Kontext aus, aber diese Werte überlaufen, wenn sie in ganze Zahlen in einem nicht aktivierten Kontext konvertiert werden. Bei Konvertierungen in Decimallösen sie immer eine aus OverflowException. Konvertierung in Single, sie konvertieren in Single.NaN, Single.PositiveInfinity, und Single.NegativeInfinitybzw.

Beachten Sie, dass die Konvertierung eines Werts in einen anderen numerischen Typ zu einem Double Genauigkeitsverlust führen kann. Bei der Konvertierung in einen der integralen Typen, wie die Ausgabe aus dem Beispiel zeigt, geht die Bruchkomponente verloren, wenn der Double Wert entweder gerundet (wie in Visual Basic) oder abgeschnitten wird (wie in C#). Bei Konvertierungen in Decimal - und Single -Werte hat der Double Wert möglicherweise keine genaue Darstellung im Zieldatentyp.

Im folgenden Beispiel werden eine Reihe von Double Werten in mehrere andere numerische Typen konvertiert. Die Konvertierungen erfolgen in einem überprüften Kontext in Visual Basic (Standard), in C# (aufgrund der aktivierten Schlüsselwort (keyword)) und in F# (aufgrund des Moduls Checked). Die Ausgabe des Beispiels zeigt das Ergebnis für Konvertierungen in einem überprüften und nicht überprüften Kontext. Sie können Konvertierungen in einem nicht aktivierten Kontext in Visual Basic durchführen, indem Sie mit dem /removeintchecks+ Compilerschalter kompilieren, in C# die checked Anweisung auskommentieren und in F# die Anweisung auskommentieren open Checked .

using System;

public class Example
{
   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("{0} ({1}) --> {2} (0x{2:X16}) ({3})",
                                  value, value.GetType().Name,
                                  lValue, lValue.GetType().Name);
            }
            catch (OverflowException) {
               Console.WriteLine("Unable to convert {0} to Int64.", value);
            }
            try {
                UInt64 ulValue = (ulong) value;
                Console.WriteLine("{0} ({1}) --> {2} (0x{2:X16}) ({3})",
                                  value, value.GetType().Name,
                                  ulValue, ulValue.GetType().Name);
            }
            catch (OverflowException) {
               Console.WriteLine("Unable to convert {0} to UInt64.", value);
            }
            try {
                Decimal dValue = (decimal) value;
                Console.WriteLine("{0} ({1}) --> {2} ({3})",
                                  value, value.GetType().Name,
                                  dValue, dValue.GetType().Name);
            }
            catch (OverflowException) {
               Console.WriteLine("Unable to convert {0} to Decimal.", value);
            }
            try {
                Single sValue = (float) value;
                Console.WriteLine("{0} ({1}) --> {2} ({3})",
                                  value, value.GetType().Name,
                                  sValue, sValue.GetType().Name);
            }
            catch (OverflowException) {
               Console.WriteLine("Unable to convert {0} to Single.", value);
            }
            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 Example
   Public Sub Main()
      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)

Weitere Informationen zur Konvertierung numerischer Typen finden Sie unter Typkonvertierung in den .NET Framework und Typkonvertierungstabellen.

Floating-Point Funktionalität

Die Double Struktur und die zugehörigen Typen stellen Methoden zum Ausführen von Vorgängen in den folgenden Bereichen bereit:

• Vergleich von Werten. Sie können die Equals -Methode aufrufen, um zu bestimmen, ob zwei Double Werte gleich sind, oder die CompareTo -Methode, um die Beziehung zwischen zwei Werten zu bestimmen.

  Die Double -Struktur unterstützt auch einen vollständigen Satz von Vergleichsoperatoren. Sie können beispielsweise auf Gleichheit oder Ungleichheit testen oder bestimmen, ob ein Wert größer oder gleich einem anderen wert ist. Wenn einer der Operanden ein anderer numerischer Typ als ein Doubleist, wird er vor dem Durchführen des Vergleichs in einen Double konvertiert.

  Warnung

  Aufgrund von Genauigkeitsunterschieden können sich zwei Double Werte, von denen Sie erwarten, gleich sein, als ungleich erweisen, was sich auf das Ergebnis des Vergleichs auswirkt. Weitere Informationen zum Vergleichen von zwei Double Werten finden Sie im Abschnitt Testen auf Gleichheit.

  Sie können auch die IsNaNMethoden , IsInfinity, IsPositiveInfinityund IsNegativeInfinity aufrufen, um auf diese speziellen Werte zu testen.

• Mathematische Operationen. Gängige arithmetische Operationen wie Addition, Subtraktion, Multiplikation und Division werden nicht durch Double Methoden, sondern durch Sprachcompiler und CIL-Anweisungen (Common Intermediate Language) implementiert. Wenn einer der Operanden in einer mathematischen Operation ein anderer numerischer Typ als ein Doubleist, wird er vor dem Ausführen des Vorgangs in einen Double konvertiert. Das Ergebnis des Vorgangs ist ebenfalls ein Double Wert.

  Andere mathematische Operationen können durch Aufrufen static von Methoden (Shared in Visual Basic) in der System.Math -Klasse ausgeführt werden. Sie enthält zusätzliche Methoden, die häufig für Arithmetik (z Math.Abs. B. , Math.Signund Math.Sqrt), geometrie (z Math.Cos . B. und Math.Sin) und Für die Berechnung (z Math.Log. B. ) verwendet werden.

  Sie können auch die einzelnen Bits in einem Double Wert bearbeiten. Die BitConverter.DoubleToInt64Bits -Methode behält das Bitmuster eines Double Werts in einer 64-Bit-Ganzzahl bei. Die BitConverter.GetBytes(Double) -Methode gibt ihr Bitmuster in einem Bytearray zurück.

• Rundung. Runden wird häufig als Technik verwendet, um die Auswirkungen von Unterschieden zwischen Werten zu verringern, die durch Probleme mit gleitkommabasierter Darstellung und Genauigkeit verursacht werden. Sie können einen Double Wert runden, indem Sie die Math.Round -Methode aufrufen.

• Formatierung. Sie können einen Double Wert in seine Zeichenfolgendarstellung konvertieren, indem Sie die ToString -Methode aufrufen oder das Feature zur zusammengesetzten Formatierung verwenden. Informationen dazu, wie Formatzeichenfolgen die Zeichenfolgendarstellung von Gleitkommawerten steuern, finden Sie in den Themen Numerische Standardformatzeichenfolgen und Benutzerdefinierte numerische Formatzeichenfolgen .

• Analysieren von Zeichenfolgen. Sie können die Zeichenfolgendarstellung eines Gleitkommawerts in einen Double Wert konvertieren, indem Sie entweder die - oder TryParse -ParseMethode aufrufen. Wenn der Analysevorgang fehlschlägt, löst die Parse -Methode eine Ausnahme aus, während die TryParse -Methode zurückgibt false.

• Typkonvertierung. Die Double -Struktur stellt eine explizite Schnittstellenimplementierung für die IConvertible -Schnittstelle bereit, die die Konvertierung zwischen zwei beliebigen Standarddatentypen .NET Framework unterstützt. Sprachcompiler unterstützen auch die implizite Konvertierung von Werten aller anderen numerischen Standardtypen in Double Werte. Die Konvertierung eines Werts eines beliebigen numerischen Standardtyps in eine Double ist eine Erweiterungskonvertierung und erfordert keinen Benutzer eines Umwandlungsoperators oder einer Konvertierungsmethode.

  Die Konvertierung von Int64 - und Single -Werten kann jedoch zu einem Genauigkeitsverlust führen. In der folgenden Tabelle sind die Genauigkeitsunterschiede für jeden dieser Typen aufgeführt:

  Typ	Maximale Genauigkeit	Interne Genauigkeit
  Double	15	17
  Int64	19 Dezimalstellen	19 Dezimalstellen
  Single	7 Dezimalstellen	9 Dezimalstellen

  Das Problem der Genauigkeit wirkt sich am häufigsten auf Werte aus Single , die in Double Werte konvertiert werden. Im folgenden Beispiel sind zwei Werte, die von identischen Divisionsvorgängen erzeugt werden, ungleich, da einer der Werte ein Gleitkommawert mit einfacher Genauigkeit ist, der in einen Doublekonvertiert wird.

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

  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 Example
     Public Sub Main()
        Dim value As Double = .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
  

Felder

E	Stellt die natürliche logarithmische Basis dar, die durch die Konstante e angegeben wird.
Epsilon	Stellt den kleinsten positiven Double-Wert dar, der größer als 0 (null) ist. Dieses Feld ist konstant.
MaxValue	Stellt den größtmöglichen Wert von Double dar. Dieses Feld ist konstant.
MinValue	Stellt den kleinstmöglichen Wert von Double dar. Dieses Feld ist konstant.
NaN	Stellt einen Wert dar, der keine Zahl ist (NaN). Dieses Feld ist konstant.
NegativeInfinity	Stellt minus unendlich dar. Dieses Feld ist konstant.
NegativeZero	Stellt die zahl negative Null (-0) dar.
Pi	Stellt das Verhältnis eines Kreisumfangs zum Kreisdurchmesser durch die Konstante π dar.
PositiveInfinity	Stellt plus unendlich dar. Dieses Feld ist konstant.
Tau	Stellt die Anzahl der Bogenmaßwerte in einer Umdrehung dar, angegeben durch die Konstante τ.

Methoden

Abs(Double)	Berechnet das Absolute eines Werts.
Acos(Double)	Berechnet den Arc-Kosinus eines Werts.
Acosh(Double)	Berechnet den hyperbolischen Arc-Kosinus eines Werts.
AcosPi(Double)	Berechnet den Arc-Kosinus eines Werts und dividiert das Ergebnis durch pi.
Asin(Double)	Berechnet den Arc-Sinus eines Werts.
Asinh(Double)	Berechnet den hyperbolischen Arc-Sinus eines Werts.
AsinPi(Double)	Berechnet den Arc-Sinus eines Werts und dividiert das Ergebnis durch pi.
Atan(Double)	Berechnet den Arc-Tangens eines Werts.
Atan2(Double, Double)	Berechnet den Arc-Tangens des Quotienten von zwei Werten.
Atan2Pi(Double, Double)	Berechnet den Arc-Tangens für den Quotienten zweier Werte und dividiert das Ergebnis durch pi.
Atanh(Double)	Berechnet den hyperbolischen Arc-Tangens eines Werts.
AtanPi(Double)	Berechnet den Arc-Tangens eines Werts und dividiert das Ergebnis durch pi.
BitDecrement(Double)	Dekrementiert einen Wert auf den kleinsten Wert, der kleiner als ein gegebener Wert ist.
BitIncrement(Double)	Erhöht einen Wert auf den kleinsten Wert, der größer als ein gegebener Wert ist.
Cbrt(Double)	Berechnet den Cubestamm eines Werts.
Ceiling(Double)	Berechnet die Obergrenze eines Werts.
Clamp(Double, Double, Double)	Klemmt einen Wert auf einen inklusiven Minimal- und Höchstwert.
CompareTo(Double)	Vergleicht diese Instanz mit einer angegebenen Gleitkommazahl mit doppelter Genauigkeit und gibt eine Ganzzahl zurück, die angibt, ob der Wert dieser Instanz kleiner oder größer als der Wert der angegebenen Gleitkommazahl mit doppelter Genauigkeit ist oder mit dieser übereinstimmt.
CompareTo(Object)	Vergleicht diese Instanz mit einem angegebenen Objekt und gibt eine ganze Zahl zurück, die angibt, ob der Wert dieser Instanz kleiner oder größer als der Wert des angegebenen Objekts ist oder mit diesem übereinstimmt.
CopySign(Double, Double)	Kopiert das Vorzeichen eines Werts in das Vorzeichen eines anderen Werts.
Cos(Double)	Berechnet den Kosinus eines Werts.
Cosh(Double)	Berechnet den hyperbolischen Kosinus eines Werts.
CosPi(Double)	Berechnet den Kosinus eines Werts, der mit pimultimultiziert wurde.
CreateChecked<TOther>(TOther)	Erstellt eine instance des aktuellen Typs aus einem Wert und löst eine Überlaufausnahme für alle Werte aus, die außerhalb des darstellbaren Bereichs des aktuellen Typs liegen.
CreateSaturating<TOther>(TOther)	Erstellt eine instance des aktuellen Typs aus einem -Wert und sättigt alle Werte, die außerhalb des darstellbaren Bereichs des aktuellen Typs liegen.
CreateTruncating<TOther>(TOther)	Erstellt eine instance des aktuellen Typs aus einem Wert und schneidet alle Werte ab, die außerhalb des darstellbaren Bereichs des aktuellen Typs liegen.
Equals(Double)	Gibt einen Wert zurück, der angibt, ob diese Instanz und ein angegebenes Double-Objekt den gleichen Wert darstellen.
Equals(Object)	Gibt einen Wert zurück, der angibt, ob diese Instanz gleich einem angegebenen Objekt ist.
Exp(Double)	Computevorgänge werden E auf eine bestimmte Leistung angehoben.
Exp10(Double)	Computevorgänge werden 10 auf eine bestimmte Leistung angehoben.
Exp10M1(Double)	10 Berechnet auf eine bestimmte Leistung und subtrahiert eine.
Exp2(Double)	Computevorgänge werden 2 auf eine bestimmte Leistung angehoben.
Exp2M1(Double)	2 Berechnet auf eine bestimmte Leistung und subtrahiert eine.
ExpM1(Double)	E Berechnet auf eine bestimmte Leistung und subtrahiert eine.
Floor(Double)	Berechnet den Boden eines Werts.
FusedMultiplyAdd(Double, Double, Double)	Berechnet die verschmolzene Multiplikation von drei Werten.
GetHashCode()	Gibt den Hashcode für diese Instanz zurück.
GetTypeCode()	Gibt den TypeCode für den Werttyp Double zurück.
Hypot(Double, Double)	Berechnet die Hypotenuse mit zwei Werten, die die Längen der kürzeren Seiten in einem rechtwinkligen Dreieck darstellen.
Ieee754Remainder(Double, Double)	Berechnet den Rest von zwei Werten, wie in IEEE 754 angegeben.
ILogB(Double)	Berechnet den ganzzahligen Logarithmus eines Werts.
IsEvenInteger(Double)	Bestimmt, ob ein Wert eine gerade ganzzahlige Zahl darstellt.
IsFinite(Double)	Diese Methode bestimmt, ob der Wert endlich ist (Null, subnormal oder normal).
IsInfinity(Double)	Gibt einen Wert zurück, der angibt, ob der Wert der angegebenen Zahl -unendlich oder +unendlich ist.
IsInteger(Double)	Bestimmt, ob ein Wert einen integralen Wert darstellt.
IsNaN(Double)	Gibt einen Wert zurück, der angibt, ob der angegebene Wert keine Zahl ist (NaN).
IsNegative(Double)	Bestimmt, ob der angegebene Wert negativ ist.
IsNegativeInfinity(Double)	Gibt einen Wert zurück, der angibt, ob die angegebene Zahl minus unendlich ergibt.
IsNormal(Double)	Bestimmt, ob der angegebene Wert normal ist.
IsOddInteger(Double)	Bestimmt, ob ein Wert eine ungerade ganzzahlige Zahl darstellt.
IsPositive(Double)	Bestimmt, ob ein Wert positiv ist.
IsPositiveInfinity(Double)	Gibt einen Wert zurück, der angibt, ob die angegebene Zahl plus unendlich ergibt.
IsPow2(Double)	Bestimmt, ob ein Wert eine Potenz von zwei ist.
IsRealNumber(Double)	Bestimmt, ob ein Wert eine reelle Zahl darstellt.
IsSubnormal(Double)	Bestimmt, ob der angegebene Wert subnormal ist.
Log(Double)	Berechnet den natürlichen (base-E Logarithmus eines Werts.
Log(Double, Double)	Berechnet den Logarithmus eines Werts in der angegebenen Basis.
Log10(Double)	Berechnet den Basis-10-Logarithmus eines Werts.
Log10P1(Double)	Berechnet den Basis-10-Logarithmus eines Werts plus 1.
Log2(Double)	Berechnet das Protokoll2 eines Werts.
Log2P1(Double)	Berechnet den Basis-2-Logarithmus eines Werts plus eins.
LogP1(Double)	Berechnet den natürlichen Logarithmus (base-E) eines Werts plus eins.
Max(Double, Double)	Vergleicht zwei Werte mit einem höheren Computewert.
MaxMagnitude(Double, Double)	Vergleicht zwei Werte mit einem höheren Computewert.
MaxMagnitudeNumber(Double, Double)	Vergleicht zwei Werte mit der Berechnung, die die größere Größe hat, und gibt den anderen Wert zurück, wenn eine Eingabe ist NaN.
MaxNumber(Double, Double)	Vergleicht zwei Werte mit der Berechnung, die größer ist, und gibt den anderen Wert zurück, wenn eine Eingabe ist NaN.
Min(Double, Double)	Vergleicht zwei Werte mit der Berechnung, die kleiner ist.
MinMagnitude(Double, Double)	Vergleicht zwei Werte mit der Berechnung, die kleiner ist.
MinMagnitudeNumber(Double, Double)	Vergleicht zwei Werte mit einer Berechnung, die die geringere Größe aufweist, und gibt den anderen Wert zurück, wenn eine Eingabe ist NaN.
MinNumber(Double, Double)	Vergleicht zwei Werte mit der Berechnung, die kleiner ist, und gibt den anderen Wert zurück, wenn eine Eingabe ist NaN.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Analysiert eine Spanne von Zeichen in einen Wert.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Konvertiert eine Zeichenspanne mit der Zeichenfolgendarstellung einer Zahl in einem angegebenen Stil und einem kulturspezifischen Format in die entsprechende Gleitkommazahl mit doppelter Genauigkeit.
Parse(String)	Konvertiert die Zeichenfolgendarstellung einer Zahl in die entsprechende Gleitkommazahl mit doppelter Genauigkeit.
Parse(String, IFormatProvider)	Konvertiert die Zeichenfolgendarstellung einer Zahl in einem bestimmten kulturspezifischen Format in die entsprechende Gleitkommazahl mit doppelter Genauigkeit.
Parse(String, NumberStyles)	Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen Format in die entsprechende Gleitkommazahl mit doppelter Genauigkeit.
Parse(String, NumberStyles, IFormatProvider)	Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen Stil und einem kulturspezifischen Format in die entsprechende Gleitkommazahl mit doppelter Genauigkeit.
Pow(Double, Double)	Berechnet einen Wert, der auf eine bestimmte Leistung angehoben wird.
ReciprocalEstimate(Double)	Berechnet eine Schätzung des Kehrwerts.
ReciprocalSqrtEstimate(Double)	Berechnet eine Schätzung der reziproken Quadratwurzel eines Werts.
RootN(Double, Int32)	Berechnet den n-ten Stamm eines Werts.
Round(Double)	Rundet einen Wert mithilfe des Standardrundungsmodus (ToEven) auf die nächste ganze Zahl.
Round(Double, Int32)	Rundet einen Wert mit dem Standardrundungsmodus (ToEven) auf eine angegebene Anzahl von Bruchstellen.
Round(Double, Int32, MidpointRounding)	Rundet einen Wert mit dem Standardrundungsmodus (ToEven) auf eine angegebene Anzahl von Bruchstellen.
Round(Double, MidpointRounding)	Rundet einen Wert mithilfe des angegebenen Rundungsmodus auf die nächste ganze Zahl.
ScaleB(Double, Int32)	Berechnet das Produkt eines Werts und dessen Basisradix, der auf die angegebene Leistung angehoben wird.
Sign(Double)	Berechnet das Vorzeichen eines Werts.
Sin(Double)	Berechnet den Sinus eines Werts.
SinCos(Double)	Berechnet den Sinus und den Sinus eines Werts.
SinCosPi(Double)	Berechnet den Sinus und den Sinus eines Werts.
Sinh(Double)	Berechnet den hyperbolischen Sinus eines Werts.
SinPi(Double)	Berechnet den Sinus eines Werts, der mit pimultipliziert wurde.
Sqrt(Double)	Berechnet die Quadratwurzel eines Werts.
Tan(Double)	Berechnet den Tangens eines Werts.
Tanh(Double)	Berechnet den hyperbolischen Tangens eines Werts.
TanPi(Double)	Berechnet den Tangens eines Werts, der mit pimultimultiziert wurde.
ToString()	Konvertiert den Wert dieser Instanz in die entsprechende Zeichenfolgendarstellung.
ToString(IFormatProvider)	Konvertiert den numerischen Wert dieser Instanz unter Berücksichtigung der angegebenen kulturabhängigen Formatierungsinformationen in die entsprechende Zeichenfolgendarstellung.
ToString(String)	Konvertiert den numerischen Wert dieser Instanz in die entsprechende Zeichenfolgendarstellung unter Berücksichtigung des angegebenen Formats.
ToString(String, IFormatProvider)	Konvertiert den numerischen Wert dieser Instanz unter Verwendung des angegebenen Formats und der angegebenen kulturabhängigen Formatierungsinformationen in die entsprechende Zeichenfolgendarstellung.
Truncate(Double)	Schneidet einen Wert ab.
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Versucht, den Wert der aktuellen Doppelinstanz in die angegebene Zeichenspanne zu formatieren.
TryParse(ReadOnlySpan<Char>, Double)	Konvertiert die Spannendarstellung einer Zahl in einem angegebenen Stil und einem kulturspezifischen Format in die entsprechende Gleitkommazahl mit doppelter Genauigkeit. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich war oder nicht.
TryParse(ReadOnlySpan<Char>, IFormatProvider, Double)	Versucht, eine Spanne von Zeichen in einen Wert zu analysieren.
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Double)	Konvertiert eine Zeichenspanne mit der Zeichenfolgendarstellung einer Zahl in einem angegebenen Stil und einem kulturspezifischen Format in die entsprechende Gleitkommazahl mit doppelter Genauigkeit. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich war oder nicht.
TryParse(String, Double)	Konvertiert die Zeichenfolgendarstellung einer Zahl in die entsprechende Gleitkommazahl mit doppelter Genauigkeit. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich war oder nicht.
TryParse(String, IFormatProvider, Double)	Versucht, eine Zeichenfolge in einen Wert zu analysieren.
TryParse(String, NumberStyles, IFormatProvider, Double)	Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen Stil und einem kulturspezifischen Format in die entsprechende Gleitkommazahl mit doppelter Genauigkeit. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich war oder nicht.

Operatoren

Equality(Double, Double)	Gibt einen Wert zurück, der angibt, ob zwei angegebene Double-Werte gleich sind.
GreaterThan(Double, Double)	Gibt einen Wert zurück, der angibt, ob ein angegebener Double-Wert größer als ein anderer angegebener Double-Wert ist.
GreaterThanOrEqual(Double, Double)	Gibt einen Wert zurück, der angibt, ob ein angegebener Double-Wert größer oder gleich einem anderen angegebenen Double-Wert ist.
Inequality(Double, Double)	Gibt einen Wert zurück, der angibt, ob zwei angegebene Double-Werte gleich sind.
LessThan(Double, Double)	Gibt einen Wert zurück, der angibt, ob ein angegebener Double-Wert größer als ein anderer angegebener Double-Wert ist.
LessThanOrEqual(Double, Double)	Gibt einen Wert zurück, der angibt, ob ein angegebener Double -Wert kleiner oder gleich einem anderen angegebenen Double-Wert ist.

Explizite Schnittstellenimplementierungen

IAdditionOperators<Double,Double,Double>.Addition(Double, Double)	Fügt zwei Werte zusammen, um ihre Summe zu berechnen.
IAdditiveIdentity<Double,Double>.AdditiveIdentity	Ruft die additive Identität des aktuellen Typs ab.
IBinaryNumber<Double>.AllBitsSet	Ruft eine instance des Binärtyps ab, in dem alle Bits festgelegt sind.
IBitwiseOperators<Double,Double,Double>.BitwiseAnd(Double, Double)	Berechnet den bitweisen und von zwei Werten.
IBitwiseOperators<Double,Double,Double>.BitwiseOr(Double, Double)	Berechnet den bitweisen oder von zwei Werten.
IBitwiseOperators<Double,Double,Double>.ExclusiveOr(Double, Double)	Berechnet den exklusiven oder von zwei Werten.
IBitwiseOperators<Double,Double,Double>.OnesComplement(Double)	Berechnet die Eins-Komplement-Darstellung eines bestimmten Werts.
IConvertible.ToBoolean(IFormatProvider)	Eine Beschreibung dieses Elements finden Sie unter ToBoolean(IFormatProvider).
IConvertible.ToByte(IFormatProvider)	Eine Beschreibung dieses Elements finden Sie unter ToByte(IFormatProvider).
IConvertible.ToChar(IFormatProvider)	Diese Konvertierung wird nicht unterstützt. Bei dem Versuch der Verwendung dieser Methode wird eine InvalidCastException ausgelöst.
IConvertible.ToDateTime(IFormatProvider)	Diese Konvertierung wird nicht unterstützt. Bei dem Versuch der Verwendung dieser Methode wird eine InvalidCastException ausgelöst.
IConvertible.ToDecimal(IFormatProvider)	Eine Beschreibung dieses Elements finden Sie unter ToDecimal(IFormatProvider).
IConvertible.ToDouble(IFormatProvider)	Eine Beschreibung dieses Elements finden Sie unter ToDouble(IFormatProvider).
IConvertible.ToInt16(IFormatProvider)	Eine Beschreibung dieses Elements finden Sie unter ToInt16(IFormatProvider).
IConvertible.ToInt32(IFormatProvider)	Eine Beschreibung dieses Elements finden Sie unter ToInt32(IFormatProvider).
IConvertible.ToInt64(IFormatProvider)	Eine Beschreibung dieses Elements finden Sie unter ToInt64(IFormatProvider).
IConvertible.ToSByte(IFormatProvider)	Eine Beschreibung dieses Elements finden Sie unter ToSByte(IFormatProvider).
IConvertible.ToSingle(IFormatProvider)	Eine Beschreibung dieses Elements finden Sie unter ToSingle(IFormatProvider).
IConvertible.ToType(Type, IFormatProvider)	Eine Beschreibung dieses Elements finden Sie unter ToType(Type, IFormatProvider).
IConvertible.ToUInt16(IFormatProvider)	Eine Beschreibung dieses Elements finden Sie unter ToUInt16(IFormatProvider).
IConvertible.ToUInt32(IFormatProvider)	Eine Beschreibung dieses Elements finden Sie unter ToUInt32(IFormatProvider).
IConvertible.ToUInt64(IFormatProvider)	Eine Beschreibung dieses Elements finden Sie unter ToUInt64(IFormatProvider).
IDecrementOperators<Double>.Decrement(Double)	Dekrementiert einen Wert.
IDivisionOperators<Double,Double,Double>.Division(Double, Double)	Dividiert einen Wert durch einen anderen, um den Quotienten zu berechnen.
IFloatingPoint<Double>.GetExponentByteCount()	Ruft die Anzahl der Bytes ab, die als Teil von TryWriteExponentLittleEndian(Span<Byte>, Int32)geschrieben werden.
IFloatingPoint<Double>.GetExponentShortestBitLength()	Ruft die Länge der Komplementdarstellung des aktuellen Exponenten in Bits ab.
IFloatingPoint<Double>.GetSignificandBitLength()	Ruft die Länge des aktuellen Significand in Bits ab.
IFloatingPoint<Double>.GetSignificandByteCount()	Ruft die Anzahl der Bytes ab, die als Teil von TryWriteSignificandLittleEndian(Span<Byte>, Int32)geschrieben werden.
IFloatingPoint<Double>.TryWriteExponentBigEndian(Span<Byte>, Int32)	Versucht, den aktuellen Exponenten im Big-End-Format auf eine bestimmte Spanne zu schreiben.
IFloatingPoint<Double>.TryWriteExponentLittleEndian(Span<Byte>, Int32)	Versucht, den aktuellen Exponenten im Little-Endian-Format in eine bestimmte Spanne zu schreiben.
IFloatingPoint<Double>.TryWriteSignificandBigEndian(Span<Byte>, Int32)	Versucht, das aktuelle Significund im Big-End-Format in eine bestimmte Spanne zu schreiben.
IFloatingPoint<Double>.TryWriteSignificandLittleEndian(Span<Byte>, Int32)	Versucht, das aktuelle Significund im Little-Endian-Format auf eine bestimmte Spanne zu schreiben.
IFloatingPointConstants<Double>.E	Ruft die mathematische Konstante eab.
IFloatingPointConstants<Double>.Pi	Ruft die mathematische Konstante piab.
IFloatingPointConstants<Double>.Tau	Ruft die mathematische Konstante tauab.
IFloatingPointIeee754<Double>.Epsilon	Ruft den kleinsten Wert ab, der hinzugefügt werden kann, was nicht zu 0 führt 0.
IFloatingPointIeee754<Double>.NaN	Ruft einen Wert ab, der darstellt NaN.
IFloatingPointIeee754<Double>.NegativeInfinity	Ruft einen Wert ab, der ein negatives infinitydarstellt.
IFloatingPointIeee754<Double>.NegativeZero	Ruft einen Wert ab, der ein negatives zerodarstellt.
IFloatingPointIeee754<Double>.PositiveInfinity	Ruft einen Wert ab, der positive infinitydarstellt.
IIncrementOperators<Double>.Increment(Double)	Erhöht einen Wert.
IMinMaxValue<Double>.MaxValue	Ruft den Maximalwert des aktuellen Typs ab.
IMinMaxValue<Double>.MinValue	Ruft den Mindestwert des aktuellen Typs ab.
IModulusOperators<Double,Double,Double>.Modulus(Double, Double)	Teilt zwei Werte zusammen, um deren Modul oder Rest zu berechnen.
IMultiplicativeIdentity<Double,Double>.MultiplicativeIdentity	Ruft die multiplikative Identität des aktuellen Typs ab.
IMultiplyOperators<Double,Double,Double>.Multiply(Double, Double)	Multipliziert zwei Werte zusammen, um ihr Produkt zu berechnen.
INumberBase<Double>.IsCanonical(Double)	Bestimmt, ob sich ein Wert in seiner kanonischen Darstellung befindet.
INumberBase<Double>.IsComplexNumber(Double)	Bestimmt, ob ein Wert eine komplexe Zahl darstellt.
INumberBase<Double>.IsImaginaryNumber(Double)	Bestimmt, ob ein Wert eine reine imaginäre Zahl darstellt.
INumberBase<Double>.IsZero(Double)	Bestimmt, ob ein Wert 0 ist.
INumberBase<Double>.One	Ruft den Wert 1 für den Typ ab.
INumberBase<Double>.Radix	Ruft die Basis für den Typ ab.
INumberBase<Double>.TryConvertFromChecked<TOther>(TOther, Double)	Stellt eine Gleitkommazahl mit doppelter Genauigkeit dar.
INumberBase<Double>.TryConvertFromSaturating<TOther>(TOther, Double)	Stellt eine Gleitkommazahl mit doppelter Genauigkeit dar.
INumberBase<Double>.TryConvertFromTruncating<TOther>(TOther, Double)	Stellt eine Gleitkommazahl mit doppelter Genauigkeit dar.
INumberBase<Double>.TryConvertToChecked<TOther>(Double, TOther)	Versucht, eine instance des aktuellen Typs in einen anderen Typ zu konvertieren, und löst eine Überlaufausnahme für alle Werte aus, die außerhalb des darstellbaren Bereichs des aktuellen Typs liegen.
INumberBase<Double>.TryConvertToSaturating<TOther>(Double, TOther)	Versucht, eine instance des aktuellen Typs in einen anderen Typ zu konvertieren und dabei alle Werte zu überlasten, die außerhalb des darstellbaren Bereichs des aktuellen Typs liegen.
INumberBase<Double>.TryConvertToTruncating<TOther>(Double, TOther)	Versucht, eine instance des aktuellen Typs in einen anderen Typ zu konvertieren, wobei alle Werte abgeschnitten werden, die außerhalb des darstellbaren Bereichs des aktuellen Typs liegen.
INumberBase<Double>.Zero	Ruft den Wert 0 für den Typ ab.
ISignedNumber<Double>.NegativeOne	Ruft den Wert -1 für den Typ ab.
ISubtractionOperators<Double,Double,Double>.Subtraction(Double, Double)	Subtrahiert zwei Werte, um deren Differenz zu berechnen.
IUnaryNegationOperators<Double,Double>.UnaryNegation(Double)	Berechnet die unäre Negation eines Werts.
IUnaryPlusOperators<Double,Double>.UnaryPlus(Double)	Berechnet das unäre Plus eines Werts.

Threadsicherheit

Alle Member dieses Typs sind threadsicher. Member, die instance Zustand zu ändern scheinen, geben tatsächlich eine neue instance zurück, die mit dem neuen Wert initialisiert wurde. Wie bei jedem anderen Typ muss das Lesen und Schreiben in eine freigegebene Variable, die eine instance dieses Typs enthält, durch eine Sperre geschützt werden, um die Threadsicherheit zu gewährleisten.

Weitere Informationen

• Decimal
• Single
• Beispiel: .NET Core-Hilfsprogramm zur Formatierung von WinForms (C#)
• Beispiel: .NET Core-Hilfsprogramm zur Formatierung von WinForms (Visual Basic)