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<double>, IConvertible, IEquatable<double>, IParsable<double>, ISpanParsable<double>, IUtf8SpanParsable<double>, System::Numerics::IAdditionOperators<double, double, double>, System::Numerics::IAdditiveIdentity<double, double>, System::Numerics::IBinaryFloatingPointIeee754<double>, System::Numerics::IBinaryNumber<double>, System::Numerics::IBitwiseOperators<double, double, double>, System::Numerics::IComparisonOperators<double, double, bool>, System::Numerics::IDecrementOperators<double>, System::Numerics::IDivisionOperators<double, double, double>, System::Numerics::IEqualityOperators<double, double, bool>, System::Numerics::IExponentialFunctions<double>, System::Numerics::IFloatingPoint<double>, System::Numerics::IFloatingPointConstants<double>, System::Numerics::IFloatingPointIeee754<double>, System::Numerics::IHyperbolicFunctions<double>, System::Numerics::IIncrementOperators<double>, System::Numerics::ILogarithmicFunctions<double>, System::Numerics::IMinMaxValue<double>, System::Numerics::IModulusOperators<double, double, double>, System::Numerics::IMultiplicativeIdentity<double, double>, System::Numerics::IMultiplyOperators<double, double, double>, System::Numerics::INumber<double>, System::Numerics::INumberBase<double>, System::Numerics::IPowerFunctions<double>, System::Numerics::IRootFunctions<double>, System::Numerics::ISignedNumber<double>, System::Numerics::ISubtractionOperators<double, double, double>, System::Numerics::ITrigonometricFunctions<double>, System::Numerics::IUnaryNegationOperators<double, double>, System::Numerics::IUnaryPlusOperators<double, double>public 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, bool>, System::Numerics::IDecrementOperators<double>, System::Numerics::IDivisionOperators<double, double, double>, System::Numerics::IEqualityOperators<double, double, bool>, System::Numerics::IExponentialFunctions<double>, System::Numerics::IFloatingPoint<double>, System::Numerics::IFloatingPointConstants<double>, System::Numerics::IFloatingPointIeee754<double>, System::Numerics::IHyperbolicFunctions<double>, System::Numerics::IIncrementOperators<double>, System::Numerics::ILogarithmicFunctions<double>, System::Numerics::IMinMaxValue<double>, System::Numerics::IModulusOperators<double, double, double>, System::Numerics::IMultiplicativeIdentity<double, double>, System::Numerics::IMultiplyOperators<double, double, double>, System::Numerics::INumber<double>, System::Numerics::INumberBase<double>, System::Numerics::IPowerFunctions<double>, System::Numerics::IRootFunctions<double>, System::Numerics::ISignedNumber<double>, System::Numerics::ISubtractionOperators<double, double, double>, System::Numerics::ITrigonometricFunctions<double>, System::Numerics::IUnaryNegationOperators<double, double>, System::Numerics::IUnaryPlusOperators<double, double>public 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<double>, IConvertible, IEquatable<double>, IParsable<double>, ISpanParsable<double>, IUtf8SpanParsable<double>, System.Numerics.IAdditionOperators<double,double,double>, System.Numerics.IAdditiveIdentity<double,double>, System.Numerics.IBinaryFloatingPointIeee754<double>, System.Numerics.IBinaryNumber<double>, System.Numerics.IBitwiseOperators<double,double,double>, System.Numerics.IComparisonOperators<double,double,bool>, System.Numerics.IDecrementOperators<double>, System.Numerics.IDivisionOperators<double,double,double>, System.Numerics.IEqualityOperators<double,double,bool>, System.Numerics.IExponentialFunctions<double>, System.Numerics.IFloatingPoint<double>, System.Numerics.IFloatingPointConstants<double>, System.Numerics.IFloatingPointIeee754<double>, System.Numerics.IHyperbolicFunctions<double>, System.Numerics.IIncrementOperators<double>, System.Numerics.ILogarithmicFunctions<double>, System.Numerics.IMinMaxValue<double>, System.Numerics.IModulusOperators<double,double,double>, System.Numerics.IMultiplicativeIdentity<double,double>, System.Numerics.IMultiplyOperators<double,double,double>, System.Numerics.INumber<double>, System.Numerics.INumberBase<double>, System.Numerics.IPowerFunctions<double>, System.Numerics.IRootFunctions<double>, System.Numerics.ISignedNumber<double>, System.Numerics.ISubtractionOperators<double,double,double>, System.Numerics.ITrigonometricFunctions<double>, System.Numerics.IUnaryNegationOperators<double,double>, System.Numerics.IUnaryPlusOperators<double,double>public readonly struct Double : IComparable, 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,bool>, System.Numerics.IDecrementOperators<double>, System.Numerics.IDivisionOperators<double,double,double>, System.Numerics.IEqualityOperators<double,double,bool>, System.Numerics.IExponentialFunctions<double>, System.Numerics.IFloatingPoint<double>, System.Numerics.IFloatingPointConstants<double>, System.Numerics.IFloatingPointIeee754<double>, System.Numerics.IHyperbolicFunctions<double>, System.Numerics.IIncrementOperators<double>, System.Numerics.ILogarithmicFunctions<double>, System.Numerics.IMinMaxValue<double>, System.Numerics.IModulusOperators<double,double,double>, System.Numerics.IMultiplicativeIdentity<double,double>, System.Numerics.IMultiplyOperators<double,double,double>, System.Numerics.INumber<double>, System.Numerics.INumberBase<double>, System.Numerics.IPowerFunctions<double>, System.Numerics.IRootFunctions<double>, System.Numerics.ISignedNumber<double>, System.Numerics.ISubtractionOperators<double,double,double>, System.Numerics.ITrigonometricFunctions<double>, System.Numerics.IUnaryNegationOperators<double,double>, System.Numerics.IUnaryPlusOperators<double,double>[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 IFormattable
interface IParsable<double>
interface ISpanFormattable
interface ISpanParsable<double>
interface IUtf8SpanFormattable
interface IUtf8SpanParsable<double>
interface IAdditionOperators<double, double, double>
interface IAdditiveIdentity<double, double>
interface IBinaryFloatingPointIeee754<double>
interface IBinaryNumber<double>
interface IBitwiseOperators<double, double, double>
interface IComparisonOperators<double, double, bool>
interface IEqualityOperators<double, double, bool>
interface IDecrementOperators<double>
interface IDivisionOperators<double, double, double>
interface IIncrementOperators<double>
interface IModulusOperators<double, double, double>
interface IMultiplicativeIdentity<double, double>
interface IMultiplyOperators<double, double, double>
interface INumber<double>
interface INumberBase<double>
interface ISubtractionOperators<double, double, double>
interface IUnaryNegationOperators<double, double>
interface IUnaryPlusOperators<double, double>
interface IExponentialFunctions<double>
interface IFloatingPointConstants<double>
interface IFloatingPoint<double>
interface ISignedNumber<double>
interface IFloatingPointIeee754<double>
interface IHyperbolicFunctions<double>
interface ILogarithmicFunctions<double>
interface IPowerFunctions<double>
interface IRootFunctions<double>
interface ITrigonometricFunctions<double>
interface IMinMaxValue<double>type 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, bool>
interface IEqualityOperators<double, double, bool>
interface IDecrementOperators<double>
interface IDivisionOperators<double, double, double>
interface IIncrementOperators<double>
interface IModulusOperators<double, double, double>
interface IMultiplicativeIdentity<double, double>
interface IMultiplyOperators<double, double, double>
interface INumber<double>
interface INumberBase<double>
interface ISubtractionOperators<double, double, double>
interface IUnaryNegationOperators<double, double>
interface IUnaryPlusOperators<double, double>
interface IExponentialFunctions<double>
interface IFloatingPointConstants<double>
interface IFloatingPoint<double>
interface ISignedNumber<double>
interface IFloatingPointIeee754<double>
interface IHyperbolicFunctions<double>
interface ILogarithmicFunctions<double>
interface IPowerFunctions<double>
interface IRootFunctions<double>
interface ITrigonometricFunctions<double>
interface IMinMaxValue<double>type double = struct
interface IConvertible
interface IFormattable
interface IParsable<double>
interface ISpanFormattable
interface ISpanParsable<double>
interface IAdditionOperators<double, double, double>
interface IAdditiveIdentity<double, double>
interface IBinaryFloatingPointIeee754<double>
interface IBinaryNumber<double>
interface IBitwiseOperators<double, double, double>
interface IComparisonOperators<double, double, bool>
interface IEqualityOperators<double, double, bool>
interface IDecrementOperators<double>
interface IDivisionOperators<double, double, double>
interface IIncrementOperators<double>
interface IModulusOperators<double, double, double>
interface IMultiplicativeIdentity<double, double>
interface IMultiplyOperators<double, double, double>
interface INumber<double>
interface INumberBase<double>
interface ISubtractionOperators<double, double, double>
interface IUnaryNegationOperators<double, double>
interface IUnaryPlusOperators<double, double>
interface IUtf8SpanFormattable
interface IUtf8SpanParsable<double>
interface IExponentialFunctions<double>
interface IFloatingPointConstants<double>
interface IFloatingPoint<double>
interface ISignedNumber<double>
interface IFloatingPointIeee754<double>
interface IHyperbolicFunctions<double>
interface ILogarithmicFunctions<double>
interface IPowerFunctions<double>
interface IRootFunctions<double>
interface ITrigonometricFunctions<double>
interface IMinMaxValue<double>[<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 IAdditionOperators(Of Double, Double, Double), IAdditiveIdentity(Of Double, Double), IBinaryFloatingPointIeee754(Of Double), IBinaryNumber(Of Double), IBitwiseOperators(Of Double, Double, Double), IComparable(Of Double), IComparisonOperators(Of Double, Double, Boolean), IConvertible, IDecrementOperators(Of Double), IDivisionOperators(Of Double, Double, Double), IEqualityOperators(Of Double, Double, Boolean), IEquatable(Of Double), IExponentialFunctions(Of Double), IFloatingPoint(Of Double), IFloatingPointConstants(Of Double), IFloatingPointIeee754(Of Double), IHyperbolicFunctions(Of Double), IIncrementOperators(Of Double), ILogarithmicFunctions(Of Double), IMinMaxValue(Of Double), IModulusOperators(Of Double, Double, Double), IMultiplicativeIdentity(Of Double, Double), IMultiplyOperators(Of Double, Double, Double), INumber(Of Double), INumberBase(Of Double), IParsable(Of Double), IPowerFunctions(Of Double), IRootFunctions(Of Double), ISignedNumber(Of Double), ISpanParsable(Of Double), ISubtractionOperators(Of Double, Double, Double), ITrigonometricFunctions(Of Double), IUnaryNegationOperators(Of Double, Double), IUnaryPlusOperators(Of Double, Double), IUtf8SpanParsable(Of Double)Public 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, Boolean), IConvertible, IDecrementOperators(Of Double), IDivisionOperators(Of Double, Double, Double), IEqualityOperators(Of Double, Double, Boolean), IEquatable(Of Double), IExponentialFunctions(Of Double), IFloatingPoint(Of Double), IFloatingPointConstants(Of Double), IFloatingPointIeee754(Of Double), IHyperbolicFunctions(Of Double), IIncrementOperators(Of Double), ILogarithmicFunctions(Of Double), IMinMaxValue(Of Double), IModulusOperators(Of Double, Double, Double), IMultiplicativeIdentity(Of Double, Double), IMultiplyOperators(Of Double, Double, Double), INumber(Of Double), INumberBase(Of Double), IParsable(Of Double), IPowerFunctions(Of Double), IRootFunctions(Of Double), ISignedNumber(Of Double), ISpanParsable(Of Double), ISubtractionOperators(Of Double, Double, Double), ITrigonometricFunctions(Of Double), IUnaryNegationOperators(Of Double, Double), IUnaryPlusOperators(Of Double, Double)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 IComparable<TSelf> IEquatable<TSelf> IParsable<Double> IParsable<TSelf> ISpanFormattable ISpanParsable<Double> ISpanParsable<TSelf> IUtf8SpanFormattable IUtf8SpanParsable<Double> IUtf8SpanParsable<TSelf> IAdditionOperators<Double,Double,Double> IAdditionOperators<TSelf,TSelf,TSelf> IAdditiveIdentity<Double,Double> IAdditiveIdentity<TSelf,TSelf> IBinaryFloatingPointIeee754<Double> IBinaryNumber<Double> IBinaryNumber<TSelf> IBitwiseOperators<Double,Double,Double> IBitwiseOperators<TSelf,TSelf,TSelf> IComparisonOperators<Double,Double,Boolean> IComparisonOperators<TSelf,TSelf,Boolean> IDecrementOperators<Double> IDecrementOperators<TSelf> IDivisionOperators<Double,Double,Double> IDivisionOperators<TSelf,TSelf,TSelf> IEqualityOperators<Double,Double,Boolean> IEqualityOperators<TSelf,TOther,TResult> IEqualityOperators<TSelf,TSelf,Boolean> IExponentialFunctions<Double> IExponentialFunctions<TSelf> IFloatingPoint<Double> IFloatingPoint<TSelf> IFloatingPointConstants<Double> IFloatingPointConstants<TSelf> IFloatingPointIeee754<Double> IFloatingPointIeee754<TSelf> IHyperbolicFunctions<Double> IHyperbolicFunctions<TSelf> IIncrementOperators<Double> IIncrementOperators<TSelf> ILogarithmicFunctions<Double> ILogarithmicFunctions<TSelf> IMinMaxValue<Double> IModulusOperators<Double,Double,Double> IModulusOperators<TSelf,TSelf,TSelf> IMultiplicativeIdentity<Double,Double> IMultiplicativeIdentity<TSelf,TSelf> IMultiplyOperators<Double,Double,Double> IMultiplyOperators<TSelf,TSelf,TSelf> INumber<Double> INumber<TSelf> INumberBase<Double> INumberBase<TSelf> IPowerFunctions<Double> IPowerFunctions<TSelf> IRootFunctions<Double> IRootFunctions<TSelf> ISignedNumber<Double> ISignedNumber<TSelf> ISubtractionOperators<Double,Double,Double> ISubtractionOperators<TSelf,TSelf,TSelf> ITrigonometricFunctions<Double> ITrigonometricFunctions<TSelf> IUnaryNegationOperators<Double,Double> IUnaryNegationOperators<TSelf,TSelf> IUnaryPlusOperators<Double,Double> IUnaryPlusOperators<TSelf,TSelf>
Beispiele
Das folgende Codebeispiel veranschaulicht die Verwendung von Double:
// The Temperature class stores the temperature as a Double
// and delegates most of the functionality to the Double
// implementation.
public class Temperature : IComparable, IFormattable
{
// IComparable.CompareTo implementation.
public int CompareTo(object obj) {
if (obj == null) return 1;
Temperature temp = obj as Temperature;
if (obj != null)
return m_value.CompareTo(temp.m_value);
else
throw new ArgumentException("object is not a Temperature");
}
// IFormattable.ToString implementation.
public string ToString(string format, IFormatProvider provider) {
if( format != null ) {
if( format.Equals("F") ) {
return String.Format("{0}'F", this.Value.ToString());
}
if( format.Equals("C") ) {
return String.Format("{0}'C", this.Celsius.ToString());
}
}
return m_value.ToString(format, provider);
}
// Parses the temperature from a string in the form
// [ws][sign]digits['F|'C][ws]
public static Temperature Parse(string s, NumberStyles styles, IFormatProvider provider) {
Temperature temp = new Temperature();
if( s.TrimEnd(null).EndsWith("'F") ) {
temp.Value = Double.Parse( s.Remove(s.LastIndexOf('\''), 2), styles, provider);
}
else if( s.TrimEnd(null).EndsWith("'C") ) {
temp.Celsius = Double.Parse( s.Remove(s.LastIndexOf('\''), 2), styles, provider);
}
else {
temp.Value = Double.Parse(s, styles, provider);
}
return temp;
}
// The value holder
protected double m_value;
public double Value {
get {
return m_value;
}
set {
m_value = value;
}
}
public double Celsius {
get {
return (m_value-32.0)/1.8;
}
set {
m_value = 1.8*value+32.0;
}
}
}
// The Temperature class stores the temperature as a Double
// and delegates most of the functionality to the Double
// implementation.
type Temperature() =
member val Value = 0. with get, set
member this.Celsius
with get () = (this.Value - 32.) / 1.8
and set (value) =
this.Value <- 1.8 * value + 32.
// Parses the temperature from a string in the form
// [ws][sign]digits['F|'C][ws]
static member Parse(s: string, styles: NumberStyles, provider: IFormatProvider) =
let temp = Temperature()
if s.TrimEnd(null).EndsWith "'F" then
temp.Value <- Double.Parse(s.Remove(s.LastIndexOf '\'', 2), styles, provider)
elif s.TrimEnd(null).EndsWith "'C" then
temp.Celsius <- Double.Parse(s.Remove(s.LastIndexOf '\'', 2), styles, provider)
else
temp.Value <- Double.Parse(s, styles, provider)
temp
interface IComparable with
// IComparable.CompareTo implementation.
member this.CompareTo(obj: obj) =
match obj with
| null -> 1
| :? Temperature as temp ->
this.Value.CompareTo temp.Value
| _ ->
invalidArg "obj" "object is not a Temperature"
interface IFormattable with
// IFormattable.ToString implementation.
member this.ToString(format: string, provider: IFormatProvider) =
match format with
| "F" ->
$"{this.Value}'F"
| "C" ->
$"{this.Celsius}'C"
| _ ->
this.Value.ToString(format, provider)
' Temperature class stores the value as Double
' and delegates most of the functionality
' to the Double implementation.
Public Class Temperature
Implements IComparable, IFormattable
Public Overloads Function CompareTo(ByVal obj As Object) As Integer _
Implements IComparable.CompareTo
If TypeOf obj Is Temperature Then
Dim temp As Temperature = CType(obj, Temperature)
Return m_value.CompareTo(temp.m_value)
End If
Throw New ArgumentException("object is not a Temperature")
End Function
Public Overloads Function ToString(ByVal format As String, ByVal provider As IFormatProvider) As String _
Implements IFormattable.ToString
If Not (format Is Nothing) Then
If format.Equals("F") Then
Return [String].Format("{0}'F", Me.Value.ToString())
End If
If format.Equals("C") Then
Return [String].Format("{0}'C", Me.Celsius.ToString())
End If
End If
Return m_value.ToString(format, provider)
End Function
' Parses the temperature from a string in form
' [ws][sign]digits['F|'C][ws]
Public Shared Function Parse(ByVal s As String, ByVal styles As NumberStyles, ByVal provider As IFormatProvider) As Temperature
Dim temp As New Temperature()
If s.TrimEnd().EndsWith("'F") Then
temp.Value = Double.Parse(s.Remove(s.LastIndexOf("'"c), 2), styles, provider)
Else
If s.TrimEnd().EndsWith("'C") Then
temp.Celsius = Double.Parse(s.Remove(s.LastIndexOf("'"c), 2), styles, provider)
Else
temp.Value = Double.Parse(s, styles, provider)
End If
End If
Return temp
End Function
' The value holder
Protected m_value As Double
Public Property Value() As Double
Get
Return m_value
End Get
Set(ByVal Value As Double)
m_value = Value
End Set
End Property
Public Property Celsius() As Double
Get
Return (m_value - 32) / 1.8
End Get
Set(ByVal Value As Double)
m_value = Value * 1.8 + 32
End Set
End Property
End Class
Hinweise
Der Double Werttyp stellt eine 64-Bit-Zahl mit doppelter Genauigkeit mit Werten dar, die von negativen 1,79769313486232e308 bis positiven 1,79769313486232e308 sowie positiven oder negativen Nullen, PositiveInfinityund NegativeInfinitynicht einer Zahl (NaN) reichen. 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 ungenau sind (z. B. die Entfernung von der Erde zu einem anderen Sonnensystem). Der Double Typ entspricht dem IEC 60559:1989 (IEEE 754)-Standard für binäre Gleitkommaarithmetik.
Fließkommadarstellung und Genauigkeit
Der Double Datentyp speichert Gleitkommawerte mit doppelter Genauigkeit in einem 64-Bit-Binärformat, wie in der folgenden Tabelle dargestellt:
| Bauteil | Binäre Ziffern |
|---|---|
| Signifikant oder Mantisse | 0-51 |
| Exponent | 52-62 |
| Vorzeichen (0 = Positiv, 1 = Negativ) | 63 |
Ebenso wie Dezimalbrüche bestimmte Bruchwerte (z. B. 1/3 oder Math.PI) nicht präzise darstellen können, können binäre Brüche einige Bruchwerte nicht darstellen. Beispielsweise wird 1/10, das genau durch .1 als Dezimalbruch dargestellt wird, durch .001100110011 als ein binärer Bruch dargestellt, wobei das Muster "0011" unendlich wiederholt wird. In diesem Fall stellt der Gleitkommawert eine ungenaue Darstellung der Zahl dar, die er repräsentiert. Durch das Ausführen zusätzlicher mathematischer Vorgänge für den ursprünglichen Gleitkommawert wird häufig der Mangel an Genauigkeit erhöht. Wenn Sie z. B. das Ergebnis der Multiplikation von 0,1 mit 10 mit dem Ergebnis aus dem neunmaligen Hinzufügen von 0,1 vergleichen, sehen Sie, dass die Addition, da sie acht weitere Vorgänge erfordert hat, das weniger präzise Ergebnis erzeugt hat. (Vor .NET 10 wird diese Ungleichzahl nur angezeigt, wenn Sie die beiden Double-Werte mithilfe der Zeichenfolge "R" standardformatzeichenfolge anzeigen, die bis zu allen 17 Ziffern der Genauigkeit angezeigt wird, die vom Typ Double unterstützt werden.)
using System;
public class Example13
{
public static void Main()
{
Double value = .1;
Double result1 = value * 10;
Double result2 = 0;
for (int ctr = 1; ctr <= 10; ctr++)
result2 += value;
Console.WriteLine($".1 * 10: {result1:R}");
Console.WriteLine($".1 Added 10 times: {result2:R}");
}
}
// The example displays the following output:
// .1 * 10: 1
// .1 Added 10 times: 0.99999999999999989
let value = 0.1
let result1 = value * 10.
let mutable result2 = 0.
for i = 1 to 10 do
result2 <- result2 + value
printfn $".1 * 10: {result1:R}"
printfn $".1 Added 10 times: {result2:R}"
// The example displays the following output:
// .1 * 10: 1
// .1 Added 10 times: 0.99999999999999989
Module Example14
Public Sub Run()
Dim value As Double = 0.1
Dim result1 As Double = value * 10
Dim result2 As Double
For ctr As Integer = 1 To 10
result2 += value
Next
Console.WriteLine(".1 * 10: {0:R}", result1)
Console.WriteLine(".1 Added 10 times: {0:R}", result2)
End Sub
End Module
' The example displays the following output:
' .1 * 10: 1
' .1 Added 10 times: 0.99999999999999989
Da einige Zahlen nicht exakt als Bruch-Binärwerte dargestellt werden können, können Gleitkommazahlen nur reelle Zahlen annähern.
Alle Gleitkommazahlen weisen auch eine begrenzte Anzahl von signifikanten Ziffern auf, wodurch auch bestimmt wird, wie genau ein Gleitkommawert eine reelle Zahl annähert. Ein Double Wert hat eine Genauigkeit von bis zu 15 Dezimalstellen, obwohl maximal 17 Ziffern intern gehandhabt werden. Dies bedeutet, dass bei einigen Gleitkommavorgängen möglicherweise die Genauigkeit zum Ändern eines Gleitkommawerts fehlt. Dies wird im folgenden Beispiel veranschaulicht. Es definiert einen sehr großen Gleitkommawert und fügt dann das Produkt von Double.Epsilon und einer Quadrillion hinzu. Das Produkt ist jedoch zu klein, um die ursprüngliche Fließkommazahl zu verändern. Seine am wenigsten signifikante Ziffer ist Tausendstel, während die wichtigste Ziffer im Produkt 10-309 ist.
using System;
public class Example14
{
public static void Main()
{
Double value = 123456789012.34567;
Double additional = Double.Epsilon * 1e15;
Console.WriteLine($"{value} + {additional} = {value + additional}");
}
}
// The example displays the following output:
// 123456789012.346 + 4.94065645841247E-309 = 123456789012.346
open System
let value = 123456789012.34567
let additional = Double.Epsilon * 1e15
printfn $"{value} + {additional} = {value + additional}"
// The example displays the following output:
// 123456789012.346 + 4.94065645841247E-309 = 123456789012.346
Module Example15
Public Sub Run()
Dim value As Double = 123456789012.34567
Dim additional As Double = Double.Epsilon * 1.0E+15
Console.WriteLine("{0} + {1} = {2}", value, additional,
value + additional)
End Sub
End Module
' The example displays the following output:
' 123456789012.346 + 4.94065645841247E-309 = 123456789012.346
Die begrenzte Genauigkeit einer Gleitkommazahl hat mehrere Folgen:
Zwei Gleitkommazahlen, die für eine bestimmte Genauigkeit gleich erscheinen, können nicht gleich verglichen werden, da ihre am wenigsten signifikanten Ziffern unterschiedlich sind. Im folgenden Beispiel werden eine Reihe von Zahlen addiert, und ihre Summe wird mit der erwarteten Summe verglichen.
using System; public class Example10 { public static void Main() { Double[] values = { 10.0, 2.88, 2.88, 2.88, 9.0 }; Double result = 27.64; Double total = 0; foreach (var value in values) total += value; if (total.Equals(result)) Console.WriteLine("The sum of the values equals the total."); else Console.WriteLine($"The sum of the values ({total}) does not equal the total ({result})."); } } // The example displays the following output: // The sum of the values (36.64) does not equal the total (36.64). // // If the index items in the Console.WriteLine statement are changed to {0:R}, // the example displays the following output: // The sum of the values (27.639999999999997) does not equal the total (27.64).let values = [ 10.0; 2.88; 2.88; 2.88; 9.0 ] let result = 27.64 let total = List.sum values if total.Equals result then printfn "The sum of the values equals the total." else printfn $"The sum of the values ({total}) does not equal the total ({result})." // The example displays the following output: // The sum of the values (36.64) does not equal the total (36.64). // // If the index items in the Console.WriteLine statement are changed to {0:R}, // the example displays the following output: // The sum of the values (27.639999999999997) does not equal the total (27.64).Module Example11 Public Sub Run() Dim values() As Double = {10.0, 2.88, 2.88, 2.88, 9.0} Dim result As Double = 27.64 Dim total As Double For Each value In values total += value Next If total.Equals(result) Then Console.WriteLine("The sum of the values equals the total.") Else Console.WriteLine("The sum of the values ({0}) does not equal the total ({1}).", total, result) End If End Sub End Module ' The example displays the following output: ' The sum of the values (36.64) does not equal the total (36.64). ' ' If the index items in the Console.WriteLine statement are changed to {0:R}, ' the example displays the following output: ' The sum of the values (27.639999999999997) does not equal the total (27.64).Die beiden Werte sind aufgrund eines Genauigkeitsverlusts während der Additionsvorgänge ungleich. In diesem Fall kann das Problem behoben werden, indem die Math.Round(Double, Int32) Methode aufgerufen wird, um die Double Werte auf die gewünschte Genauigkeit zu runden, bevor der Vergleich ausgeführt wird.
Ein mathematischer oder Vergleichsvorgang, der eine Gleitkommazahl verwendet, liefert möglicherweise nicht dasselbe Ergebnis, wenn eine Dezimalzahl verwendet wird, da die binäre Gleitkommazahl möglicherweise nicht der Dezimalzahl entspricht. Ein vorheriges Beispiel veranschaulichte dies, indem es das Ergebnis der Multiplikation von 0,1 mit 10 und das mehrfache Hinzufügen von 0,1 zeigte.
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 über den Bereich der Int128UInt128 Typen hinaus wichtig ist, verwenden Sie den BigInteger Typ.
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 Genauigkeitsunterschieden. Im folgenden Beispiel wird das Ergebnis identischer Divisionsvorgänge einem Double Und einem Single Wert zugewiesen. Nach dem Umwandeln des Single Werts in einen Double, ein Vergleich der beiden Werte zeigt, dass sie ungleich sind.
using System; public class Example9 { public static void Run() { double value1 = 1 / 3.0; float sValue2 = 1 / 3.0f; double value2 = (double)sValue2; Console.WriteLine($"{value1:R} = {value2:R}: {value1.Equals(value2)}"); } } // The example displays the following output: // 0.33333333333333331 = 0.3333333432674408: 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 Example10 Public Sub Run() Dim value1 As Double = 1 / 3 Dim sValue2 As Single = 1 / 3 Dim value2 As Double = CDbl(sValue2) Console.WriteLine("{0} = {1}: {2}", value1, value2, value1.Equals(value2)) End Sub End Module ' The example displays the following output: ' 0.33333333333333331 = 0.3333333432674408: FalseUm dieses Problem zu vermeiden, verwenden Sie entweder den Double Datentyp anstelle des Single Datentyps, oder verwenden Sie die Round Methode, damit beide Werte dieselbe Genauigkeit aufweisen.
Darüber hinaus kann das Ergebnis von arithmetischen und Zuweisungsoperationen mit Double Werten aufgrund des Verlusts der Präzision des Double Typs geringfügig von der Plattform abweichen. Beispielsweise kann sich das Ergebnis der Zuweisung eines Literal-Double-Werts in den 32-Bit- und 64-Bit-Versionen von .NET unterscheiden. Im folgenden Beispiel wird dieser Unterschied veranschaulicht, wenn der Literalwert -4,4233060424772E-305 und eine Variable mit dem Wert -4,42330604244772E-305 einer Double Variablen zugewiesen sind. 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);
// The output is:
// Double value from literal: -4.42330604244772E-305
// Double value from variable: -4.42330604244772E-305
// Double value from Parse method: -4.42330604244772E-305
let value = -4.42330604244772E-305
let fromLiteral = -4.42330604244772E-305
let fromVariable = value
let fromParse = Double.Parse "-4.42330604244772E-305"
printfn $"Double value from literal: {fromLiteral,29:R}"
printfn $"Double value from variable: {fromVariable,28:R}"
printfn $"Double value from Parse method: {fromParse,24:R}"
// On 32-bit versions of the .NET Framework, the output is:
// Double value from literal: -4.42330604244772E-305
// Double value from variable: -4.42330604244772E-305
// Double value from Parse method: -4.42330604244772E-305
//
// On other versions of the .NET Framework, the output is:
// Double value from literal: -4.4233060424477198E-305
// Double value from variable: -4.4233060424477198E-305
// Double value from Parse method: -4.42330604244772E-305
Dim value As Double = -4.4233060424477198E-305
Dim fromLiteral As Double = -4.4233060424477198E-305
Dim fromVariable As Double = value
Dim fromParse As Double = Double.Parse("-4.42330604244772E-305")
Console.WriteLine("Double value from literal: {0,29:R}", fromLiteral)
Console.WriteLine("Double value from variable: {0,28:R}", fromVariable)
Console.WriteLine("Double value from Parse method: {0,24:R}", fromParse)
' The output is:
' Double value from literal: -4.42330604244772E-305
' Double value from variable: -4.42330604244772E-305
' Double value from Parse method: -4.42330604244772E-305
Testen auf Gleichheit
Um gleich zu sein, müssen zwei Double Werte identische Werte darstellen. Aufgrund von Unterschieden bei der Genauigkeit zwischen Werten oder aufgrund eines Genauigkeitsverlusts durch einen oder beide Werte ergeben sich Gleitkommawerte, die voraussichtlich identisch sind, aufgrund von Unterschieden in ihren am wenigsten signifikanten Ziffern ungleich. Daher ergeben Aufrufe der Equals Methode, um zu bestimmen, ob zwei Werte gleich sind, oder Aufrufe der CompareTo Methode, um die Beziehung zwischen zwei Double Werten zu bestimmen, häufig unerwartete Ergebnisse. Dies zeigt sich im folgenden Beispiel, in dem zwei scheinbar gleiche Double Werte ungleich sind, da der erste eine Genauigkeit von 15 Stellen hat, wohingegen der zweite eine Genauigkeit von 17 Stellen hat.
using System;
public class Example
{
public static void Main()
{
double value1 = .333333333333333;
double value2 = 1.0/3;
Console.WriteLine($"{value1} = {value2}: {value1.Equals(value2)}");
}
}
// The example displays the following output:
// 0.333333333333333 = 0.33333333333333331: False
open System
let value1 = 0.333333333333333
let value2 = 1. / 3.
printfn $"{value1:R} = {value2:R}: {value1.Equals value2}"
// The example displays the following output:
// 0.333333333333333 = 0.33333333333333331: False
Module Example1
Public Sub Run()
Dim value1 As Double = 0.333333333333333
Dim value2 As Double = 1 / 3
Console.WriteLine("{0} = {1}: {2}", value1, value2, value1.Equals(value2))
End Sub
End Module
' The example displays the following output:
' 0.333333333333333 = 0.33333333333333331: False
In Fällen, in denen ein Genauigkeitsverlust das Ergebnis eines Vergleichs wahrscheinlich beeinträchtigt, können Sie eine der folgenden Alternativen zum Aufrufen der Equals- oder CompareTo-Methode nutzen:
Rufen Sie die Math.Round Methode auf, um sicherzustellen, dass beide Werte dieselbe Genauigkeit aufweisen. Im folgenden Beispiel wird ein vorheriges Beispiel so geändert, dass dieser Ansatz verwendet wird, sodass zwei Bruchwerte gleichwertig sind.
double value1 = .333333333333333; double value2 = 1.0 / 3; int precision = 7; value1 = Math.Round(value1, precision); value2 = Math.Round(value2, precision); Console.WriteLine($"{value1} = {value2}: {value1.Equals(value2)}"); // The example displays the following output: // 0.3333333 = 0.3333333: 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 Example3 Public Sub Run() Dim value1 As Double = 0.333333333333333 Dim value2 As Double = 1 / 3 Dim precision As Integer = 7 value1 = Math.Round(value1, precision) value2 = Math.Round(value2, precision) Console.WriteLine("{0} = {1}: {2}", value1, value2, value1.Equals(value2)) End Sub End Module ' The example displays the following output: ' 0.3333333 = 0.3333333: TrueDas Problem der Genauigkeit gilt weiterhin für das Runden von Mittelpunktswerten. Weitere Informationen finden Sie in der Math.Round(Double, Int32, MidpointRounding) Methode.
Testen Sie auf ungefähre Gleichheit, statt auf exakte Gleichheit. Dies erfordert, dass Sie entweder einen absoluten Betrag definieren, um den sich die beiden Werte unterscheiden können, aber dennoch gleich sind oder dass Sie einen relativen Betrag definieren, um den der kleinere Wert vom größeren Wert abweichen kann.
Warning
Double.Epsilon wird manchmal als absolutes Maß für den Abstand zwischen zwei Double Werten beim Testen auf Gleichheit verwendet. Double.Epsilon misst jedoch den kleinsten möglichen Wert, der zu einem Double addiert oder von diesem subtrahiert werden kann, dessen Wert Null ist. Für die meisten positiven und negativen Double Werte ist der Wert Double.Epsilon zu klein, um erkannt zu werden. Aus diesem Grund wird die Verwendung in Tests für Gleichheit nicht empfohlen, mit Ausnahme von Werten, die null sind.
Im folgenden Beispiel wird der letztere Ansatz verwendet, um eine
IsApproximatelyEqualMethode zu definieren, die den relativen Unterschied zwischen zwei Werten testet. Die Methode dividiert durchMath.Max(value1, value2), sodass der Vergleich relativ zum größeren (nach Betrag) der beiden Werte ist, wodurch das Ergebnis in der korrekten Größenordnung platziert wird. WennMath.MaxNull zurückgegeben wird (was geschieht, wenn ein Wert null ist und der andere negativ ist), greift die Methode aufMath.Min(value1, value2)zurück, um den ungleich null Werts als Divisor zu verwenden. Sie kontrastiert auch das Ergebnis von Aufrufen derIsApproximatelyEqualMethode und der Equals(Double) Methode.using System; public class Example3 { public static void Main() { double one1 = .1 * 10; double one2 = 0; for (int ctr = 1; ctr <= 10; ctr++) one2 += .1; Console.WriteLine($"{one1} = {one2}: {one1.Equals(one2)}"); Console.WriteLine($"{one1} is approximately equal to {one2}: {IsApproximatelyEqual(one1, one2, .000000001)}"); } static bool IsApproximatelyEqual(double value1, double value2, double epsilon) { // If they are equal anyway, just return True. if (value1.Equals(value2)) return true; // Handle NaN, Infinity. if (Double.IsInfinity(value1) | Double.IsNaN(value1)) return value1.Equals(value2); else if (Double.IsInfinity(value2) | Double.IsNaN(value2)) return value1.Equals(value2); // Handle zero to avoid division by zero double divisor = Math.Max(value1, value2); if (divisor.Equals(0)) divisor = Math.Min(value1, value2); return Math.Abs((value1 - value2) / divisor) <= epsilon; } } // The example displays the following output: // 1 = 0.99999999999999989: False // 1 is approximately equal to 0.99999999999999989: 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 Example4 Public Sub Run() Dim one1 As Double = 0.1 * 10 Dim one2 As Double = 0 For ctr As Integer = 1 To 10 one2 += 0.1 Next Console.WriteLine("{0} = {1}: {2}", one1, one2, one1.Equals(one2)) Console.WriteLine("{0} is approximately equal to {1}: {2}", one1, one2, IsApproximatelyEqual(one1, one2, 0.000000001)) End Sub Function IsApproximatelyEqual(value1 As Double, value2 As Double, epsilon As Double) As Boolean ' If they are equal anyway, just return True. If value1.Equals(value2) Then Return True ' Handle NaN, Infinity. If Double.IsInfinity(value1) Or Double.IsNaN(value1) Then Return value1.Equals(value2) ElseIf Double.IsInfinity(value2) Or Double.IsNaN(value2) Then Return value1.Equals(value2) End If ' Handle zero to avoid division by zero Dim divisor As Double = Math.Max(value1, value2) If divisor.Equals(0) Then divisor = Math.Min(value1, value2) End If Return Math.Abs((value1 - value2) / divisor) <= epsilon End Function End Module ' The example displays the following output: ' 1 = 0.99999999999999989: False ' 1 is approximately equal to 0.99999999999999989: True
Fließkommawerte und Ausnahmen
Im Gegensatz zu Vorgängen mit integralen Typen, die eine DivideByZeroException Division durch Null oder einen OverflowException Überlauf in einem überprüften Kontext auslösen, lösen Vorgänge mit Gleitkommawerten keine Ausnahmen aus. Stattdessen ist das Ergebnis einer Gleitkommaoperation in Ausnahmefällen null, Plusunendlichkeit, Minusunendlichkeit oder NaN (nicht eine Zahl):
Wenn das Ergebnis eines Gleitkommavorgangs für das Zielformat zu klein ist, ist das Ergebnis null. Dies kann auftreten, wenn zwei sehr kleine Zahlen multipliziert werden, wie im folgenden Beispiel gezeigt.
using System; public class Example6 { public static void Main() { Double value1 = 1.1632875981534209e-225; Double value2 = 9.1642346778e-175; Double result = value1 * value2; Console.WriteLine($"{value1} * {value2} = {result}"); Console.WriteLine($"{result} = 0: {result.Equals(0.0)}"); } } // The example displays the following output: // 1.16328759815342E-225 * 9.1642346778E-175 = 0 // 0 = 0: 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 Example7 Public Sub Run() Dim value1 As Double = 1.1632875981534209E-225 Dim value2 As Double = 9.1642346778E-175 Dim result As Double = value1 * value2 Console.WriteLine("{0} * {1} = {2}", value1, value2, result) Console.WriteLine("{0} = 0: {1}", result, result.Equals(0.0)) End Sub End Module ' The example displays the following output: ' 1.16328759815342E-225 * 9.1642346778E-175 = 0 ' 0 = 0: TrueWenn die Größe des Ergebnisses eines Gleitkommavorgangs den Bereich des Zielformats überschreitet, ist PositiveInfinity das Ergebnis des Vorgangs oder NegativeInfinity, entsprechend dem Vorzeichen des Ergebnisses. Das Ergebnis eines Vorgangs, der überläuft Double.MaxValue, ist PositiveInfinity und das Ergebnis eines Vorgangs, der überläuft Double.MinValue, ist NegativeInfinity, wie das folgende Beispiel zeigt.
using System; public class Example7 { public static void Main() { Double value1 = 4.565e153; Double value2 = 6.9375e172; Double result = value1 * value2; Console.WriteLine($"PositiveInfinity: {Double.IsPositiveInfinity(result)}"); Console.WriteLine($"NegativeInfinity: {Double.IsNegativeInfinity(result)}{Environment.NewLine}"); value1 = -value1; result = value1 * value2; Console.WriteLine($"PositiveInfinity: {Double.IsPositiveInfinity(result)}"); Console.WriteLine($"NegativeInfinity: {Double.IsNegativeInfinity(result)}"); } } // The example displays the following output: // PositiveInfinity: True // NegativeInfinity: False // // PositiveInfinity: False // NegativeInfinity: 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 Example8 Public Sub Run() Dim value1 As Double = 4.565E+153 Dim value2 As Double = 6.9375E+172 Dim result As Double = value1 * value2 Console.WriteLine("PositiveInfinity: {0}", Double.IsPositiveInfinity(result)) Console.WriteLine("NegativeInfinity: {0}", Double.IsNegativeInfinity(result)) Console.WriteLine() value1 = -value1 result = value1 * value2 Console.WriteLine("PositiveInfinity: {0}", Double.IsPositiveInfinity(result)) Console.WriteLine("NegativeInfinity: {0}", Double.IsNegativeInfinity(result)) End Sub End Module ' The example displays the following output: ' PositiveInfinity: True ' NegativeInfinity: False ' ' PositiveInfinity: False ' NegativeInfinity: 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, ist das Ergebnis des Vorgangs NaN. Beispiel: NaN-Ergebnisse aus den folgenden Vorgängen:
Abteilung durch Null mit einem Dividenden Null. Beachten Sie, dass andere Fälle der Division durch Null entweder PositiveInfinity oder NegativeInfinity als Ergebnis ausgeben.
Jede Gleitkommaoperation mit einer ungültigen Eingabe. Rufen Sie beispielsweise die Math.Sqrt Methode mit einem negativen Wert auf, gibt sie NaN zurück, ebenso wie die Math.Acos Methode, wenn diese mit einem Wert größer als eins oder kleiner als minus eins aufgerufen wird.
Jeder Vorgang mit einem Argument, dessen Wert lautet Double.NaN.
Typkonvertierungen
Die Double Struktur definiert keine expliziten oder impliziten Konvertierungsoperatoren. Stattdessen werden Konvertierungen vom Compiler implementiert.
Die Konvertierung des Wertes eines beliebigen primitiven numerischen Typs in einen Double ist eine erweiternde Konvertierung und erfordert daher keinen expliziten Cast-Operator oder Aufruf einer Konvertierungsmethode, es sei denn, ein Compiler verlangt dies ausdrücklich. Beispielsweise erfordert der C#-Compiler einen Umwandlungsoperator für Konvertierungen von Decimal in Double, während der Visual Basic-Compiler nicht. Im folgenden Beispiel wird der Minimal- oder Maximalwert anderer primitiver numerischer Datentypen in ein Double umgewandelt.
dynamic[] values = { Byte.MinValue, Byte.MaxValue, Decimal.MinValue,
Decimal.MaxValue, Int16.MinValue, Int16.MaxValue,
Int32.MinValue, Int32.MaxValue, Int64.MinValue,
Int64.MaxValue, SByte.MinValue, SByte.MaxValue,
Single.MinValue, Single.MaxValue, UInt16.MinValue,
UInt16.MaxValue, UInt32.MinValue, UInt32.MaxValue,
UInt64.MinValue, UInt64.MaxValue };
double dblValue;
foreach (dynamic value in values)
{
if (value.GetType() == typeof(decimal))
dblValue = (double)value;
else
dblValue = value;
Console.WriteLine($"{value} ({value.GetType().Name}) --> " +
$"{dblValue:R} ({dblValue.GetType().Name})");
}
// The example displays the following output:
// 0 (Byte) --> 0 (Double)
// 255 (Byte) --> 255 (Double)
// -79228162514264337593543950335 (Decimal) --> -7.9228162514264338E+28 (Double)
// 79228162514264337593543950335 (Decimal) --> 7.9228162514264338E+28 (Double)
// -32768 (Int16) --> -32768 (Double)
// 32767 (Int16) --> 32767 (Double)
// -2147483648 (Int32) --> -2147483648 (Double)
// 2147483647 (Int32) --> 2147483647 (Double)
// -9223372036854775808 (Int64) --> -9.2233720368547758E+18 (Double)
// 9223372036854775807 (Int64) --> 9.2233720368547758E+18 (Double)
// -128 (SByte) --> -128 (Double)
// 127 (SByte) --> 127 (Double)
// -3.402823E+38 (Single) --> -3.4028234663852886E+38 (Double)
// 3.402823E+38 (Single) --> 3.4028234663852886E+38 (Double)
// 0 (UInt16) --> 0 (Double)
// 65535 (UInt16) --> 65535 (Double)
// 0 (UInt32) --> 0 (Double)
// 4294967295 (UInt32) --> 4294967295 (Double)
// 0 (UInt64) --> 0 (Double)
// 18446744073709551615 (UInt64) --> 1.8446744073709552E+19 (Double)
open System
let values: obj[] =
[| Byte.MinValue; Byte.MaxValue; Decimal.MinValue
Decimal.MaxValue; Int16.MinValue; Int16.MaxValue
Int32.MinValue; Int32.MaxValue; Int64.MinValue
Int64.MaxValue; SByte.MinValue; SByte.MaxValue
Single.MinValue; Single.MaxValue; UInt16.MinValue
UInt16.MaxValue; UInt32.MinValue, UInt32.MaxValue
UInt64.MinValue; UInt64.MaxValue |]
for value in values do
let dblValue = value :?> double
printfn $"{value} ({value.GetType().Name}) --> {dblValue:R} ({dblValue.GetType().Name})"
// The example displays the following output:
// 0 (Byte) --> 0 (Double)
// 255 (Byte) --> 255 (Double)
// -79228162514264337593543950335 (Decimal) --> -7.9228162514264338E+28 (Double)
// 79228162514264337593543950335 (Decimal) --> 7.9228162514264338E+28 (Double)
// -32768 (Int16) --> -32768 (Double)
// 32767 (Int16) --> 32767 (Double)
// -2147483648 (Int32) --> -2147483648 (Double)
// 2147483647 (Int32) --> 2147483647 (Double)
// -9223372036854775808 (Int64) --> -9.2233720368547758E+18 (Double)
// 9223372036854775807 (Int64) --> 9.2233720368547758E+18 (Double)
// -128 (SByte) --> -128 (Double)
// 127 (SByte) --> 127 (Double)
// -3.402823E+38 (Single) --> -3.4028234663852886E+38 (Double)
// 3.402823E+38 (Single) --> 3.4028234663852886E+38 (Double)
// 0 (UInt16) --> 0 (Double)
// 65535 (UInt16) --> 65535 (Double)
// 0 (UInt32) --> 0 (Double)
// 4294967295 (UInt32) --> 4294967295 (Double)
// 0 (UInt64) --> 0 (Double)
// 18446744073709551615 (UInt64) --> 1.8446744073709552E+19 (Double)
Module Example5
Public Sub Run()
Dim values() As Object = {Byte.MinValue, Byte.MaxValue, Decimal.MinValue,
Decimal.MaxValue, Int16.MinValue, Int16.MaxValue,
Int32.MinValue, Int32.MaxValue, Int64.MinValue,
Int64.MaxValue, SByte.MinValue, SByte.MaxValue,
Single.MinValue, Single.MaxValue, UInt16.MinValue,
UInt16.MaxValue, UInt32.MinValue, UInt32.MaxValue,
UInt64.MinValue, UInt64.MaxValue}
Dim dblValue As Double
For Each value In values
dblValue = value
Console.WriteLine("{0} ({1}) --> {2:R} ({3})",
value, value.GetType().Name,
dblValue, dblValue.GetType().Name)
Next
End Sub
End Module
' The example displays the following output:
' 0 (Byte) --> 0 (Double)
' 255 (Byte) --> 255 (Double)
' -79228162514264337593543950335 (Decimal) --> -7.9228162514264338E+28 (Double)
' 79228162514264337593543950335 (Decimal) --> 7.9228162514264338E+28 (Double)
' -32768 (Int16) --> -32768 (Double)
' 32767 (Int16) --> 32767 (Double)
' -2147483648 (Int32) --> -2147483648 (Double)
' 2147483647 (Int32) --> 2147483647 (Double)
' -9223372036854775808 (Int64) --> -9.2233720368547758E+18 (Double)
' 9223372036854775807 (Int64) --> 9.2233720368547758E+18 (Double)
' -128 (SByte) --> -128 (Double)
' 127 (SByte) --> 127 (Double)
' -3.402823E+38 (Single) --> -3.4028234663852886E+38 (Double)
' 3.402823E+38 (Single) --> 3.4028234663852886E+38 (Double)
' 0 (UInt16) --> 0 (Double)
' 65535 (UInt16) --> 65535 (Double)
' 0 (UInt32) --> 0 (Double)
' 4294967295 (UInt32) --> 4294967295 (Double)
' 0 (UInt64) --> 0 (Double)
' 18446744073709551615 (UInt64) --> 1.8446744073709552E+19 (Double)
Darüber hinaus werden die Single Werte Single.NaN, Single.PositiveInfinity, und Single.NegativeInfinity konvertiert in Double.NaN, Double.PositiveInfinity, bzw Double.NegativeInfinity. . .
Beachten Sie, dass die Konvertierung des Werts einiger numerischer Typen in einen Double Wert zu einem Genauigkeitsverlust führen kann. Wie das Beispiel zeigt, ist ein Genauigkeitsverlust möglich beim Konvertieren von Decimal-Werten, Int64- und UInt64-Werten zu Double-Werten.
Die Konvertierung eines Double-Werts in einen Wert eines anderen primitiven numerischen Datentyps ist eine schmale Konvertierung und erfordert einen Umwandlungsoperator (in C#), eine Konvertierungsmethode (in Visual Basic) oder einen Aufruf einer Convert-Methode. Werte, die sich außerhalb des Bereichs des Zieldatentyps befinden, die durch die Eigenschaften MinValue und MaxValue des Zieltyps definiert werden, verhalten sich wie in der folgenden Tabelle dargestellt.
| Zieltyp | Result |
|---|---|
| Beliebiger integraler Typ | Eine OverflowException Ausnahme, wenn die Konvertierung in einem überprüften Kontext auftritt. Wenn die Konvertierung in einem ungeprüften Kontext erfolgt (die Vorgabe in C#), ist die Konvertierung erfolgreich, aber der Wert läuft über. |
| Decimal | Eine OverflowException Ausnahme. |
| Single |
Single.NegativeInfinity für negative Werte. Single.PositiveInfinity für positive Werte. |
Darüber hinaus lösen Double.NaN, Double.PositiveInfinity und Double.NegativeInfinity bei Konversionen in Ganzzahlen in einem geprüften Kontext ein OverflowException aus, aber diese Werte laufen bei der Konversion in Ganzzahlen in einem ungeprüften Kontext über. Bei Konvertierungen nach Decimalwerfen sie immer ein OverflowException. Für Konvertierungen zu Single werden sie in Single.NaN, Single.PositiveInfinity und Single.NegativeInfinity konvertiert, jeweils entsprechend.
Ein Genauigkeitsverlust kann dazu führen, dass ein Double Wert in einen anderen numerischen Typ konvertiert wird. Bei der Konvertierung in einen der integralen Typen, wie die Ausgabe aus dem Beispiel zeigt, geht die Bruchkomponente verloren, wenn der Double Wert entweder gerundet wird (wie in Visual Basic) oder abgeschnitten wird (wie in C#). Der Decimal-Wert hat möglicherweise keine genaue Darstellung im Zieldatentyp für Konvertierungen in Single- und Double-Werte.
Im folgenden Beispiel wird eine Anzahl von Double Werten in mehrere andere numerische Typen konvertiert. Die Konvertierungen erfolgen in einem eingecheckten Kontext in Visual Basic (Standard), in C# (aufgrund der checked Schlüsselwort) und in F# (aufgrund des moduls Checked). Die Ausgabe aus dem Beispiel zeigt das Ergebnis für Konvertierungen sowohl in einem überprüften als auch in einem deaktivierten Kontext. Sie können Konvertierungen in einem unchecked-Kontext in Visual Basic ausführen, indem Sie mit der /removeintchecks+-Compileroption kompilieren, in C# indem Sie die checked-Anweisung auskommentieren und in F#, indem Sie die open Checked-Anweisung auskommentieren.
using System;
public class Example5
{
public static void Main()
{
Double[] values = { Double.MinValue, -67890.1234, -12345.6789,
12345.6789, 67890.1234, Double.MaxValue,
Double.NaN, Double.PositiveInfinity,
Double.NegativeInfinity };
checked
{
foreach (var value in values)
{
try
{
Int64 lValue = (long)value;
Console.WriteLine($"{value} ({value.GetType().Name}) --> {lValue} (0x{lValue:X16}) ({lValue.GetType().Name})");
}
catch (OverflowException)
{
Console.WriteLine($"Unable to convert {value} to Int64.");
}
try
{
UInt64 ulValue = (ulong)value;
Console.WriteLine($"{value} ({value.GetType().Name}) --> {ulValue} (0x{ulValue:X16}) ({ulValue.GetType().Name})");
}
catch (OverflowException)
{
Console.WriteLine($"Unable to convert {value} to UInt64.");
}
try
{
Decimal dValue = (decimal)value;
Console.WriteLine($"{value} ({value.GetType().Name}) --> {dValue} ({dValue.GetType().Name})");
}
catch (OverflowException)
{
Console.WriteLine($"Unable to convert {value} to Decimal.");
}
try
{
Single sValue = (float)value;
Console.WriteLine($"{value} ({value.GetType().Name}) --> {sValue} ({sValue.GetType().Name})");
}
catch (OverflowException)
{
Console.WriteLine($"Unable to convert {value} to Single.");
}
Console.WriteLine();
}
}
}
}
// The example displays the following output for conversions performed
// in a checked context:
// Unable to convert -1.79769313486232E+308 to Int64.
// Unable to convert -1.79769313486232E+308 to UInt64.
// Unable to convert -1.79769313486232E+308 to Decimal.
// -1.79769313486232E+308 (Double) --> -Infinity (Single)
//
// -67890.1234 (Double) --> -67890 (0xFFFFFFFFFFFEF6CE) (Int64)
// Unable to convert -67890.1234 to UInt64.
// -67890.1234 (Double) --> -67890.1234 (Decimal)
// -67890.1234 (Double) --> -67890.13 (Single)
//
// -12345.6789 (Double) --> -12345 (0xFFFFFFFFFFFFCFC7) (Int64)
// Unable to convert -12345.6789 to UInt64.
// -12345.6789 (Double) --> -12345.6789 (Decimal)
// -12345.6789 (Double) --> -12345.68 (Single)
//
// 12345.6789 (Double) --> 12345 (0x0000000000003039) (Int64)
// 12345.6789 (Double) --> 12345 (0x0000000000003039) (UInt64)
// 12345.6789 (Double) --> 12345.6789 (Decimal)
// 12345.6789 (Double) --> 12345.68 (Single)
//
// 67890.1234 (Double) --> 67890 (0x0000000000010932) (Int64)
// 67890.1234 (Double) --> 67890 (0x0000000000010932) (UInt64)
// 67890.1234 (Double) --> 67890.1234 (Decimal)
// 67890.1234 (Double) --> 67890.13 (Single)
//
// Unable to convert 1.79769313486232E+308 to Int64.
// Unable to convert 1.79769313486232E+308 to UInt64.
// Unable to convert 1.79769313486232E+308 to Decimal.
// 1.79769313486232E+308 (Double) --> Infinity (Single)
//
// Unable to convert NaN to Int64.
// Unable to convert NaN to UInt64.
// Unable to convert NaN to Decimal.
// NaN (Double) --> NaN (Single)
//
// Unable to convert Infinity to Int64.
// Unable to convert Infinity to UInt64.
// Unable to convert Infinity to Decimal.
// Infinity (Double) --> Infinity (Single)
//
// Unable to convert -Infinity to Int64.
// Unable to convert -Infinity to UInt64.
// Unable to convert -Infinity to Decimal.
// -Infinity (Double) --> -Infinity (Single)
// The example displays the following output for conversions performed
// in an unchecked context:
// -1.79769313486232E+308 (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
// -1.79769313486232E+308 (Double) --> 9223372036854775808 (0x8000000000000000) (UInt64)
// Unable to convert -1.79769313486232E+308 to Decimal.
// -1.79769313486232E+308 (Double) --> -Infinity (Single)
//
// -67890.1234 (Double) --> -67890 (0xFFFFFFFFFFFEF6CE) (Int64)
// -67890.1234 (Double) --> 18446744073709483726 (0xFFFFFFFFFFFEF6CE) (UInt64)
// -67890.1234 (Double) --> -67890.1234 (Decimal)
// -67890.1234 (Double) --> -67890.13 (Single)
//
// -12345.6789 (Double) --> -12345 (0xFFFFFFFFFFFFCFC7) (Int64)
// -12345.6789 (Double) --> 18446744073709539271 (0xFFFFFFFFFFFFCFC7) (UInt64)
// -12345.6789 (Double) --> -12345.6789 (Decimal)
// -12345.6789 (Double) --> -12345.68 (Single)
//
// 12345.6789 (Double) --> 12345 (0x0000000000003039) (Int64)
// 12345.6789 (Double) --> 12345 (0x0000000000003039) (UInt64)
// 12345.6789 (Double) --> 12345.6789 (Decimal)
// 12345.6789 (Double) --> 12345.68 (Single)
//
// 67890.1234 (Double) --> 67890 (0x0000000000010932) (Int64)
// 67890.1234 (Double) --> 67890 (0x0000000000010932) (UInt64)
// 67890.1234 (Double) --> 67890.1234 (Decimal)
// 67890.1234 (Double) --> 67890.13 (Single)
//
// 1.79769313486232E+308 (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
// 1.79769313486232E+308 (Double) --> 0 (0x0000000000000000) (UInt64)
// Unable to convert 1.79769313486232E+308 to Decimal.
// 1.79769313486232E+308 (Double) --> Infinity (Single)
//
// NaN (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
// NaN (Double) --> 0 (0x0000000000000000) (UInt64)
// Unable to convert NaN to Decimal.
// NaN (Double) --> NaN (Single)
//
// Infinity (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
// Infinity (Double) --> 0 (0x0000000000000000) (UInt64)
// Unable to convert Infinity to Decimal.
// Infinity (Double) --> Infinity (Single)
//
// -Infinity (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
// -Infinity (Double) --> 9223372036854775808 (0x8000000000000000) (UInt64)
// Unable to convert -Infinity to Decimal.
// -Infinity (Double) --> -Infinity (Single)
open System
open Checked
let values =
[| Double.MinValue; -67890.1234; -12345.6789
12345.6789; 67890.1234; Double.MaxValue
Double.NaN; Double.PositiveInfinity;
Double.NegativeInfinity |]
for value in values do
try
let lValue = int64 value
printfn $"{value} ({value.GetType().Name}) --> {lValue} (0x{lValue:X16}) ({lValue.GetType().Name})"
with :? OverflowException ->
printfn $"Unable to convert {value} to Int64."
try
let ulValue = uint64 value
printfn $"{value} ({value.GetType().Name}) --> {ulValue} (0x{ulValue:X16}) ({ulValue.GetType().Name})"
with :? OverflowException ->
printfn $"Unable to convert {value} to UInt64."
try
let dValue = decimal value
printfn $"{value} ({value.GetType().Name}) --> {dValue} ({dValue.GetType().Name})"
with :? OverflowException ->
printfn $"Unable to convert {value} to Decimal."
try
let sValue = float32 value
printfn $"{value} ({value.GetType().Name}) --> {sValue} ({sValue.GetType().Name})"
with :? OverflowException ->
printfn $"Unable to convert {value} to Single."
printfn ""
// The example displays the following output for conversions performed
// in a checked context:
// Unable to convert -1.79769313486232E+308 to Int64.
// Unable to convert -1.79769313486232E+308 to UInt64.
// Unable to convert -1.79769313486232E+308 to Decimal.
// -1.79769313486232E+308 (Double) --> -Infinity (Single)
//
// -67890.1234 (Double) --> -67890 (0xFFFFFFFFFFFEF6CE) (Int64)
// Unable to convert -67890.1234 to UInt64.
// -67890.1234 (Double) --> -67890.1234 (Decimal)
// -67890.1234 (Double) --> -67890.13 (Single)
//
// -12345.6789 (Double) --> -12345 (0xFFFFFFFFFFFFCFC7) (Int64)
// Unable to convert -12345.6789 to UInt64.
// -12345.6789 (Double) --> -12345.6789 (Decimal)
// -12345.6789 (Double) --> -12345.68 (Single)
//
// 12345.6789 (Double) --> 12345 (0x0000000000003039) (Int64)
// 12345.6789 (Double) --> 12345 (0x0000000000003039) (UInt64)
// 12345.6789 (Double) --> 12345.6789 (Decimal)
// 12345.6789 (Double) --> 12345.68 (Single)
//
// 67890.1234 (Double) --> 67890 (0x0000000000010932) (Int64)
// 67890.1234 (Double) --> 67890 (0x0000000000010932) (UInt64)
// 67890.1234 (Double) --> 67890.1234 (Decimal)
// 67890.1234 (Double) --> 67890.13 (Single)
//
// Unable to convert 1.79769313486232E+308 to Int64.
// Unable to convert 1.79769313486232E+308 to UInt64.
// Unable to convert 1.79769313486232E+308 to Decimal.
// 1.79769313486232E+308 (Double) --> Infinity (Single)
//
// Unable to convert NaN to Int64.
// Unable to convert NaN to UInt64.
// Unable to convert NaN to Decimal.
// NaN (Double) --> NaN (Single)
//
// Unable to convert Infinity to Int64.
// Unable to convert Infinity to UInt64.
// Unable to convert Infinity to Decimal.
// Infinity (Double) --> Infinity (Single)
//
// Unable to convert -Infinity to Int64.
// Unable to convert -Infinity to UInt64.
// Unable to convert -Infinity to Decimal.
// -Infinity (Double) --> -Infinity (Single)
// The example displays the following output for conversions performed
// in an unchecked context:
// -1.79769313486232E+308 (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
// -1.79769313486232E+308 (Double) --> 9223372036854775808 (0x8000000000000000) (UInt64)
// Unable to convert -1.79769313486232E+308 to Decimal.
// -1.79769313486232E+308 (Double) --> -Infinity (Single)
//
// -67890.1234 (Double) --> -67890 (0xFFFFFFFFFFFEF6CE) (Int64)
// -67890.1234 (Double) --> 18446744073709483726 (0xFFFFFFFFFFFEF6CE) (UInt64)
// -67890.1234 (Double) --> -67890.1234 (Decimal)
// -67890.1234 (Double) --> -67890.13 (Single)
//
// -12345.6789 (Double) --> -12345 (0xFFFFFFFFFFFFCFC7) (Int64)
// -12345.6789 (Double) --> 18446744073709539271 (0xFFFFFFFFFFFFCFC7) (UInt64)
// -12345.6789 (Double) --> -12345.6789 (Decimal)
// -12345.6789 (Double) --> -12345.68 (Single)
//
// 12345.6789 (Double) --> 12345 (0x0000000000003039) (Int64)
// 12345.6789 (Double) --> 12345 (0x0000000000003039) (UInt64)
// 12345.6789 (Double) --> 12345.6789 (Decimal)
// 12345.6789 (Double) --> 12345.68 (Single)
//
// 67890.1234 (Double) --> 67890 (0x0000000000010932) (Int64)
// 67890.1234 (Double) --> 67890 (0x0000000000010932) (UInt64)
// 67890.1234 (Double) --> 67890.1234 (Decimal)
// 67890.1234 (Double) --> 67890.13 (Single)
//
// 1.79769313486232E+308 (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
// 1.79769313486232E+308 (Double) --> 0 (0x0000000000000000) (UInt64)
// Unable to convert 1.79769313486232E+308 to Decimal.
// 1.79769313486232E+308 (Double) --> Infinity (Single)
//
// NaN (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
// NaN (Double) --> 0 (0x0000000000000000) (UInt64)
// Unable to convert NaN to Decimal.
// NaN (Double) --> NaN (Single)
//
// Infinity (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
// Infinity (Double) --> 0 (0x0000000000000000) (UInt64)
// Unable to convert Infinity to Decimal.
// Infinity (Double) --> Infinity (Single)
//
// -Infinity (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
// -Infinity (Double) --> 9223372036854775808 (0x8000000000000000) (UInt64)
// Unable to convert -Infinity to Decimal.
// -Infinity (Double) --> -Infinity (Single)
Module Example6
Public Sub Run()
Dim values() As Double = {Double.MinValue, -67890.1234, -12345.6789,
12345.6789, 67890.1234, Double.MaxValue,
Double.NaN, Double.PositiveInfinity,
Double.NegativeInfinity}
For Each value In values
Try
Dim lValue As Int64 = CLng(value)
Console.WriteLine("{0} ({1}) --> {2} (0x{2:X16}) ({3})",
value, value.GetType().Name,
lValue, lValue.GetType().Name)
Catch e As OverflowException
Console.WriteLine("Unable to convert {0} to Int64.", value)
End Try
Try
Dim ulValue As UInt64 = CULng(value)
Console.WriteLine("{0} ({1}) --> {2} (0x{2:X16}) ({3})",
value, value.GetType().Name,
ulValue, ulValue.GetType().Name)
Catch e As OverflowException
Console.WriteLine("Unable to convert {0} to UInt64.", value)
End Try
Try
Dim dValue As Decimal = CDec(value)
Console.WriteLine("{0} ({1}) --> {2} ({3})",
value, value.GetType().Name,
dValue, dValue.GetType().Name)
Catch e As OverflowException
Console.WriteLine("Unable to convert {0} to Decimal.", value)
End Try
Try
Dim sValue As Single = CSng(value)
Console.WriteLine("{0} ({1}) --> {2} ({3})",
value, value.GetType().Name,
sValue, sValue.GetType().Name)
Catch e As OverflowException
Console.WriteLine("Unable to convert {0} to Single.", value)
End Try
Console.WriteLine()
Next
End Sub
End Module
' The example displays the following output for conversions performed
' in a checked context:
' Unable to convert -1.79769313486232E+308 to Int64.
' Unable to convert -1.79769313486232E+308 to UInt64.
' Unable to convert -1.79769313486232E+308 to Decimal.
' -1.79769313486232E+308 (Double) --> -Infinity (Single)
'
' -67890.1234 (Double) --> -67890 (0xFFFFFFFFFFFEF6CE) (Int64)
' Unable to convert -67890.1234 to UInt64.
' -67890.1234 (Double) --> -67890.1234 (Decimal)
' -67890.1234 (Double) --> -67890.13 (Single)
'
' -12345.6789 (Double) --> -12346 (0xFFFFFFFFFFFFCFC6) (Int64)
' Unable to convert -12345.6789 to UInt64.
' -12345.6789 (Double) --> -12345.6789 (Decimal)
' -12345.6789 (Double) --> -12345.68 (Single)
'
' 12345.6789 (Double) --> 12346 (0x000000000000303A) (Int64)
' 12345.6789 (Double) --> 12346 (0x000000000000303A) (UInt64)
' 12345.6789 (Double) --> 12345.6789 (Decimal)
' 12345.6789 (Double) --> 12345.68 (Single)
'
' 67890.1234 (Double) --> 67890 (0x0000000000010932) (Int64)
' 67890.1234 (Double) --> 67890 (0x0000000000010932) (UInt64)
' 67890.1234 (Double) --> 67890.1234 (Decimal)
' 67890.1234 (Double) --> 67890.13 (Single)
'
' Unable to convert 1.79769313486232E+308 to Int64.
' Unable to convert 1.79769313486232E+308 to UInt64.
' Unable to convert 1.79769313486232E+308 to Decimal.
' 1.79769313486232E+308 (Double) --> Infinity (Single)
'
' Unable to convert NaN to Int64.
' Unable to convert NaN to UInt64.
' Unable to convert NaN to Decimal.
' NaN (Double) --> NaN (Single)
'
' Unable to convert Infinity to Int64.
' Unable to convert Infinity to UInt64.
' Unable to convert Infinity to Decimal.
' Infinity (Double) --> Infinity (Single)
'
' Unable to convert -Infinity to Int64.
' Unable to convert -Infinity to UInt64.
' Unable to convert -Infinity to Decimal.
' -Infinity (Double) --> -Infinity (Single)
' The example displays the following output for conversions performed
' in an unchecked context:
' -1.79769313486232E+308 (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
' -1.79769313486232E+308 (Double) --> 9223372036854775808 (0x8000000000000000) (UInt64)
' Unable to convert -1.79769313486232E+308 to Decimal.
' -1.79769313486232E+308 (Double) --> -Infinity (Single)
'
' -67890.1234 (Double) --> -67890 (0xFFFFFFFFFFFEF6CE) (Int64)
' -67890.1234 (Double) --> 18446744073709483726 (0xFFFFFFFFFFFEF6CE) (UInt64)
' -67890.1234 (Double) --> -67890.1234 (Decimal)
' -67890.1234 (Double) --> -67890.13 (Single)
'
' -12345.6789 (Double) --> -12346 (0xFFFFFFFFFFFFCFC6) (Int64)
' -12345.6789 (Double) --> 18446744073709539270 (0xFFFFFFFFFFFFCFC6) (UInt64)
' -12345.6789 (Double) --> -12345.6789 (Decimal)
' -12345.6789 (Double) --> -12345.68 (Single)
'
' 12345.6789 (Double) --> 12346 (0x000000000000303A) (Int64)
' 12345.6789 (Double) --> 12346 (0x000000000000303A) (UInt64)
' 12345.6789 (Double) --> 12345.6789 (Decimal)
' 12345.6789 (Double) --> 12345.68 (Single)
'
' 67890.1234 (Double) --> 67890 (0x0000000000010932) (Int64)
' 67890.1234 (Double) --> 67890 (0x0000000000010932) (UInt64)
' 67890.1234 (Double) --> 67890.1234 (Decimal)
' 67890.1234 (Double) --> 67890.13 (Single)
'
' 1.79769313486232E+308 (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
' 1.79769313486232E+308 (Double) --> 0 (0x0000000000000000) (UInt64)
' Unable to convert 1.79769313486232E+308 to Decimal.
' 1.79769313486232E+308 (Double) --> Infinity (Single)
'
' NaN (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
' NaN (Double) --> 0 (0x0000000000000000) (UInt64)
' Unable to convert NaN to Decimal.
' NaN (Double) --> NaN (Single)
'
' Infinity (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
' Infinity (Double) --> 0 (0x0000000000000000) (UInt64)
' Unable to convert Infinity to Decimal.
' Infinity (Double) --> Infinity (Single)
'
' -Infinity (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
' -Infinity (Double) --> 9223372036854775808 (0x8000000000000000) (UInt64)
' Unable to convert -Infinity to Decimal.
' -Infinity (Double) --> -Infinity (Single)
Weitere Informationen zur Konvertierung numerischer Typen finden Sie unter Typkonvertierung in .NET und Typkonvertierungstabellen.
Fließkomma-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 zu bestimmen, ob zwei Double Werte gleich sind, oder die CompareTo Methode, um die Beziehung zwischen zwei Werten zu bestimmen.
Die Double Struktur unterstützt auch einen vollständigen Satz von Vergleichsoperatoren. Sie können z. B. auf Gleichheit oder Ungleichheit testen oder ermitteln, ob ein Wert größer oder gleich einem anderen ist. Wenn es sich bei einem der Operanden um einen anderen numerischen Typ als einen Doublehandelt, wird er vor dem Ausführen des Vergleichs in einen Double konvertiert.
Warning
Aufgrund von Genauigkeitsunterschieden können zwei Double Werte, die Sie für gleich halten, ungleich sein, was sich auf das Ergebnis des Vergleichs auswirkt. Informationen zum Vergleichen von zwei Double Werten finden Sie im Abschnitt " Test for equality ".
Sie können auch die IsNaN, IsInfinity, IsPositiveInfinity und IsNegativeInfinity-Methoden aufrufen, um auf diese speziellen Werte zu testen.
Mathematische Vorgänge. Allgemeine arithmetische Vorgänge, z. B. Addition, Subtraktion, Multiplikation und Division, werden von Sprachcompilern und CIL-Anweisungen (Common Intermediate Language) anstelle von Double Methoden implementiert. Wenn einer der Operanden in einem mathematischen Vorgang ein anderer numerischer Typ als ein Doublenumerischer Typ ist, wird er vor dem Ausführen des Vorgangs in einen Double konvertiert. Das Ergebnis des Vorgangs ist auch ein Double Wert.
Andere mathematische Vorgänge können durch Aufrufen von
static(Sharedin Visual Basic)-Methoden in der klasse System.Math ausgeführt werden. Es enthält zusätzliche Methoden, die häufig für Arithmetik (z. B. Math.Abs, Math.Sign und Math.Sqrt), Geometrie (z. B. Math.Cos und Math.Sin) und Analysis (z. B. Math.Log) 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 das Bitmuster in einem Bytearray zurück.
Runden. Rundung wird häufig als Technik verwendet, um die Auswirkungen von Unterschieden zwischen Werten zu verringern, 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 seine Zeichenfolgenrepräsentation konvertieren, indem Sie die ToString Methode aufrufen oder das Merkmal der zusammengesetzten Formatierung verwenden. Informationen dazu, wie Zeichenfolgen die Zeichenfolgendarstellung von Gleitkommawerten steuern, finden Sie unter Standard Numeric Format Strings and Custom Numeric Format Strings.
Analysieren von Zeichenfolgen. Sie können die Zeichenfolgendarstellung eines Gleitkommawerts in einen Double-Wert konvertieren, indem Sie entweder die Parse-Methode oder die TryParse-Methode aufrufen. Wenn der Analysevorgang fehlschlägt, löst die Parse Methode eine Ausnahme aus, während die TryParse Methode zurückgibt
false.Typumwandlung. Die Double Struktur stellt eine explizite Schnittstellenimplementierung für die IConvertible Schnittstelle bereit, die die Konvertierung zwischen zwei standardmäßigen .NET-Datentypen unterstützt. Sprachcompiler unterstützen auch die implizite Konvertierung von Werten aller anderen standardmäßigen numerischen Typen in Double Werte. Die Konvertierung eines Wertes eines beliebigen numerischen Standardtyps in einen Double ist eine erweiternde Konvertierung und erfordert nicht die Verwendung eines Casting-Operators oder einer Konvertierungsmethode,
Die Konvertierung von Int64- und Single-Werten kann jedoch zu einem Genauigkeitsverlust führen. In der folgenden Tabelle sind die Unterschiede in der Genauigkeit für jeden dieser Typen aufgeführt:
Typ Maximale Genauigkeit Interne Präzision Double 15 17 Int64 19 Dezimalziffern 19 Dezimalziffern Single 7 Dezimalziffern 9 Dezimalziffern Das Problem der Genauigkeit betrifft am häufigsten Single-Werte, die in Double-Werte konvertiert werden. Im folgenden Beispiel sind zwei Werte, die durch identische Divisionsoperationen erzeugt werden, ungleich, da einer der Werte ein Gleitkommawert mit einfacher Genauigkeit ist, der in einen Double konvertiert wird.
using System; public class Example13 { public static void Main() { Double value = .1; Double result1 = value * 10; Double result2 = 0; for (int ctr = 1; ctr <= 10; ctr++) result2 += value; Console.WriteLine($".1 * 10: {result1:R}"); Console.WriteLine($".1 Added 10 times: {result2:R}"); } } // The example displays the following output: // .1 * 10: 1 // .1 Added 10 times: 0.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 Example14 Public Sub Run() Dim value As Double = 0.1 Dim result1 As Double = value * 10 Dim result2 As Double For ctr As Integer = 1 To 10 result2 += value Next Console.WriteLine(".1 * 10: {0:R}", result1) Console.WriteLine(".1 Added 10 times: {0:R}", result2) End Sub End Module ' The example displays the following output: ' .1 * 10: 1 ' .1 Added 10 times: 0.99999999999999989
Felder
| Name | Beschreibung |
|---|---|
| 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 Null ist. Dieses Feld ist konstant. |
| MaxValue |
Stellt den größten möglichen Wert eines .Double Dieses Feld ist konstant. |
| MinValue |
Stellt den kleinsten möglichen Wert eines .Double Dieses Feld ist konstant. |
| NaN |
Stellt einen Wert dar, der keine Zahl ( |
| NegativeInfinity |
Stellt negative Unendlichkeit dar. Dieses Feld ist konstant. |
| NegativeZero |
Stellt die Zahl negative Null (-0) dar. |
| Pi |
Stellt das Verhältnis des Umfangs eines Kreises zu seinem Durchmesser dar, der durch die Konstante angegeben wird, π. |
| PositiveInfinity |
Stellt positive Unendlichkeit dar. Dieses Feld ist konstant. |
| Tau |
Stellt die Anzahl der Bogenmaße in einer Drehzahl dar, die durch die Konstante τ angegeben wird. |
Methoden
| Name | Beschreibung |
|---|---|
| Abs(Double) |
Berechnet den absoluten Wert. |
| Acos(Double) |
Berechnet den Arkuskosinus eines Werts. |
| Acosh(Double) |
Berechnet den hyperbolischen Arkuskosinus eines Werts. |
| AcosPi(Double) |
Berechnet den Arkuskosinus eines Werts und dividiert das Ergebnis durch |
| Asin(Double) |
Berechnet den Arkussinus eines Werts. |
| Asinh(Double) |
Berechnet den hyperbolischen Arkussinus eines Werts. |
| AsinPi(Double) |
Berechnet den Arkussinus eines Werts und dividiert das Ergebnis durch |
| Atan(Double) |
Berechnet den Bogen-Tangens eines Werts. |
| Atan2(Double, Double) |
Berechnet den Bogen-Tangens des Quotienten zweier Werte. |
| Atan2Pi(Double, Double) |
Berechnet den Bogen-Tangens für den Quotienten zweier Werte und dividiert das Ergebnis durch |
| Atanh(Double) |
Berechnet den hyperbolischen Bogen-Tangens eines Werts. |
| AtanPi(Double) |
Berechnet den Bogen-Tangens eines Werts und dividiert das Ergebnis durch pi. |
| BitDecrement(Double) |
Gibt den größten Wert zurück, der kleiner als ein angegebener Wert ist. |
| BitIncrement(Double) |
Gibt den kleinsten Wert zurück, der größer als ein angegebener 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 Minimal- und Maximalwert. |
| ClampNative(Double, Double, Double) |
Klammert einen Wert auf einen inklusiven Minimal- und Maximalwert unter Verwendung plattformspezifischer Verhaltensweisen für |
| CompareTo(Double) |
Vergleicht diese Instanz mit einer angegebenen Gleitkommazahl mit doppelter Genauigkeit und gibt eine ganze Zahl zurück, die angibt, ob der Wert dieser Instanz kleiner als, gleich oder größer als der Wert der angegebenen Gleitkommazahl mit doppelter Genauigkeit ist. |
| CompareTo(Object) |
Vergleicht diese Instanz mit einem angegebenen Objekt und gibt eine ganze Zahl zurück, die angibt, ob der Wert dieser Instanz kleiner als, gleich oder größer als der Wert des angegebenen Objekts ist. |
| ConvertToInteger<TInteger>(Double) |
Konvertiert einen Wert in einen angegebenen ganzzahligen Typ unter Verwendung der Sättigung beim Überlauf. |
| ConvertToIntegerNative<TInteger>(Double) |
Wandelt einen Wert in einen angegebenen ganzzahligen Typ um, wobei das plattformspezifische Verhalten beim Überlauf verwendet wird. |
| CopySign(Double, Double) |
Kopiert das Vorzeichen eines Werts in das Vorzeichen eines anderen Werts. |
| Cos(Double) |
Berechnet den Kosinus eines Werts. |
| Cosh(Double) |
Berechnet den hyperbolischen Kosinus eines Werts. |
| CosPi(Double) |
Berechnet den Kosinus eines Werts, der von |
| CreateChecked<TOther>(TOther) |
Erstellt eine Instanz des aktuellen Typs aus einem Wert und löst eine Überlaufausnahme für alle Werte aus, die außerhalb des darstellbaren Bereichs des aktuellen Typs liegen. |
| CreateSaturating<TOther>(TOther) |
Erstellt eine Instanz des aktuellen Typs aus einem Wert, wobei alle Werte gesättigt werden, die außerhalb des darstellbaren 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 darstellbaren Bereichs des aktuellen Typs liegen. |
| DegreesToRadians(Double) |
Wandelt einen bestimmten Wert von Grad in Bogenmaß um. |
| Equals(Double) |
Gibt einen Wert zurück, der angibt, ob diese Instanz und ein angegebenes Double Objekt denselben Wert darstellen. |
| Equals(Object) |
Gibt einen Wert zurück, der angibt, ob diese Instanz einem angegebenen Objekt entspricht. |
| Exp(Double) |
|
| Exp10(Double) |
|
| Exp10M1(Double) |
|
| Exp2(Double) |
|
| Exp2M1(Double) |
|
| ExpM1(Double) |
|
| Floor(Double) |
Berechnet den Boden eines Werts. |
| FusedMultiplyAdd(Double, Double, Double) |
Berechnet das fused multiplizierte Add von drei Werten. |
| GetHashCode() |
Gibt den Hashcode für diesen instance zurück. |
| GetTypeCode() | |
| Hypot(Double, Double) |
Berechnet die Hypotenuse mit zwei Werten, die die Längen der kürzeren Seiten in einem rechtwinkligen Dreieck darstellen. |
| Ieee754Remainder(Double, Double) |
Berechnet den Rest von zwei Werten gemäß IEEE 754. |
| ILogB(Double) |
Berechnet den ganzzahligen Logarithmus eines Werts. |
| IsEvenInteger(Double) |
Bestimmt, ob ein Wert eine gerade integrale Zahl darstellt. |
| IsFinite(Double) |
Bestimmt, ob der angegebene Wert endlich ist (Null, Unternormal oder Normal). |
| IsInfinity(Double) |
Gibt einen Wert zurück, der angibt, ob die angegebene Zahl als negative oder positive Unendlichkeit ausgewertet wird. |
| IsInteger(Double) |
Bestimmt, ob ein Wert einen integralen Wert darstellt. |
| IsNaN(Double) |
Gibt einen Wert zurück, der angibt, ob der angegebene Wert keine Zahl (NaN) ist. |
| IsNegative(Double) |
Bestimmt, ob der angegebene Wert negativ ist. |
| IsNegativeInfinity(Double) |
Gibt einen Wert zurück, der angibt, ob die angegebene Zahl als negative Unendlichkeit ausgewertet wird. |
| IsNormal(Double) |
Bestimmt, ob der angegebene Wert normal ist. |
| IsOddInteger(Double) |
Bestimmt, ob ein Wert eine ungerade integrale Zahl darstellt. |
| IsPositive(Double) |
Bestimmt, ob ein Wert positiv ist. |
| IsPositiveInfinity(Double) |
Gibt einen Wert zurück, der angibt, ob die angegebene Zahl als positive Unendlichkeit ausgewertet wird. |
| IsPow2(Double) |
Bestimmt, ob ein Wert eine Potenz von zwei ist. |
| IsRealNumber(Double) |
Bestimmt, ob ein Wert eine reelle Zahl darstellt. |
| IsSubnormal(Double) |
Bestimmt, ob der angegebene Wert subnormal ist. |
| Lerp(Double, Double, Double) |
Führt eine lineare Interpolation zwischen zwei Werten basierend auf der angegebenen Gewichtung aus. |
| Log(Double, Double) |
Berechnet den Logarithmus eines Werts in der angegebenen Basis. |
| Log(Double) |
Berechnet den natürlichen ( |
| Log10(Double) |
Berechnet den Logarithmus der Basis 10 eines Werts. |
| Log10P1(Double) |
Berechnet den Logarithmus der Basis 10 eines Werts plus 1. |
| Log2(Double) |
Berechnet das Protokoll2 eines Werts. |
| Log2P1(Double) |
Berechnet den Logarithmus der Basis-2 eines Werts plus 1. |
| LogP1(Double) |
Berechnet den natürlichen ( |
| Max(Double, Double) |
Vergleicht zwei Werte mit der Berechnung, die größer ist. |
| MaxMagnitude(Double, Double) |
Vergleicht zwei Werte mit der Berechnung, die größer ist. |
| MaxMagnitudeNumber(Double, Double) |
Vergleicht zwei Werte, um zu berechnen, die die größere Größe aufweisen und den anderen Wert zurückgeben, wenn eine Eingabe ist |
| MaxNative(Double, Double) |
Vergleicht zwei Werte mit der Berechnung, die mit plattformspezifischem Verhalten für |
| MaxNumber(Double, Double) |
Vergleicht zwei Werte mit der Berechnung, die größer ist und den anderen Wert zurückgibt, wenn eine Eingabe 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. |
| MinMagnitudeNumber(Double, Double) |
Vergleicht zwei Werte mit der Berechnung, die die geringere Größe aufweist und den anderen Wert zurückgibt, wenn eine Eingabe ist |
| MinNative(Double, Double) |
Vergleicht zwei Werte mit der Berechnung, die mit plattformspezifischem Verhalten für |
| MinNumber(Double, Double) |
Vergleicht zwei Werte mit der Berechnung, die kleiner ist und den anderen Wert zurückgibt, wenn eine Eingabe ist |
| MultiplyAddEstimate(Double, Double, Double) |
Berechnet eine Schätzung von ( |
| Parse(ReadOnlySpan<Byte>, IFormatProvider) |
Analysiert eine Spanne von UTF-8 Zeichen in einen Wert. |
| Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider) |
Analysiert eine Spanne von UTF-8 Zeichen in einen Wert. |
| Parse(ReadOnlySpan<Char>, IFormatProvider) |
Analysiert eine Spanne von Zeichen in einen Wert. |
| Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider) |
Konvertiert einen Zeichenbereich, der die Zeichenfolgendarstellung einer Zahl in einer angegebenen Formatvorlage und einem kulturspezifischen Format enthält, in dessen Gleitkommazahlenentsprechung mit doppelter Genauigkeit. |
| Parse(String, IFormatProvider) |
Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen kulturspezifischen Format in das Gleitkommazahlenäquivalent mit doppelter Genauigkeit. |
| Parse(String, NumberStyles, IFormatProvider) |
Konvertiert die Zeichenfolgendarstellung einer Zahl in einer angegebenen Formatvorlage und einem kulturspezifischen Format in dessen Gleitkommazahläquivalent mit doppelter Genauigkeit. |
| Parse(String, NumberStyles) |
Konvertiert die Zeichenfolgendarstellung einer Zahl in einer angegebenen Formatvorlage in dessen Gleitkommazahläquivalent mit doppelter Genauigkeit. |
| Parse(String) |
Konvertiert die Zeichenfolgendarstellung einer Zahl in dessen Gleitkommazahläquivalent mit doppelter Genauigkeit. |
| Pow(Double, Double) |
Berechnet einen Wert, der auf eine bestimmte Leistung erhöht wird. |
| RadiansToDegrees(Double) |
Wandelt einen bestimmten Wert von Bogenmaß in Grad um. |
| ReciprocalEstimate(Double) |
Berechnet eine Schätzung des Kehrwerts eines Werts. |
| ReciprocalSqrtEstimate(Double) |
Berechnet eine Schätzung der gegenseitigen Quadratwurzel eines Werts. |
| RootN(Double, Int32) |
Berechnet die n-th-Stammebene eines Werts. |
| Round(Double, Int32, MidpointRounding) |
Rundet einen Wert auf eine angegebene Anzahl von Dezimalstellen mithilfe des standardmäßigen Rundungsmodus (ToEven). |
| Round(Double, Int32) |
Rundet einen Wert auf eine angegebene Anzahl von Dezimalstellen mithilfe des standardmäßigen Rundungsmodus (ToEven). |
| Round(Double, MidpointRounding) |
Rundet einen Wert mithilfe des angegebenen Rundungsmodus auf die nächste ganze Zahl. |
| Round(Double) |
Rundet einen Wert mithilfe des standardmäßigen Rundungsmodus (ToEven) auf die nächste ganze Zahl ab. |
| ScaleB(Double, Int32) |
Berechnet das Produkt eines Werts und dessen Basisradiix, das auf die angegebene Leistung angehoben wird. |
| Sign(Double) |
Berechnet das Vorzeichen eines Werts. |
| Sin(Double) |
Berechnet den Sinus eines Werts. |
| SinCos(Double) |
Berechnet den Sinus und kosinus eines Werts. |
| SinCosPi(Double) |
Berechnet den Sinus und kosinus eines Werts. |
| Sinh(Double) |
Berechnet den hyperbolischen Sinus eines Werts. |
| SinPi(Double) |
Berechnet den Sinus eines Werts, der multipliziert wurde. |
| Sqrt(Double) |
Berechnet die Quadratwurzel eines Werts. |
| Tan(Double) |
Berechnet den Tangens eines Werts. |
| Tanh(Double) |
Berechnet den hyperbolischen Tangens eines Werts. |
| TanPi(Double) |
Berechnet den Tangens eines Werts, der von |
| ToString() |
Konvertiert den numerischen Wert dieser Instanz in die entsprechende Zeichenfolgendarstellung. |
| ToString(IFormatProvider) |
Wandelt den numerischen Wert dieser Instanz mithilfe der angegebenen kulturspezifischen Formatinformationen in die entsprechende Zeichenfolgendarstellung um. |
| ToString(String, IFormatProvider) |
Wandelt den numerischen Wert dieser Instanz mithilfe der angegebenen Format- und kulturspezifischen Formatinformationen in die entsprechende Zeichenfolgendarstellung um. |
| ToString(String) |
Wandelt den numerischen Wert dieser Instanz mithilfe des angegebenen Formats in die entsprechende Zeichenfolgendarstellung um. |
| Truncate(Double) |
Schneidet einen Wert ab. |
| TryFormat(Span<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider) |
Versucht, den Wert der aktuellen Instanz als UTF-8 in die bereitgestellte Bytespanne zu formatieren. |
| TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider) |
Versucht, den Wert der aktuellen doppelten Instanz in die bereitgestellte Zeichenspanne zu formatieren. |
| TryParse(ReadOnlySpan<Byte>, Double) |
Versucht, einen UTF-8-Zeichenbereich mit der Zeichenfolgendarstellung einer Zahl in seine Gleitkommazahläquivalent mit doppelter Genauigkeit zu konvertieren. |
| TryParse(ReadOnlySpan<Byte>, IFormatProvider, Double) |
Versucht, eine Spanne von UTF-8 Zeichen in einen Wert zu analysieren. |
| TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, Double) |
Versucht, eine Spanne von UTF-8 Zeichen in einen Wert zu analysieren. |
| TryParse(ReadOnlySpan<Char>, Double) |
Wandelt die Spandarstellung einer Zahl in einem angegebenen Format und kulturspezifischen Format in das Gleitkommazahlenäquivalent mit doppelter Genauigkeit um. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich war oder fehlgeschlagen ist. |
| TryParse(ReadOnlySpan<Char>, IFormatProvider, Double) |
Versucht, einen Bereich von Zeichen in einen Wert zu analysieren. |
| TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Double) |
Konvertiert einen Zeichenbereich, der die Zeichenfolgendarstellung einer Zahl in einem angegebenen Format und kulturspezifischen Format enthält, in dessen Gleitkommazahlenäquivalent mit doppelter Genauigkeit. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich war oder fehlgeschlagen ist. |
| TryParse(String, Double) |
Konvertiert die Zeichenfolgendarstellung einer Zahl in dessen Gleitkommazahläquivalent mit doppelter Genauigkeit. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich war oder fehlgeschlagen ist. |
| TryParse(String, IFormatProvider, Double) |
Versucht, eine Zeichenfolge in einen Wert zu analysieren. |
| TryParse(String, NumberStyles, IFormatProvider, Double) |
Konvertiert die Zeichenfolgendarstellung einer Zahl in einer angegebenen Formatvorlage und einem kulturspezifischen Format in dessen Gleitkommazahläquivalent mit doppelter Genauigkeit. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich war oder fehlgeschlagen ist. |
Operatoren
| Name | Beschreibung |
|---|---|
| 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 nicht gleich sind. |
| LessThan(Double, Double) |
Gibt einen Wert zurück, der angibt, ob ein angegebener Double Wert kleiner 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
| Name | Beschreibung |
|---|---|
| IAdditionOperators<Double,Double,Double>.Addition(Double, Double) |
Addiert zwei Werte zusammen, um ihre Summe zu berechnen. |
| IAdditiveIdentity<Double,Double>.AdditiveIdentity |
Ruft die additive Identität des aktuellen Typs ab. |
| IBinaryNumber<Double>.AllBitsSet |
Ruft eine Instanz des binären Typs ab, in der alle Bits festgelegt sind. |
| IBitwiseOperators<Double,Double,Double>.BitwiseAnd(Double, Double) |
Berechnet die bitweise und von zwei Werten. |
| IBitwiseOperators<Double,Double,Double>.BitwiseOr(Double, Double) |
Berechnet die bitweise oder zwei Werte. |
| IBitwiseOperators<Double,Double,Double>.ExclusiveOr(Double, Double) |
Berechnet die exklusiven oder zwei Werte. |
| IBitwiseOperators<Double,Double,Double>.OnesComplement(Double) |
Berechnet die Darstellung eines bestimmten Werts. |
| IComparable.CompareTo(Object) |
Vergleicht die aktuelle instance mit einem anderen Objekt desselben Typs und gibt eine ganze Zahl zurück, die angibt, ob das aktuelle instance vorangestellt, folgt oder an derselben Position in der Sortierreihenfolge wie das andere Objekt vorkommt. |
| IConvertible.GetTypeCode() |
Gibt die TypeCode Für diese Instanz zurück. |
| IConvertible.ToBoolean(IFormatProvider) |
Eine Beschreibung dieses Mitglieds finden Sie unter ToBoolean(IFormatProvider). |
| IConvertible.ToByte(IFormatProvider) |
Eine Beschreibung dieses Mitglieds finden Sie unter ToByte(IFormatProvider). |
| IConvertible.ToChar(IFormatProvider) |
Diese Konvertierung wird nicht unterstützt. Wenn Sie versuchen, diese Methode zu verwenden, wird ein InvalidCastException. |
| IConvertible.ToDateTime(IFormatProvider) |
Diese Konvertierung wird nicht unterstützt. Wenn Sie versuchen, diese Methode zu verwenden, wird ein InvalidCastException. |
| IConvertible.ToDecimal(IFormatProvider) |
Eine Beschreibung dieses Mitglieds finden Sie unter ToDecimal(IFormatProvider). |
| IConvertible.ToDouble(IFormatProvider) |
Eine Beschreibung dieses Mitglieds finden Sie unter ToDouble(IFormatProvider). |
| IConvertible.ToInt16(IFormatProvider) |
Eine Beschreibung dieses Mitglieds finden Sie unter ToInt16(IFormatProvider). |
| IConvertible.ToInt32(IFormatProvider) |
Eine Beschreibung dieses Mitglieds finden Sie unter ToInt32(IFormatProvider). |
| IConvertible.ToInt64(IFormatProvider) |
Eine Beschreibung dieses Mitglieds finden Sie unter ToInt64(IFormatProvider). |
| IConvertible.ToSByte(IFormatProvider) |
Eine Beschreibung dieses Mitglieds finden Sie unter ToSByte(IFormatProvider). |
| IConvertible.ToSingle(IFormatProvider) |
Eine Beschreibung dieses Mitglieds finden Sie unter ToSingle(IFormatProvider). |
| IConvertible.ToType(Type, IFormatProvider) |
Eine Beschreibung dieses Mitglieds finden Sie unter ToType(Type, IFormatProvider). |
| IConvertible.ToUInt16(IFormatProvider) |
Eine Beschreibung dieses Mitglieds finden Sie unter ToUInt16(IFormatProvider). |
| IConvertible.ToUInt32(IFormatProvider) |
Eine Beschreibung dieses Mitglieds finden Sie unter ToUInt32(IFormatProvider). |
| IConvertible.ToUInt64(IFormatProvider) |
Eine Beschreibung dieses Mitglieds finden Sie unter ToUInt64(IFormatProvider). |
| IDecrementOperators<Double>.Decrement(Double) |
Erhöht einen Wert. |
| IDivisionOperators<Double,Double,Double>.Division(Double, Double) |
Dividiert einen Wert durch einen anderen, um seinen Quotienten zu berechnen. |
| 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 Exponenten ab. |
| IFloatingPoint<Double>.GetSignificandBitLength() |
Ruft die Länge des aktuellen Zeichens in Bits ab. |
| IFloatingPoint<Double>.GetSignificandByteCount() |
Ruft die Anzahl der Bytes ab, die als Teil von TryWriteSignificandLittleEndian(Span<Byte>, Int32). |
| IFloatingPoint<Double>.TryWriteExponentBigEndian(Span<Byte>, Int32) |
Versucht, den aktuellen Exponenten im Big-End-Format in eine bestimmte Spanne zu schreiben. |
| IFloatingPoint<Double>.TryWriteExponentLittleEndian(Span<Byte>, Int32) |
Versucht, den aktuellen Exponenten in einem kleinen Endenformat in eine bestimmte Spanne zu schreiben. |
| IFloatingPoint<Double>.TryWriteSignificandBigEndian(Span<Byte>, Int32) |
Versucht, das aktuelle Significand im Big-End-Format in eine bestimmte Spanne zu schreiben. |
| IFloatingPoint<Double>.TryWriteSignificandLittleEndian(Span<Byte>, Int32) |
Versucht, das aktuelle Significand in little-endian-Format in eine bestimmte Spanne zu schreiben. |
| IFloatingPointConstants<Double>.E |
Ruft die mathematische Konstante |
| IFloatingPointConstants<Double>.Pi |
Ruft die mathematische Konstante |
| IFloatingPointConstants<Double>.Tau |
Ruft die mathematische Konstante |
| IFloatingPointIeee754<Double>.Epsilon |
Ruft den kleinsten Wert ab, der dem |
| IFloatingPointIeee754<Double>.NaN |
Ruft einen Wert ab, der darstellt |
| IFloatingPointIeee754<Double>.NegativeInfinity |
Ruft einen Wert ab, der negative |
| IFloatingPointIeee754<Double>.NegativeZero |
Ruft einen Wert ab, der negative |
| IFloatingPointIeee754<Double>.PositiveInfinity |
Ruft einen Wert ab, der positive |
| IIncrementOperators<Double>.Increment(Double) |
Erhöht einen Wert. |
| IMinMaxValue<Double>.MaxValue |
Ruft den Maximalwert des aktuellen Typs ab. |
| IMinMaxValue<Double>.MinValue |
Ruft den Minimalwert des aktuellen Typs ab. |
| IModulusOperators<Double,Double,Double>.Modulus(Double, Double) |
Dividiert zwei Werte zusammen, um deren Modul oder Rest zu berechnen. |
| IMultiplicativeIdentity<Double,Double>.MultiplicativeIdentity |
Ruft die multiplizierte Identität des aktuellen Typs ab. |
| IMultiplyOperators<Double,Double,Double>.Multiply(Double, Double) |
Multipliziert zwei Werte zusammen, um ihr Produkt zu berechnen. |
| INumberBase<Double>.IsCanonical(Double) |
Bestimmt, ob sich ein Wert in seiner kanonischen Darstellung befindet. |
| INumberBase<Double>.IsComplexNumber(Double) |
Bestimmt, ob ein Wert eine komplexe Zahl darstellt. |
| INumberBase<Double>.IsImaginaryNumber(Double) |
Bestimmt, ob ein Wert eine reine imaginäre Zahl darstellt. |
| INumberBase<Double>.IsZero(Double) |
Bestimmt, ob ein Wert null ist. |
| INumberBase<Double>.One |
Ruft den Wert |
| INumberBase<Double>.Radix |
Ruft die Basis für den Typ ab. |
| INumberBase<Double>.TryConvertFromChecked<TOther>(TOther, Double) |
Stellt eine Gleitkommazahl mit doppelter Genauigkeit dar. |
| INumberBase<Double>.TryConvertFromSaturating<TOther>(TOther, Double) |
Stellt eine Gleitkommazahl mit doppelter Genauigkeit dar. |
| INumberBase<Double>.TryConvertFromTruncating<TOther>(TOther, Double) |
Stellt eine Gleitkommazahl mit doppelter Genauigkeit dar. |
| INumberBase<Double>.TryConvertToChecked<TOther>(Double, TOther) |
Versucht, eine Instanz des aktuellen Typs in einen anderen Typ zu konvertieren und löst eine Überlaufausnahme für alle Werte aus, die außerhalb des darstellbaren Bereichs des aktuellen Typs liegen. |
| INumberBase<Double>.TryConvertToSaturating<TOther>(Double, TOther) |
Versucht, eine Instanz des aktuellen Typs in einen anderen Typ zu konvertieren und alle Werte zu sättigungen, die außerhalb des darstellbaren Bereichs des aktuellen Typs liegen. |
| INumberBase<Double>.TryConvertToTruncating<TOther>(Double, TOther) |
Versucht, eine Instanz des aktuellen Typs in einen anderen Typ zu konvertieren, wobei alle Werte abgeschnitten werden, die außerhalb des darstellbaren Bereichs des aktuellen Typs liegen. |
| INumberBase<Double>.Zero |
Ruft den Wert |
| ISignedNumber<Double>.NegativeOne |
Ruft den Wert |
| ISubtractionOperators<Double,Double,Double>.Subtraction(Double, Double) |
Subtrahiert zwei Werte, um ihre Differenz zu berechnen. |
| IUnaryNegationOperators<Double,Double>.UnaryNegation(Double) |
Berechnet die unäre Negation eines Werts. |
| IUnaryPlusOperators<Double,Double>.UnaryPlus(Double) |
Berechnet das unäre Pluszeichen eines Werts. |
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 in eine freigegebene Variable, die eine Instanz dieses Typs enthält, durch eine Sperre geschützt werden, um die Threadsicherheit zu gewährleisten.
