Double Struktur
Definition
Wichtig
Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.
Stellt eine Gleitkommazahl mit doppelter Genauigkeit dar.
public value class double : IComparable, IComparable<double>, IConvertible, IEquatable<double>, IFormattablepublic value class double : IComparable, IComparable<double>, IConvertible, IEquatable<double>, ISpanFormattablepublic 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>, System::Numerics::IDecrementOperators<double>, System::Numerics::IDivisionOperators<double, double, double>, System::Numerics::IEqualityOperators<double, double>, System::Numerics::IExponentialFunctions<double>, System::Numerics::IFloatingPoint<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 value class double : IComparable, IConvertible, IFormattablepublic value class double : IComparable, IComparable<double>, IEquatable<double>, IFormattablepublic struct Double : IComparable, IComparable<double>, IConvertible, IEquatable<double>, IFormattablepublic readonly struct Double : IComparable, IComparable<double>, IConvertible, IEquatable<double>, IFormattablepublic readonly struct Double : IComparable, IComparable<double>, IConvertible, IEquatable<double>, ISpanFormattablepublic 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>, System.Numerics.IDecrementOperators<double>, System.Numerics.IDivisionOperators<double,double,double>, System.Numerics.IEqualityOperators<double,double>, System.Numerics.IExponentialFunctions<double>, System.Numerics.IFloatingPoint<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>[System.Serializable]
public struct Double : IComparable, IConvertible, IFormattable[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public struct Double : IComparable, IComparable<double>, IConvertible, IEquatable<double>, IFormattablepublic struct Double : IComparable, IComparable<double>, IEquatable<double>, IFormattabletype double = struct
interface IConvertible
interface IFormattabletype double = struct
interface IConvertible
interface ISpanFormattable
interface IFormattabletype 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>
interface IEqualityOperators<double, double>
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 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>[<System.Serializable>]
type double = struct
interface IFormattable
interface IConvertible[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type double = struct
interface IFormattable
interface IConvertibletype double = struct
interface IFormattablePublic Structure Double
Implements IComparable, IComparable(Of Double), IConvertible, IEquatable(Of Double), IFormattablePublic Structure Double
Implements IComparable, IComparable(Of Double), IConvertible, IEquatable(Of Double), ISpanFormattablePublic 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), IConvertible, IDecrementOperators(Of Double), IDivisionOperators(Of Double, Double, Double), IEqualityOperators(Of Double, Double), IEquatable(Of Double), IExponentialFunctions(Of Double), IFloatingPoint(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)Public Structure Double
Implements IComparable, IConvertible, IFormattablePublic Structure Double
Implements IComparable, IComparable(Of Double), IEquatable(Of Double), IFormattable- Vererbung
- Attribute
- Implementiert
-
IComparable IComparable<Double> IConvertible IEquatable<Double> IFormattable ISpanFormattable IComparable<TOther> IComparable<TSelf> IEquatable<TOther> 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> IComparisonOperators<TSelf,TSelf> IDecrementOperators<Double> IDecrementOperators<TSelf> IDivisionOperators<Double,Double,Double> IDivisionOperators<TSelf,TSelf,TSelf> IEqualityOperators<Double,Double> IEqualityOperators<TSelf,TOther> IEqualityOperators<TSelf,TSelf> IExponentialFunctions<Double> IExponentialFunctions<TSelf> IFloatingPoint<Double> IFloatingPoint<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 Double:
// 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 doppelte Genauigkeit 64-Bit-Zahl mit Werten dar, die von negativen 1,797693134862e308 bis positiv 1,797693134862e308 sowie positive oder negative NullPositiveInfinityNegativeInfinity, und nicht eine Zahl (NaN) entsprechen. Es soll Werte darstellen, die extrem groß sind (z. B. Entfernungen zwischen Planeten oder Galaxien) oder extrem klein (z. B. die molekulare Masse einer Substanz in Kilogramm) und die oft unvoreingesehen sind (z. B. der Abstand von Erde zu einem anderen Sonnensystem). Der Double Typ entspricht dem IEC 60559:1989 (IEEE 754) Standard für binäre Gleitkomma-Arithmetik.
Dieses Thema enthält folgende Abschnitte:
Floating-Point Darstellung und Genauigkeit
Der Double Datentyp speichert doppelte Gleitkommawerte in einem 64-Bit-Binärformat, wie in der folgenden Tabelle dargestellt:
| Teil | Bits |
|---|---|
| Significand oder mantissa | 0-51 |
| Exponent | 52-62 |
| Sign (0 = Positiv, 1 = Negativ) | 63 |
Wie dezimale Bruchwerte nicht präzise darstellen können (z. B. 1/3 oder Math.PI), binäre Brüche können einige Bruchwerte nicht darstellen. Beispielsweise wird 1/10, das genau durch .1 als Dezimalbruch dargestellt wird, durch .001100110011 als binärer Bruch dargestellt, wobei das Muster "00011" in unendlich wiederholt wird. In diesem Fall stellt der Gleitkommawert eine ungenaue Darstellung der Zahl bereit, die sie darstellt. Bei zusätzlichen mathematischen Vorgängen auf dem ursprünglichen Gleitkommawert wird häufig der Mangel an Genauigkeit erhöht. Wenn wir z. B. das Ergebnis der Multiplikation von .1 um 10 vergleichen und .1 zu .1 neun Mal hinzufügen, sehen wir, dass diese Ergänzung, da sie acht weitere Vorgänge umfasst, das weniger präzise Ergebnis erzeugt hat. Beachten Sie, dass diese Disparität nur angezeigt wird, wenn wir die beiden Double Werte mithilfe der Double Standardmäßigen numerischen Formatzeichenfolge "R" anzeigen, die bei Bedarf alle 17 Ziffern der Genauigkeit anzeigt, die vom Typ unterstützt werden.
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 Bruch binärwerte dargestellt werden können, können Gleitkommazahlen nur ungefähre reale Zahlen darstellen.
Alle Gleitkommazahlen verfügen auch über eine begrenzte Anzahl von signifikanten Ziffern, die auch bestimmt, wie genau ein Gleitkommawert eine reale Zahl angibt. Ein Double Wert weist bis zu 15 Dezimalstellen der Genauigkeit auf, obwohl maximal 17 Ziffern intern beibehalten werden. Dies bedeutet, dass einige Gleitkommavorgänge möglicherweise die Genauigkeit fehlen, um einen Gleitkommawert zu ändern. Dies wird im folgenden Beispiel veranschaulicht. Es definiert einen sehr großen Gleitkommawert und fügt dann das Produkt von Double.Epsilon und einem Quadrillion hinzu. Das Produkt ist jedoch zu klein, um den ursprünglichen Gleitkommawert zu ändern. Die am wenigsten bedeutende Zahl ist Tausendththen, während die wichtigsten Ziffern des Produkts 10-309 sind.
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 Gleitkommanummer weist mehrere Folgen auf:
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 werden eine Reihe von Zahlen zusammengezählt, und deren Gesamtsumme wird mit der erwarteten Summe verglichen. Obwohl die beiden Werte identisch sind, gibt ein Aufruf der
EqualsMethode an, dass sie nicht vorhanden 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 zu{0:R}und zu ändern und{1}{1:R}alle signifikanten Ziffern der beiden Double Werte anzuzeigen, ist klar, dass die beiden Werte aufgrund eines Genauigkeitsverlusts während der Ergänzungsvorgänge ungleich sind. In diesem Fall kann das Problem behoben werden, indem Math.Round(Double, Int32) die Methode aufgerufen wird, um die Werte auf die Double gewünschte Genauigkeit zu runden, bevor sie den Vergleich ausführen.Ein mathematischer oder Vergleichsvorgang, der eine Gleitkommanummer verwendet, führt möglicherweise nicht zu demselben Ergebnis, wenn eine Dezimalzahl verwendet wird, da die binäre Gleitkommanummer möglicherweise nicht der Dezimalzahl entspricht. Ein vorheriges Beispiel veranschaulichte dies, indem das Ergebnis der Multiplikation von .1 um 10 angezeigt und 1 mal hinzugefügt wird.
Wenn die Genauigkeit in numerischen Vorgängen mit Bruchwerten wichtig ist, können Sie den Decimal Typ anstelle des Double Typs verwenden. Wenn die Genauigkeit in numerischen Vorgängen mit integralen Werten außerhalb des Bereichs der Int64 UInt64 typen wichtig ist, verwenden Sie den BigInteger Typ.
Ein Wert kann nicht runder Weg gehen, wenn eine Gleitkommanummer beteiligt ist. Ein Wert gilt für eine Rundfahrt, wenn ein Vorgang eine ursprüngliche Gleitkommanummer in ein anderes Formular konvertiert, ein umgekehrter Vorgang transformiert das konvertierte Formular in eine Gleitkommanummer zurück, und die endgültige Gleitkommanummer entspricht nicht der ursprünglichen Gleitkommanummer. Die Rundreise kann fehlschlagen, da eine oder mehrere wichtige Ziffern verloren gehen oder in 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 Werte jedoch identisch, die wiederhergestellten Werte nicht den ursprünglichen Werten entsprechen.
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.14159265358979open 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.14159265358979Imports 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.14159265358979In diesem Fall können die Werte mithilfe der standardmäßigen numerischen Formatzeichenfolge "G17" erfolgreich gerundet werden, um die vollständige Genauigkeit von Double Werten beizubehalten, wie im folgenden Beispiel dargestellt.
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.14159265358979open 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.14159265358979Imports 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 schlägt der Formatbezeichner "R" in einigen Fällen nicht erfolgreich den ursprünglichen Wert zurück. Um sicherzustellen, dass Double Werte erfolgreich round-trip sind, verwenden Sie den Formatbezeichner "G17".
Single Werte haben weniger Genauigkeit als Double Werte. Ein Single Wert, der in einen scheinbar gleichwertigen Double Wert konvertiert wird, entspricht häufig nicht dem Double Wert aufgrund von Unterschiede in der Genauigkeit. Im folgenden Beispiel wird das Ergebnis identischer Divisionsvorgänge einem Wert und einem Single Wert zugewiesenDouble. Nachdem der Single Wert in einen DoubleGegossen wird, 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: Falseopen 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: FalseModule 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: FalseUm dieses Problem zu vermeiden, verwenden Sie entweder Double Single den Datentyp oder verwenden Sie die Round Methode, damit beide Werte dieselbe Genauigkeit haben.
Darüber hinaus kann sich das Ergebnis von Arithmetik- und Zuordnungsvorgängen mit Double Werten leicht durch Plattform unterscheiden, da die Genauigkeit des Double Typs verloren geht. Das Ergebnis der Zuweisung eines Literalwerts Double kann sich beispielsweise in den 32-Bit- und 64-Bit-Versionen der .NET Framework unterscheiden. Im folgenden Beispiel wird dieser Unterschied veranschaulicht, wenn der Literalwert -4.4233060424772E-305 und eine Variable, deren Wert -4.4233060424772E-305 einer Double Variable zugewiesen ist. Beachten Sie, dass das Ergebnis der Parse(String) Methode in diesem Fall nicht unter einem Genauigkeitsverlust leidet.
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 der Gleichheit
Um gleich zu gelten, müssen zwei Double Werte identische Werte darstellen. Aufgrund von Differenzen zwischen Werten oder aufgrund eines Genauigkeitsverlusts durch einen oder beide Werte sind Gleitkommawerte, die wahrscheinlich identisch sind, aufgrund von Unterschieden in ihren am wenigsten signifikanten Ziffern ungleich. Daher werden Aufrufe der Equals Methode aufgerufen, um zu bestimmen, ob zwei Werte gleich sind oder die CompareTo Methode aufgerufen wird, um die Beziehung zwischen zwei Double Werten zu bestimmen, oft unerwartete Ergebnisse. Dies zeigt sich im folgenden Beispiel, wobei zwei scheinbar Double gleiche Werte ungleich sind, da die erste 15 Ziffern Genauigkeit aufweist, 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, sind häufig 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 quadratisch, bevor die Quadratwurzel des Ergebnisses durch 3,51 geteilt wird, um den ursprünglichen Wert wiederherzustellen. Obwohl die beiden Werte identisch sind, 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 signifikanten Ziffern jedes Doppelwerts 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 Equals CompareTo Oder Methode übernehmen:
Rufen Sie die Math.Round Methode auf, um sicherzustellen, dass beide Werte dieselbe Genauigkeit aufweisen. Im folgenden Beispiel wird ein vorheriges Beispiel geändert, um diesen Ansatz zu verwenden, 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: Trueopen 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: TrueModule 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: TrueDas Problem der Genauigkeit gilt weiterhin für die Rundung von Mittewerten. Weitere Informationen finden Sie unter der Methode Math.Round(Double, Int32, MidpointRounding).
Testen Sie ungefähre Gleichheit statt Gleichheit. Dies erfordert, dass Sie entweder einen absoluten Betrag definieren, durch den sich die beiden Werte unterscheiden können, aber trotzdem gleich sein können oder dass Sie einen relativen Betrag definieren, durch den der kleinere Wert von dem größeren Wert abweichen kann.
Warnung
Double.Epsilon wird manchmal als absolutes Maß für den Abstand zwischen zwei Double Werten beim Testen der Gleichheit verwendet. Double.Epsilon Misst jedoch den kleinsten möglichen Wert, der hinzugefügt werden kann, oder subtrahiert von einem Wert, Double dessen Wert null ist. Für die meisten positiven und negativen Double Werte ist der Wert Double.Epsilon zu klein, um erkannt zu werden. Mit Ausnahme von Werten, die null sind, empfehlen wir daher die Verwendung in Tests für Gleichheit nicht.
Im folgenden Beispiel wird der letzte Ansatz verwendet, um eine
IsApproximatelyEqualMethode zu definieren, die den relativen Unterschied zwischen zwei Werten testet. Außerdem wird das Ergebnis von Aufrufen der Methode und derIsApproximatelyEqualEquals(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: Trueopen 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: TrueModule 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 in Fällen von Überlauf- oder illegalen Vorgängen wie Teilung nach Null auslösen, werden Vorgänge mit Gleitkommawerten nicht ausgelöst. Stattdessen ist das Ergebnis eines Gleitkommavorgangs 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 das folgende Beispiel zeigt.
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: Truelet 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: TrueModule 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: TrueWenn die Höhe des Ergebnisses eines Gleitkommavorgangs den Bereich des Zielformats überschreitet, ist PositiveInfinity das Ergebnis des Vorgangs oder NegativeInfinityentsprechend für das Zeichen des Ergebnisses geeignet. Das Ergebnis eines Vorgangs, der überlauft ist, und das Ergebnis eines VorgangsDouble.MaxValue, der überlauft Double.MinValue istPositiveInfinityNegativeInfinity, wie das folgende Beispiel zeigt.
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: Trueopen 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: TrueModule 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: TruePositiveInfinity ergibt sich auch aus einer Division um Null mit einer positiven Dividende und NegativeInfinity ergibt sich aus einer Division um Null mit einer negativen Dividende.
Wenn ein Gleitkommavorgang ungültig ist, lautet NaNdas Ergebnis des Vorgangs . Beispiel: NaN Ergebnisse aus den folgenden Vorgängen:
- Division um Null mit einer Dividende von Null. Beachten Sie, dass andere Fälle der Division nach Null entweder PositiveInfinity oder NegativeInfinity.
Alle Gleitkommavorgänge mit einer ungültigen Eingabe. Wenn Sie beispielsweise die Math.Sqrt Math.Acos Methode mit einem negativen Wert aufrufenNaN, wird die Methode mit einem Wert aufgerufen, der größer als ein oder weniger negativ ist.
Jeder Vorgang mit einem Argument, dessen Wert ist Double.NaN.
Typkonvertierungen und die Doppelstruktur
Die Double Struktur definiert keine expliziten oder impliziten Konvertierungsoperatoren. Stattdessen werden Konvertierungen vom Compiler implementiert.
Die Konvertierung des Werts eines grundformatigen numerischen Typs in Double eine Verbreiterung ist eine Erweiterungskonvertierung und erfordert daher keinen expliziten Castoperator oder Aufruf einer Konvertierungsmethode, es sei denn, ein Compiler erfordert es explizit. Der C#-Compiler erfordert beispielsweise einen Casting-Operator für Konvertierungen von Decimal zu Double, während der Visual Basic Compiler nicht. Im folgenden Beispiel wird der Mindest- oder Maximalwert anderer numerischer Grundtypen in einen 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 die Werte in Double.NaN, Double.PositiveInfinityund Single.NegativeInfinity , bzwDouble.NegativeInfinity. in konvertiert.
Beachten Sie, dass die Konvertierung des Werts einiger numerischer Typen zu einem Double Wert einen Verlust der Genauigkeit erfordern kann. Wie das Beispiel veranschaulicht, ist beim Konvertieren DecimalInt64von UInt64 Werten Double ein Genauigkeitsverlust möglich.
Die Konvertierung eines Double Werts in einen Wert eines anderen grundtyps numerischen Datentyps ist eine schmale Konvertierung und erfordert einen Castoperator (in C#), eine Konvertierungsmethode (in Visual Basic) oder einen Aufruf einer Convert Methode. Werte, die außerhalb des Bereichs des Zieldatentyps liegen, die durch die Eigenschaften und MaxValue Eigenschaften des Zieltyps MinValue definiert werden, verhalten sich wie in der folgenden Tabelle dargestellt.
| Zieltyp | Ergebnis |
|---|---|
| Jeder integrale Typ | Ausnahme OverflowException , wenn die Konvertierung in einem überprüften Kontext auftritt. Wenn die Konvertierung in einem deaktivierten Kontext (der Standard in C#) auftritt, 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.NaNDouble.PositiveInfinityDouble.NegativeInfinity wird eine OverflowException Konvertierung in ganzzahlige Zahlen in einem überprüften Kontext ausgelöst, aber diese Werte überlaufen, wenn sie in ganzzahlige Zahlen in einen deaktivierten Kontext konvertiert werden. Für Konvertierungen in Decimal, sie werfen immer eine OverflowException. Konvertierung in Single, sie konvertieren in Single.NaN, Single.PositiveInfinity, und Single.NegativeInfinitybzw.
Beachten Sie, dass ein Verlust der Genauigkeit dazu führen kann, dass ein Double Wert in einen anderen numerischen Typ konvertiert wird. Bei der Konvertierung in eine 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 (wie in C#). Für Konvertierungen und Decimal Single Werte verfügt der Double Wert möglicherweise nicht über eine genaue Darstellung im Zieldatentyp.
Im folgenden Beispiel wird eine Anzahl von Double Werten in mehrere andere numerische Typen konvertiert. Die Konvertierungen treten in einem überprüften Kontext in Visual Basic (standard) in C# (aufgrund des überprüften Schlüsselworts) und in F# (aufgrund des überprüften Moduls) auf. Die Ausgabe aus dem Beispiel zeigt das Ergebnis für Konvertierungen in einem deaktivierten Kontext. Sie können Konvertierungen in einem deaktivierten Kontext in Visual Basic ausführen, indem Sie mit dem /removeintchecks+ Compilerschalter, in C# kompilieren, indem Sie die Anweisung und in F# kommentieren, indem Sie die checked open Checked Anweisung kommentieren.
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 in den .NET Framework- und Typkonvertierungstabellen.
Floating-Point Funktionalität
Die Double Struktur und verwandte Typen bieten Methoden zum Ausführen von Vorgängen in den folgenden Bereichen:
Vergleich von Werten. Sie können die Equals Methode aufrufen, um festzustellen, ob zwei Double Werte gleich sind, oder CompareTo die Methode, um die Beziehung zwischen zwei Werten zu bestimmen.
Die Double Struktur unterstützt auch einen vollständigen Satz von Vergleichsoperatoren. Sie können z. B. auf Gleichheit oder Ungleichheit testen oder bestimmen, ob ein Wert größer oder gleich einer anderen ist. Wenn eine der Operanden ein anderer typ als ein anderes als ein Doublenumerischer Typ ist, wird er in eine Double konvertiert, bevor der Vergleich ausgeführt wird.
Warnung
Aufgrund von Unterschiede in der Genauigkeit können zwei Double Werte, die Sie erwarten, ungleich sein, was sich auf das Ergebnis des Vergleichs auswirkt. Weitere Informationen zum Vergleich von zwei Double Werten finden Sie im Abschnitt "Tests für Gleichheit".
Sie können auch die IsNaNIsInfinityMethoden aufrufen, IsPositiveInfinityIsNegativeInfinity um diese speziellen Werte zu testen.
Mathematische Vorgänge. Häufige arithmetische Vorgänge, z. B. Ergänzung, Subtraktion, Multiplikation und Division, werden durch Sprachcompiler und Common Intermediate Language (CIL)-Anweisungen implementiert, anstatt durch Double Methoden. Wenn eine der Operanden in einem mathematischen Vorgang ein anderer als ein numerischer Typ ist, wird er vor dem Ausführen des Vorgangs in ein anderes als ein Double numerischer Typ Doublekonvertiert. Das Ergebnis des Vorgangs ist auch ein Double Wert.
Andere mathematische Vorgänge können durch Aufrufen
static(Sharedin Visual Basic) Methoden in der System.Math Klasse ausgeführt werden. Es enthält zusätzliche Methoden, die häufig für Arithmetik (z. B. , Math.Signund ), Geometrie (z. B. und Math.SqrtMath.Sin) und Calculus Math.Log(Math.Coswie Math.Absz. 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. Die Rundung wird häufig als Technik zum Verringern der Auswirkungen von Werten verwendet, die durch Probleme der Gleitkommadarstellung 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 die Zeichenfolgendarstellung konvertieren, indem Sie die Methode aufrufen oder mithilfe des ToString Zusammengesetztformatierungsfeatures verwenden. Informationen dazu, wie Formatzeichenfolgen die Zeichenfolgendarstellung von Gleitkommawerten steuern, finden Sie in den Themen "Standard Numerische FormatZeichenfolgen" und "Benutzerdefinierte numerische Zeichenfolgen".
Analysieren von Zeichenfolgen. Sie können die Zeichenfolgendarstellung eines Gleitkommawerts in einen Double Wert konvertieren, indem Sie entweder die Parse Methode aufrufen.TryParse Wenn der Analysevorgang fehlschlägt, löst die Methode eine Ausnahme aus, während die Parse TryParse Methode zurückgibt
false.Typkonvertierung. Die Double Struktur stellt eine explizite Schnittstellenimplementierung für die IConvertible Schnittstelle bereit, die die Konvertierung zwischen allen beiden Standarddatentypen .NET Framework unterstützt. Sprachcompiler unterstützen auch die implizite Konvertierung von Werten aller anderen standard numerischen Typen in Double Werte. Die Konvertierung eines Werts eines standard numerischen Typs in eine Double Erweiterungskonvertierung und erfordert keinen Benutzer eines Casting-Operators oder einer Konvertierungsmethode,
Die Konvertierung und Int64 Single die Werte können jedoch einen Genauigkeitsverlust erfordern. In der folgenden Tabelle sind die Unterschiede in der Genauigkeit für jede 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 Abteilungsvorgängen erzeugt werden, ungleich, da eine der Werte ein einzelner Gleitkommawert ist, der in einen Doubleumgewandelt 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.99999999999999989let 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.99999999999999989Module 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 ( |
| 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-Cosine eines Werts. |
| Acosh(Double) |
Berechnet den hyperbolischen Arc-Cosine eines Werts. |
| Asin(Double) |
Berechnet den Bogensine eines Werts. |
| Asinh(Double) |
Berechnet den hyperbolischen Arc-Sine eines Werts. |
| Atan(Double) |
Berechnet den Arc-Tangent eines Werts. |
| Atan2(Double, Double) |
Berechnet den Arc-Tangent des Quotienten von zwei Werten. |
| Atanh(Double) |
Berechnet den hyperbolischen Arc-Tangent eines Werts. |
| BitDecrement(Double) |
Dekrementiert einen Wert auf den kleinsten Wert, der kleiner als ein gegebener Wert vergleicht. |
| 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) |
Klammert einen Wert auf einen inklusiven Mindest- 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 Zeichen eines Werts in das Zeichen eines anderen Werts.. |
| Cos(Double) |
Berechnet den Kosinus eines Werts. |
| Cosh(Double) |
Berechnet den hyperbolischen Kosinus eines Werts. |
| CreateChecked<TOther>(TOther) |
Erstellt eine Instanz des aktuellen Typs aus einem Wert, die eine Überlaufausnahme für alle Werte auslöst, die außerhalb des repräsentativen Bereichs des aktuellen Typs liegen. |
| CreateSaturating<TOther>(TOther) |
Erstellt eine Instanz des aktuellen Typs aus einem Wert und Sättigung aller Werte, die außerhalb des repräsentativen Bereichs des aktuellen Typs liegen. |
| CreateTruncating<TOther>(TOther) |
Erstellt eine Instanz des aktuellen Typs aus einem Wert, wobei alle Werte abgeschnitten werden, die außerhalb des repräsentativen 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) |
Berechnet |
| Floor(Double) |
Berechnet den Boden eines Werts. |
| FusedMultiplyAdd(Double, Double, Double) |
Berechnet das verfügete multiplizierte Add von drei Werten. |
| GetHashCode() |
Gibt den Hashcode für diese Instanz zurück. |
| GetTypeCode() | |
| Ieee754Remainder(Double, Double) |
Berechnet den Rest von zwei Werten, wie von IEEE 754 angegeben. |
| ILogB(Double) |
Berechnet den ganzzahligen Logarithmus eines Werts. |
| 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. |
| 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. |
| IsPositiveInfinity(Double) |
Gibt einen Wert zurück, der angibt, ob die angegebene Zahl plus unendlich ergibt. |
| IsPow2(Double) |
Bestimmt, ob ein Wert eine Leistung von zwei ist. |
| IsSubnormal(Double) |
Bestimmt, ob der angegebene Wert subnormal ist. |
| Log(Double) |
Berechnet den natürlichen ( |
| Log(Double, Double) |
Berechnet den Logarithmus eines Werts in der angegebenen Basis. |
| Log10(Double) |
Berechnet den Basis-10-Logarithmus eines Werts. |
| Log2(Double) |
Berechnet das Protokoll2 eines Werts. |
| Max(Double, Double) |
Vergleicht zwei Werte, um zu berechnen, was größer ist. |
| MaxMagnitude(Double, Double) |
Vergleicht zwei Werte, um zu berechnen, was größer ist. |
| Min(Double, Double) |
Vergleicht zwei Werte mit der Berechnung, die kleiner ist. |
| MinMagnitude(Double, Double) |
Vergleicht zwei Werte mit der Berechnung, die kleiner ist. |
| Parse(ReadOnlySpan<Char>, IFormatProvider) |
Analysiert einen Bereich 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 ausgelöst wird. |
| ReciprocalEstimate(Double) |
Berechnet eine Schätzung der Gegenseitigkeit eines Werts. |
| ReciprocalSqrtEstimate(Double) |
Berechnet eine Schätzung der gegenseitigen Quadratwurzel eines Werts. |
| Round(Double) |
Rundet einen Wert auf die nächste ganze Zahl mit dem Standardrundenmodus (ToEven). |
| Round(Double, Int32) |
Rundet einen Wert auf eine angegebene Anzahl von Bruchstellen mit dem Standardrundenmodus (ToEven). |
| Round(Double, Int32, MidpointRounding) |
Rundet einen Wert auf eine angegebene Anzahl von Bruchstellen mit dem Standardrundenmodus (ToEven). |
| Round(Double, MidpointRounding) |
Rundet einen Wert mit dem angegebenen Rundungsmodus auf die nächste ganze Zahl ab. |
| ScaleB(Double, Int32) |
Berechnet das Produkt eines Werts und dessen Basisradix auf die angegebene Leistung. |
| Sign(Double) |
Berechnet das Zeichen eines Werts. |
| Sin(Double) |
Berechnet den Sinus eines Werts. |
| SinCos(Double) |
Berechnet den Sinus und den Kosinus eines Werts. |
| Sinh(Double) |
Berechnet den hyperbolischen Sinus eines Werts. |
| Sqrt(Double) |
Berechnet die Quadratwurzel eines Werts. |
| Tan(Double) |
Berechnet die Tangente eines Werts. |
| Tanh(Double) |
Berechnet den hyperbolischen Tangent eines Werts. |
| 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) |
Geschnitten einen Wert. |
| TryCreate<TOther>(TOther, Double) |
Versucht, eine Instanz des aktuellen Typs aus einem Wert zu erstellen. |
| 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, einen Bereich 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) | |
| 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
| IComparable.CompareTo(Object) |
Vergleicht 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. |
| IConvertible.GetTypeCode() |
Gibt den TypeCode für diese Instanz zurück. |
| 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). |
| IFloatingPoint<Double>.GetExponentByteCount() |
Ruft die Anzahl der Bytes ab, die als Teil von TryWriteExponentLittleEndian(Span<Byte>, Int32). |
| IFloatingPoint<Double>.GetExponentShortestBitLength() |
Ruft die Länge in Bits der kürzesten zwei Ergänzungsdarstellung des aktuellen Exponent ab. |
| IFloatingPoint<Double>.GetSignificandBitLength() |
Ruft die Länge in Bits des aktuellen Significand ab. |
| IFloatingPoint<Double>.GetSignificandByteCount() |
Ruft die Anzahl der Bytes ab, die als Teil von TryWriteSignificandLittleEndian(Span<Byte>, Int32). |
| IFloatingPoint<Double>.TryWriteExponentLittleEndian(Span<Byte>, Int32) |
Versucht, den aktuellen Exponent in kleinem Endenformat in einen bestimmten Bereich zu schreiben. |
| IFloatingPoint<Double>.TryWriteSignificandLittleEndian(Span<Byte>, Int32) |
Versucht, das aktuelle Significand, im klein-endischen Format, in einen bestimmten Bereich zu schreiben. |
Gilt für:
Threadsicherheit
Alle Elemente dieses Typs sind threadsicher. Elemente, die den Instanzstatus ändern möchten, geben tatsächlich eine neue Instanz zurück, die mit dem neuen Wert initialisiert wurde. Wie bei jedem anderen Typ muss das Lesen und Schreiben an eine freigegebene Variable, die eine Instanz dieses Typs enthält, durch eine Sperrung geschützt werden, um die Threadsicherheit zu gewährleisten.