(0) exportieren Drucken
Alle erweitern
Dieser Artikel wurde maschinell übersetzt. Bewegen Sie den Mauszeiger über die Sätze im Artikel, um den Originaltext anzuzeigen. Weitere Informationen
Übersetzung
Original

Double-Struktur

Stellt eine Gleitkommazahl mit doppelter Genauigkeit dar.

Namespace:  System
Assembly:  mscorlib (in mscorlib.dll)

[SerializableAttribute]
[ComVisibleAttribute(true)]
public struct Double : IComparable, IFormattable, 
	IConvertible, IComparable<double>, IEquatable<double>

Der Double-Typ macht die folgenden Member verfügbar.

  NameBeschreibung
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsCompareTo(Double)Vergleicht diese Instanz mit einer angegebenen Gleitkommazahl mit doppelter Genauigkeit und gibt eine ganze Zahl 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.
Öffentliche MethodeUnterstützt von XNA FrameworkCompareTo(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.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsEquals(Double)Gibt einen Wert zurück, der angibt, ob diese Instanz und ein angegebenes Double-Objekt den gleichen Wert darstellen.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsEquals(Object)Gibt einen Wert zurück, der angibt, ob diese Instanz gleich einem angegebenen Objekt ist. (Überschreibt ValueType.Equals(Object).)
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsGetHashCodeGibt den Hashcode für diese Instanz zurück. (Überschreibt ValueType.GetHashCode().)
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsGetTypeRuft den Type der aktuellen Instanz ab. (Von Object geerbt.)
Öffentliche MethodeUnterstützt von XNA FrameworkGetTypeCodeGibt die TypeCode-Enumeration für den Werttyp Double zurück.
Öffentliche MethodeStatischer MemberUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsIsInfinityGibt einen Wert zurück, der angibt, ob der Wert der angegebenen Zahl -unendlich oder +unendlich ist.
Öffentliche MethodeStatischer MemberUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsIsNaNGibt einen Wert zurück, der angibt, ob der angegebene Wert keine Nummer ist (NaN).
Öffentliche MethodeStatischer MemberUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsIsNegativeInfinityGibt einen Wert zurück, der angibt, ob der Wert der angegebenen Zahl -unendlich ist.
Öffentliche MethodeStatischer MemberUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsIsPositiveInfinityGibt einen Wert zurück, der angibt, ob der Wert der angegebenen Zahl +unendlich ist.
Öffentliche MethodeStatischer MemberUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsParse(String)Konvertiert die Zeichenfolgendarstellung einer Zahl in die entsprechende Gleitkommazahl mit doppelter Genauigkeit.
Öffentliche MethodeStatischer MemberUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsParse(String, NumberStyles)Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen Format in die entsprechende Gleitkommazahl mit doppelter Genauigkeit.
Öffentliche MethodeStatischer MemberUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsParse(String, IFormatProvider)Konvertiert die Zeichenfolgendarstellung einer Zahl in einem bestimmten kulturabhängigen Format in die entsprechende Gleitkommazahl mit doppelter Genauigkeit.
Öffentliche MethodeStatischer MemberUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsParse(String, NumberStyles, IFormatProvider)Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen Stil und einem kulturabhängigen Format in die entsprechende Gleitkommazahl mit doppelter Genauigkeit.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsToString()Konvertiert den Wert dieser Instanz in die entsprechende Zeichenfolgendarstellung. (Überschreibt ValueType.ToString().)
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsToString(IFormatProvider)Konvertiert den numerischen Wert dieser Instanz unter Berücksichtigung der angegebenen kulturabhängigen Formatierungsinformationen in die entsprechende Zeichenfolgendarstellung.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsToString(String)Konvertiert den numerischen Wert dieser Instanz in die entsprechende Zeichenfolgendarstellung unter Berücksichtigung des angegebenen Formats.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsToString(String, IFormatProvider)Konvertiert den numerischen Wert dieser Instanz unter Verwendung des angegebenen Formats und der angegebenen kulturabhängigen Formatierungsinformationen in die entsprechende Zeichenfolgendarstellung.
Öffentliche MethodeStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsTryParse(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.
Öffentliche MethodeStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsTryParse(String, NumberStyles, IFormatProvider, Double)Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen Stil und einem kulturabhängigen Format in die entsprechende Gleitkommazahl mit doppelter Genauigkeit. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich war oder nicht.
Zum Seitenanfang

  NameBeschreibung
Öffentlicher OperatorStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsEqualityGibt einen Wert zurück, der angibt, ob zwei angegebene Double-Werte gleich sind.
Öffentlicher OperatorStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsGreaterThanGibt einen Wert zurück, der angibt, ob ein angegebener Double-Wert größer als ein anderer angegebener Double-Wert ist.
Öffentlicher OperatorStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsGreaterThanOrEqualGibt einen Wert zurück, der angibt, ob ein angegebener Double-Wert größer oder gleich einem anderen angegebenen Double-Wert ist.
Öffentlicher OperatorStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsInequalityGibt einen Wert zurück, der angibt, ob zwei angegebene Double-Werte ungleich sind.
Öffentlicher OperatorStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsLessThanGibt einen Wert zurück, der angibt, ob ein angegebener Double-Wert kleiner als ein anderer angegebener Double-Wert ist.
Öffentlicher OperatorStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsLessThanOrEqualGibt einen Wert zurück, der angibt, ob ein angegebener Double-Wert kleiner oder gleich einem anderen angegebenen Double-Wert ist.
Zum Seitenanfang

  NameBeschreibung
Öffentliches FeldStatischer MemberUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsEpsilonStellt den kleinsten positiven Double-Wert dar, der größer als 0 (null) ist. Dieses Feld ist konstant.
Öffentliches FeldStatischer MemberUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsMaxValueStellt den größtmöglichen Wert der Double-Struktur dar. Dieses Feld ist konstant.
Öffentliches FeldStatischer MemberUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsMinValueStellt den kleinstmöglichen Wert von Double dar. Dieses Feld ist konstant.
Öffentliches FeldStatischer MemberUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsNaNStellt einen Wert dar, der keine Zahl ist (NaN). Dieses Feld ist konstant.
Öffentliches FeldStatischer MemberUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsNegativeInfinityStellt minus unendlich dar. Dieses Feld ist konstant.
Öffentliches FeldStatischer MemberUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsPositiveInfinityStellt plus unendlich dar. Dieses Feld ist konstant.
Zum Seitenanfang

  NameBeschreibung
Explizite SchnittstellenimplementierungPrivate MethodeUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsIComparable.CompareToVergleicht die aktuelle Instanz mit einem anderen Objekt vom selben Typ und gibt eine ganze Zahl zurück, die angibt, ob die aktuelle Instanz in der Sortierreihenfolge vor oder nach dem anderen Objekt oder an derselben Position auftritt.
Explizite SchnittstellenimplementierungPrivate MethodeUnterstützt von XNA FrameworkIConvertible.ToBooleanInfrastruktur. Eine Beschreibung dieses Members finden Sie unter IConvertible.ToBoolean.
Explizite SchnittstellenimplementierungPrivate MethodeUnterstützt von XNA FrameworkIConvertible.ToByteInfrastruktur. Eine Beschreibung dieses Members finden Sie unter IConvertible.ToByte.
Explizite SchnittstellenimplementierungPrivate MethodeUnterstützt von XNA FrameworkIConvertible.ToCharInfrastruktur. Diese Konvertierung wird nicht unterstützt. Bei dem Versuch der Verwendung dieser Methode wird eine InvalidCastException ausgelöst.
Explizite SchnittstellenimplementierungPrivate MethodeUnterstützt von XNA FrameworkIConvertible.ToDateTimeInfrastruktur. Diese Konvertierung wird nicht unterstützt. Bei dem Versuch der Verwendung dieser Methode wird eine InvalidCastException ausgelöst.
Explizite SchnittstellenimplementierungPrivate MethodeUnterstützt von XNA FrameworkIConvertible.ToDecimalInfrastruktur. Eine Beschreibung dieses Members finden Sie unter IConvertible.ToDecimal.
Explizite SchnittstellenimplementierungPrivate MethodeUnterstützt von XNA FrameworkIConvertible.ToDoubleInfrastruktur. Eine Beschreibung dieses Members finden Sie unter IConvertible.ToDouble.
Explizite SchnittstellenimplementierungPrivate MethodeUnterstützt von XNA FrameworkIConvertible.ToInt16Infrastruktur. Eine Beschreibung dieses Members finden Sie unter IConvertible.ToInt16.
Explizite SchnittstellenimplementierungPrivate MethodeUnterstützt von XNA FrameworkIConvertible.ToInt32Infrastruktur. Eine Beschreibung dieses Members finden Sie unter IConvertible.ToInt32.
Explizite SchnittstellenimplementierungPrivate MethodeUnterstützt von XNA FrameworkIConvertible.ToInt64Infrastruktur. Eine Beschreibung dieses Members finden Sie unter IConvertible.ToInt64.
Explizite SchnittstellenimplementierungPrivate MethodeUnterstützt von XNA FrameworkIConvertible.ToSByteInfrastruktur. Eine Beschreibung dieses Members finden Sie unter IConvertible.ToSByte.
Explizite SchnittstellenimplementierungPrivate MethodeUnterstützt von XNA FrameworkIConvertible.ToSingleInfrastruktur. Eine Beschreibung dieses Members finden Sie unter IConvertible.ToSingle.
Explizite SchnittstellenimplementierungPrivate MethodeUnterstützt von XNA FrameworkIConvertible.ToTypeInfrastruktur. Eine Beschreibung dieses Members finden Sie unter IConvertible.ToType.
Explizite SchnittstellenimplementierungPrivate MethodeUnterstützt von XNA FrameworkIConvertible.ToUInt16Infrastruktur. Eine Beschreibung dieses Members finden Sie unter IConvertible.ToUInt16.
Explizite SchnittstellenimplementierungPrivate MethodeUnterstützt von XNA FrameworkIConvertible.ToUInt32Infrastruktur. Eine Beschreibung dieses Members finden Sie unter IConvertible.ToUInt32.
Explizite SchnittstellenimplementierungPrivate MethodeUnterstützt von XNA FrameworkIConvertible.ToUInt64Infrastruktur. Eine Beschreibung dieses Members finden Sie unter IConvertible.ToUInt64.
Zum Seitenanfang

Der Double-Werttyp wird eine 64-Bit-Zahl mit doppelter Genauigkeit mit den von reichenden negativem 1.79769313486232e308 positiven Werte bis zu positivem 1.79769313486232e308 dar, sowie oder negativ null, PositiveInfinity, NegativeInfinity und keine Zahl (NaN). Es soll, um Werte darzustellen, die (wie Abstände zwischen Planeten oder Galaxien) sehr groß sind, oder sehr klein (die molekulare Masse einer in den Substanz Kilogramm) und die häufig ungenau sind (z der Abstand von der Erde zu einem anderen Sonnensystem), ruft der Double-Typ mit dem Standard IEC- 60559:1989 (IEEE 754) für die Gleitkommaarithmetik aus.

Dieses Thema enthält folgende Abschnitte:

Gleitkommadarstellung und Genauigkeit

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

Segment

Bits

Signifikand oder Mantisse

0-51

Exponent

52-62

Zeichen (0 = positive, negative 1 =)

63

Genauso wie Dezimalstellen nicht möglich sind, geringfügig Bruchwerte genau darzustellen (wie 1/3 oder Math.PI), sind Binärbrüche nicht in der Lage, einige Bruchwerte darzustellen. Beispielsweise wird 1/10, das genau durch .1 als Dezimalstelle dargestellt wird, durch .001100110011 als Binärbruch dargestellt, mit dem Muster "0011 ", iterativ gegen Unendlich. In diesem Fall stellt der Gleitkommawert eine ungenaue Darstellung der Zahl, die sie darstellt. Das Ausführen zusätzlicher mathematischen Operationen auf dem ursprünglichen Gleitkommawert sich häufig, die Fehlerfreiheit Genauigkeit zu erhöhen. Wenn wir das Ergebnis der Multiplikation .1 mit 10 und des Hinzufügens von .1 bis .1 neunmal vergleichen, finden wir die Addition, da acht weitere Vorgänge beteiligt besitzt, weisen erzeugt kleiner präzises Ergebnis. Beachten Sie, dass diese Ungleichheit offensichtlich ist, wenn wir die zwei Double-Werte anzeigen, indem wir "R" numerische Standardformatzeichenfolge verwenden, die ggf. alle 17 Ziffern von Genauigkeit unterstützt Double durch den Typ.


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


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

Alle Gleitkommazahlen haben ebenfalls eine begrenzte Anzahl signifikante Ziffern, die auch bestimmt, wie genau ein Gleitkommawert eine reelle Zahl entspricht. Ein Double-Wert hat bis 15 Dezimalstellen Genauigkeit, jedoch maximal 17 Ziffern intern verwaltet wird. Dies bedeutet, dass einige Gleitkommaoperationen kann die Genauigkeit Einigen, um einen Gleitkommawert zu ändern. Dies wird im folgenden Beispiel veranschaulicht. Es definiert einen sehr großen Gleitkommawert und dann das Produkt von Double.Epsilon und einem Quadrillion hinzu. Das Produkt ist jedoch zu klein, den ursprünglichen Gleitkommawert zu ändern. Seine wenige signifikante Ziffer handelt Tausendstel-, während die signifikanteste Ziffer im Produkt. 1 ist.-312


using System;

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


Die eingeschränkte Genauigkeit eine Gleitkommazahl hat mehrere Folgen:

  • Zwei Gleitkommazahlen, die bei einer bestimmten Genauigkeit als gleich gelten, können bei einer anderen Genauigkeit als ungleich gelten, da sich die letzten signifikanten Ziffern unterscheiden. Im folgenden Beispiel wird eine Reihe von Zahlen addiert, und deren Summe wird mit ihrer erwarteten Summe verglichen. Obwohl die beiden Werte werden, sind identisch, ist ein Aufruf der Equals-Methode an, dass sie es 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).   
    
    
    

    Wenn Sie die Formatelemente in der Console.WriteLine(String, Object, Object)-Anweisung von {0} und {1} zu {0:R} und {1:R} ändern, um alle signifikanten Stellen der beiden Double-Werte anzuzeigen, ist es klar, dass die beiden Werte aufgrund eines Verlust von Genauigkeit bei Additionen ungleich sind. In diesem Fall kann das Problem behoben werden, indem die Math.Round(Double, Int32)-Methode aufruft, um die Double-Werte zur gewünschten Genauigkeit abzurunden, bevor Sie den Vergleich ausführt.

  • Ein mathematisches oder ein Vergleich, die eine Gleitkommazahl verwendet, können möglicherweise nicht das gleiche Ergebnis, falls eine Dezimalzahl verwendet wird, da die binäre Gleitkommazahl möglicherweise nicht dem Dezimaltrennzeichen entspricht. In einem vorherigen Beispiel veranschaulicht dies, indem das Ergebnis der Multiplikation .1 mit 10 und zum Hinzufügen von .1mal wird.

    Wenn Genauigkeit in numerischen Vorgängen mit Bruchwerten wichtig ist, können Sie Decimal und der Double-Typ verwenden. Wenn Genauigkeit in numerischen Vorgängen mit ganzzahligen Werten über den Bereich der Int64 oder UInt64-Typen hinaus wichtig ist, verwenden Sie den Typ BigInteger.

  • Ein Wert hat möglicherweise kein Roundtrip wenn eine Gleitkommazahl betroffen ist. Ein Wert wird betont, um einen Roundtrip zu übergeben, wenn ein Vorgang eine ursprüngliche Gleitkommazahl zu einem anderen Formular konvertiert, ein inverser Ausführen wandelt das konvertierte Formular zurück in eine Gleitkommazahl, und die endgültige Gleitkommazahl ist ungleich der ursprüngliche Gleitkommazahl. Die Wiederherstellung könnte fehlschlagen, wenn ein oder mehr niederstwertige Ziffern bei einer Konvertierung verloren gehen oder geändert werden. Im folgenden Beispiel werden drei Double-Werte in Zeichenfolgen konvertiert und in einer Datei gespeichert. Wie die Ausgabe jedoch darstellt obwohl die Werte werden, identisch sein, sind die wiederhergestellten Werte ungleich der ursprünglichen Werte.

    
    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
    
    
    

    In diesem Fall können die Werte erfolgreich einen Roundtrip werden, indem "R" numerische Standardformatzeichenfolge verwendet, um die vollständige Genauigkeit von 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:R}{1}", values[ctr], ctr < values.Length - 1 ? "|" : "" );
    
          sw.Close();
    
          Double[] restoredValues = new Double[values.Length];
          StreamReader sr = new StreamReader(@".\Doubles.dat");
          string temp = sr.ReadToEnd();
          string[] tempStrings = temp.Split('|');
          for (int ctr = 0; ctr < tempStrings.Length; ctr++)
             restoredValues[ctr] = Double.Parse(tempStrings[ctr]);   
    
    
          for (int ctr = 0; ctr < values.Length; ctr++)
             Console.WriteLine("{0} {2} {1}", values[ctr], 
                               restoredValues[ctr],
                               values[ctr].Equals(restoredValues[ctr]) ? "=" : "<>");
       }
    }
    // The example displays the following output:
    //       2.17821782178218 = 2.17821782178218
    //       0.333333333333333 = 0.333333333333333
    //       3.14159265358979 = 3.14159265358979
    
    
    
  • Single -Werte eine geringere Genauigkeit als Double-Werte. Ein Wert, der an Single scheinbar entsprechenden Double konvertiert wird, häufig entspricht dem Double-Wert aufgrund der Unterschiede von Genauigkeit. Im folgenden Beispiel Double und einem Single-Wert ist das Ergebnis der identischen Divisionen zugewiesen. Nachdem der Single-Wert in Double umgewandelt ist, wird ein Vergleich der beiden Werte dar, 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
    
    
    

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

Außerdem kann sich das Ergebnis von arithmetischen Vorgängen und Zuweisungsvorgängen mit Double-Werten bei unterschiedlichen Plattformen wegen des Verlusts an Genauigkeit für den Double-Typ unterscheiden. Das Ergebnis der Zuweisung eines literalen Double-Werts kann sich z. B. in der 32-Bit- und der 64-Bit-Version von .NET Framework unterscheiden. Im folgenden Beispiel wird dieser Unterschied veranschaulicht, wenn einer Double-Variable der literale Wert -4.42330604244772E-305 und eine Variable, deren Wert -4.42330604244772E-305 ist, zugewiesen werden. Beachten Sie, dass das Ergebnis der Parse(String)-Methode in diesem Fall keinem Genauigkeitsverlust unterliegt.


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      


Testen auf Gleichheit

So darstellen als gleich zu werden, müssen zwei Double-Werte identische Werte. Aufgrund der Unterschiede von Genauigkeit zwischen Werten oder aufgrund eines Verlust einer Präzision von einer oder beide Werte, Gleitkommawerte, die erwartet werden, um das Ausschalten identische häufig zu sein, z aufgrund der Unterschiede bei der am wenigsten signifikanten Ziffern ungleich sind. Folglich Aufrufe der, ob zwei Werte oder Aufrufe gleich sind, die Methode CompareTo bestimmen Methode, Equals, um die Beziehung zwischen zwei Double-Werten, häufig Ertragunerwartete ergebnisse zu bestimmen. Dies ist im folgenden Beispiel zutage, in dem zwei anscheinend gleiche Double fehlschlagen, Werte ungleich sein, da der erste 15 Stellen darstellen 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


Berechnete Werte, die verschiedenen Codepfaden folgen und auf unterschiedliche Arten bearbeitet werden, sind oftmals ungleich. Im folgenden Beispiel wird ein Double-Wert quadriert, und anschließend wird die Quadratwurzel berechnet, um den ursprünglichen Zellenwert wiederherzustellen. Eine Double Sekunde wird mit 3,51 multipliziert und quadriert, bevor die Quadratwurzel des Ergebnisses durch 3,51 geteilt wird, um den ursprünglichen Zellenwert wiederherzustellen. Obwohl die beiden Werte werden, identisch sein, ist ein Aufruf der Equals(Double)-Methode an, dass sie nicht gleich sind. Verwenden der R-Zeile Standardformatzeichenfolge, um ein Ergebnis zurückzugeben String-, das alle signifikanten Ziffern jedes Double-Werts darstellt anzeigt, 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


In Fällen wo ein Genauigkeitsverlust wahrscheinlich ist, ist das Ergebnis eines Vergleichs zu beeinflussen, können Sie folgende Alternativen zum Aufrufen von Equals oder CompareTo-Methode aufweisen:

  • Rufen Sie die Math.Round-Methode auf, um sicherzustellen, dass beide Werte dieselbe Genauigkeit haben. Im folgenden Beispiel ändert ein vorheriges Beispiel, um diese Vorgehensweise zu verwenden, damit zwei Bruchwerte entsprechen.

    
    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
    
    
    

    Hinweis, obwohl, der das Problem von Genauigkeit weiterhin zum Abrunden der Mittelpunktwerten übernommen wird. Weitere Informationen finden Sie unter der Math.Round(Double, Int32, MidpointRounding)-Methode.

  • Test für Gleichheit ungefähre anstatt Gleichheit. Dies erfordert, dass Sie entweder eine absolute Menge, durch die sich die Werte unterscheiden können, jedoch gleich, noch zu sein definieren oder dass eine relative Menge definieren, durch die der kleinere Wert im größeren Wert abweichen kann.

    WarnhinweisVorsicht

    Double.Epsilon wird auch als absolute Measure des Abstands zwischen zwei Double-Werten beim Testen auf Gleichheit verwendet. jedoch Double.Epsilon misst den kleinstmöglichen Wert, das hinzugefügt werden oder der subtrahiert werden kann, Double, dessen Wert null ist. Für positivste und negativste Double-Werte ist der Wert von Double.Epsilon zu klein erkannt werden. Daher außer Werten, die Null sind, nicht empfohlen die Verwendung in den Tests für Gleichheit.

    Im folgenden Beispiel wird der letzten Vorgehensweise, um eine IsApproximatelyEqual-Methode zu definieren, die den relativen Unterschied zwischen zwei Werten testet. Es werden auch das Ergebnis der Aufrufe der IsApproximatelyEqual-Methode und der Equals(Double)-Methode.

    
    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
    
    
    

Gleitkommawerte und Ausnahmen

Anders als Operationen mit ganzzahligen Typen, die Ausnahmen im Falle des Überlaufs oder ungültigen Vorgänge wie Division durch 0 auslösen, lösen Operationen mit Gleitkommawerten keine Ausnahmen aus. Stattdessen in den Ausnahmesituationen, ist das Ergebnis eines Gleitkommavorgangs positiv unendlich oder negativ unendlich oder keine Zahl Nullen (NaN):

  • Wenn das Ergebnis eines Gleitkommavorgangs zum Zielformat zu klein ist, ist das Ergebnis gleich. 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
    
    
    
  • Wenn die Größe des Ergebnisses eines Gleitkommavorgangs den Bereich des Zielformats überschreitet, ist das Ergebnis des Vorgangs PositiveInfinity oder NegativeInfinity, entsprechend dem Zeichen des Ergebnisses. Das Ergebnis einer Operation, der Double.MaxValue überschritten ist PositiveInfinity, und das Ergebnis einer Operation, dass Überläufe Double.MinValueNegativeInfinity ist, wie im 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
    
    
    

    PositiveInfinity wird auch von einer Division von 0 durch eine positive Dividend und NegativeInfinity Ergebnisse einer Division durch 0 mit einer negativen Dividend.

  • Wenn eine Gleitkommaoperation ungültig ist, ist das Ergebnis der Operation NaN. Beispielsweise führt die NaN aus den folgenden Vorgängen:

  • Alle Gleitkommavorgang mit einer ungültigen Eingaben. Beispielsweise die Math.Sqrt-Methode einem negativen Wert Aufruf gibt NaN zurück, wie erfolgt, die Math.Acos-Methode mit einem Wert aufgerufen wird, der größer als eine oder weniger als negative eins ist.

  • Jede Operation mit einem Argument, dessen Wert Double.NaN ist.

Gleitkommafunktionalität

Die Struktur Double und verwandte Typen stellen Methoden, um Vorgänge in den folgenden Bereichen auszuführen:

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

    Die Double-Struktur unterstützt ebenfalls einen vollständigen Satz Vergleichsoperatoren. Beispielsweise können Sie auf Gleichheit oder Ungleichheit testen, oder um zu bestimmen, ob ein Wert größer oder gleich einem anderen Wert ist. Wenn einer der Operanden ein numerischer anderen Typ als Double ist, wird er in Double konvertiert, bevor der Vergleich ausführt.

    WarnhinweisVorsicht

    Aufgrund der Unterschiede von Genauigkeit, fallen zwei Double-Werte sein, die Sie erwarten sein, aus, gleich, ungleich sein, die das Ergebnis des Vergleichs beeinflusst. Siehe den Abschnitt Tests für Gleichheit weitere Informationen zum Vergleichen von zwei Werten. Double

    Sie können IsNaN, IsInfinity, IsPositiveInfinity und IsNegativeInfinity-Methoden aufrufen, um für diese speziellen Werte zu testen.

  • Mathematische Vorgänge. Gängige arithmetische Operationen, wie Addition, Subtraktion, Multiplikation und Division, werden durch Sprachcompiler und allgemeine Intermediate Language (CIL)- Anweisungen, anstatt von Double-Methoden implementiert. Wenn einer der Operanden in einen mathematischen Vorgang ein numerischer anderen Typ als Double ist, wird er in Double konvertiert, bevor der Vorgang ausführt. Das Ergebnis des Vorgangs ist auch ein Double-Wert.

    Andere mathematische Vorgänge können ausgeführt werden, indem Sie static-Methoden (Shared in Visual Basic) in der System.Math-Klasse aufruft. Sie enthält die zusätzlichen Methoden, die für arithmetische häufig verwendet werden (beispielsweise Math.Abs, Math.Sign und Math.Sqrt), Geometrien (wie Math.Cos und Math.Sin) und enthält Calculus (wie Math.Log).

    Sie können die einzelnen Bits eines Double-Wert auch bearbeiten. Die BitConverter.DoubleToInt64Bits-Methode verwaltet Bitmusters eines Double-Werts in eine 64-Bit-Ganzzahl bei. Die BitConverter.GetBytes(Double)-Methode gibt sein Bitmuster in einem Bytearray zurück.

  • Runden. Das Runden ist als Verfahren zum Reduzieren der Auswirkungen von Unterschieden zwischen den Werten häufig verwendet, die von Problemen der Gleitkommadarstellung verursacht werden und Genauigkeit. Sie können aufrunden einen Double-Wert, 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 die Funktion für die kombinierte Formatierung verwenden. Weitere Informationen zu Formatzeichenfolgen, wie die Zeichenfolgendarstellung von Gleitkommawerten steuern, finden Sie die Themen Standardmäßige Zahlenformatzeichenfolgen und Benutzerdefinierte Zahlenformatzeichenfolgen.

  • Analysieren von Zeichenfolgen. Sie kann die Zeichenfolgendarstellung eines Gleitkommawerts auf ein Double-Wert konvertieren, indem Sie Parse oder TryParse-Methode aufrufen. Wenn die Analyseoperation fehlschlägt, löst die Parse-Methode eine Ausnahme aus, während die TryParse-Methode false zurückgibt.

  • Typkonvertierung. Die Double-Struktur stellt eine explizite Schnittstellenimplementierung für die IConvertible-Schnittstelle bereit, die Konvertierung zwischen zwei standardmäßige .net framework-datentypen unterstützt. Sprachcompiler unterstützen auch die implizite Konvertierung von Werten aller anderen Standardnumerischen Laufzeittypen zu Double-Werten. Konvertierung eines Werts eines Standardnumerischen typs zu Double ist eine Erweiterungskonvertierung und kann den Benutzer einer Umwandlungsoperator- oder -Konvertierungsmethode,

    Allerdings können Konvertierung von Int64 und Single-Werte einen Genauigkeitsverlust beinhalten. In der folgenden Tabelle werden die Unterschiede der Genauigkeit für jeden dieser Typen auf:

    Typ

    Maximale Genauigkeit

    Interne Genauigkeit

    Double

    15

    17

    Int64

    19 Dezimalstellen

    19 Dezimalstellen

    Single

    7 Dezimalstellen

    9 Dezimalstellen

    Das Problem einer Präzision beeinflusst sehr häufig Single-Werte, die für Double-Werte konvertiert werden. Im folgenden Beispiel sind zwei Werte, die durch identische Divisionen erzeugten, ungleich, da eines der Werte ein Gleitkommawert einfacher Genauigkeit ist, der in Double konvertiert 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
    
    
    

Das folgende Codebeispiel veranschaulicht die Verwendung von Double:


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

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

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

			return m_value.ToString(format, provider);
		}

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

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

			return temp;
		}

		// The value holder
		protected double m_value;

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

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


.NET Framework

Unterstützt in: 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Unterstützt in: 4, 3.5 SP1

Portable Klassenbibliothek

Unterstützt in: Portable Klassenbibliothek

.NET für Windows Store-Apps

Unterstützt in: Windows 8

.NET für Windows Phone-Apps

Unterstützt in: Windows Phone 8, Silverlight 8.1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (Server Core-Rolle wird nicht unterstützt), Windows Server 2008 R2 (Server Core-Rolle wird mit SP1 oder höher unterstützt; Itanium wird nicht unterstützt)

.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen für .NET Framework.

Alle Member dieses Typs sind threadsicher. Member, die scheinbar den Zustand einer Instanz ändern, geben in Wirklichkeit eine neue Instanz zurück, die mit dem neuen Wert initialisiert wurde. Wie bei allen anderen Typen müssen Lese- und Schreibzugriffe auf eine freigegebene Variable, die eine Instanz dieses Typs enthält, durch eine Sperre geschützt werden, um die Threadsicherheit zu gewährleisten.

WarnhinweisVorsicht

Die Zuweisung einer Instanz dieses Typs ist nicht auf allen Hardwareplattformen threadsicher, da die binäre Darstellung der Instanz u. U. zu groß ist, sodass die Zuweisung nicht in einem einzelnen atomaren Vorgang abgeschlossen werden kann.

Community-Beiträge

HINZUFÜGEN
Anzeigen:
© 2014 Microsoft