Double Struct
Definitie
Belangrijk
Bepaalde informatie heeft betrekking op een voorlopige productversie die aanzienlijk kan worden gewijzigd voordat deze wordt uitgebracht. Microsoft biedt geen enkele expliciete of impliciete garanties met betrekking tot de informatie die hier wordt verstrekt.
Vertegenwoordigt een drijvendekommagetal met dubbele precisie.
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- Overname
- Kenmerken
- Implementeringen
-
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>
Voorbeelden
Het volgende codevoorbeeld illustreert het gebruik van 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
Opmerkingen
Het Double waardetype vertegenwoordigt een 64-bits getal met dubbele precisie met waarden van negatief 1,79769313486232e308 tot positief 1,79769313486232e308, plus positieve of negatieve nul, PositiveInfinityen NegativeInfinitygeen getal (NaN). Het is bedoeld om waarden te vertegenwoordigen die extreem groot zijn (zoals afstanden tussen planeten of galaxies) of extreem klein (zoals de moleculaire massa van een stof in kilogram) en die vaak onnauwkeurig zijn (zoals de afstand van de aarde naar een ander zonnestelsel). Het Double type voldoet aan de IEC 60559:1989-standaard (IEEE 754) voor binaire zwevendekommaberekening.
Weergave en precisie van drijvende komma
Double gegevenstype slaat dubbele precisie zwevende-kommawaarden op in een 64-bits binair formaat, zoals weergegeven in de volgende tabel:
| Onderdeel | Bits |
|---|---|
| Significand of mantissa | 0-51 |
| Exponent | 52-62 |
| Teken (0 = Positief, 1 = Negatief) | 63 |
Net zoals decimale breuken bepaalde breuken niet precies kunnen weergeven (zoals 1/3 of Math.PI), kunnen binaire breuken bepaalde breuken niet vertegenwoordigen. Bijvoorbeeld: 1/10, die precies wordt weergegeven door .1 als decimale breuk, wordt vertegenwoordigd door .001100110011 als een binaire breuk, waarbij het patroon '0011' wordt herhaald tot oneindig. In dit geval biedt de zwevendekommavalue een onnauwkeurige weergave van het getal dat het vertegenwoordigt. Het uitvoeren van extra wiskundige bewerkingen op de oorspronkelijke drijvendekommage-waarde verhoogt vaak het gebrek aan precisie. Als u bijvoorbeeld het resultaat vergelijkt van het vermenigvuldigen van .1 met 10 en het negen keer optellen van .1 bij .1, ziet u dat optellen, omdat het acht extra bewerkingen heeft omvat, het minder nauwkeurige resultaat heeft opgeleverd. (Vóór .NET 10 is deze verschillen alleen zichtbaar als u de twee Double waarden weergeeft met behulp van de tekenreeks 'R' standaard numerieke notatietekenreeks, die maximaal 17 cijfers van precisie weergeeft die worden ondersteund door het type Double.)
using System;
public class Example13
{
public static void Main()
{
Double value = .1;
Double result1 = value * 10;
Double result2 = 0;
for (int ctr = 1; ctr <= 10; ctr++)
result2 += value;
Console.WriteLine($".1 * 10: {result1:R}");
Console.WriteLine($".1 Added 10 times: {result2:R}");
}
}
// The example displays the following output:
// .1 * 10: 1
// .1 Added 10 times: 0.99999999999999989
let value = 0.1
let result1 = value * 10.
let mutable result2 = 0.
for i = 1 to 10 do
result2 <- result2 + value
printfn $".1 * 10: {result1:R}"
printfn $".1 Added 10 times: {result2:R}"
// The example displays the following output:
// .1 * 10: 1
// .1 Added 10 times: 0.99999999999999989
Module Example14
Public Sub Run()
Dim value As Double = 0.1
Dim result1 As Double = value * 10
Dim result2 As Double
For ctr As Integer = 1 To 10
result2 += value
Next
Console.WriteLine(".1 * 10: {0:R}", result1)
Console.WriteLine(".1 Added 10 times: {0:R}", result2)
End Sub
End Module
' The example displays the following output:
' .1 * 10: 1
' .1 Added 10 times: 0.99999999999999989
Omdat sommige getallen niet exact als fractionele binaire waarden kunnen worden weergegeven, kunnen getallen met drijvende komma alleen reële getallen bij benadering worden weergegeven.
Alle getallen met drijvende komma hebben ook een beperkt aantal significante cijfers, wat ook bepaalt hoe nauwkeurig een drijvendekommagewaarde een reëel getal benadert. Een Double waarde heeft maximaal 15 decimale cijfers van precisie, hoewel een maximum van 17 cijfers intern wordt bijgehouden. Dit betekent dat sommige drijvendekommabewerkingen mogelijk niet de precisie hebben om een drijvende-kommawaarde te wijzigen. In het volgende voorbeeld ziet u een afbeelding. Het definieert een zeer grote drijvendekommawaarde en voegt vervolgens het product van Double.Epsilon en één quadrillion eraan toe. Het product is echter te klein om de oorspronkelijke drijvendekommage-waarde te wijzigen. Het minst significante cijfer is duizendde, terwijl het belangrijkste cijfer in het product 10-309 is.
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
De beperkte precisie van een drijvende-komma-getal heeft verschillende gevolgen.
Twee zwevende kommanummers die gelijk lijken aan een bepaalde precisie, kunnen mogelijk niet gelijk worden vergeleken, omdat hun minst significante cijfers verschillen. In het volgende voorbeeld worden een reeks getallen bij elkaar opgeteld en wordt het totaal vergeleken met het verwachte totaal.
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).De twee waarden zijn ongelijk vanwege een verlies van precisie tijdens de optellingsbewerkingen. In dit geval kan het probleem worden opgelost door de Math.Round(Double, Int32) methode aan te roepen om de Double waarden naar de gewenste precisie te afronden voordat de vergelijking wordt uitgevoerd.
Een wiskundige of vergelijkingsbewerking die gebruikmaakt van een drijvendekommagetal levert mogelijk niet hetzelfde resultaat op als een decimaal getal wordt gebruikt, omdat het binaire drijvendekommagetal mogelijk niet gelijk is aan het decimale getal. Een eerder voorbeeld illustreerde dit door het resultaat weer te geven van het vermenigvuldigen van .1 met 10 en het toevoegen van .1 keer.
Wanneer nauwkeurigheid in numerieke bewerkingen met breukwaarden belangrijk is, kunt u het Decimal type gebruiken in plaats van het Double type. Wanneer nauwkeurigheid in numerieke bewerkingen met integrale waarden buiten het bereik van de Int128UInt128 typen belangrijk is, gebruikt u het BigInteger type.
Single waarden hebben minder precisie dan Double waarden. Een Single waarde die wordt geconverteerd naar een schijnbaar equivalent Double , komt vaak niet overeen met de Double waarde vanwege verschillen in precisie. In het volgende voorbeeld wordt het resultaat van identieke delingsbewerkingen toegewezen aan een Double en een Single waarde. Nadat de Single waarde is omgezet in een Double, geeft een vergelijking van de twee waarden aan dat ze ongelijk zijn.
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: FalseAls u dit probleem wilt voorkomen, gebruikt u de Double plaats van het Single gegevenstype of gebruikt u de Round methode zodat beide waarden dezelfde precisie hebben.
Bovendien kan het resultaat van rekenkundige bewerkingen en toewijzingsbewerkingen met Double waarden enigszins verschillen per platform vanwege het verlies van precisie van het Double type. Het resultaat van het toewijzen van een letterlijke Double waarde kan bijvoorbeeld verschillen in de 32-bits en 64-bits versies van .NET. In het volgende voorbeeld ziet u dit verschil wanneer de letterlijke waarde -4,42330604244772E-305 en een variabele waarvan de waarde -4,42330604244772E-305 is toegewezen aan een Double variabele. Houd er rekening mee dat het resultaat van de Parse(String) methode in dit geval geen verlies van precisie ondervindt.
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 op gelijkheid
Om als gelijk te worden beschouwd, moeten twee Double waarden identieke waarden vertegenwoordigen. Vanwege verschillen in precisie tussen waarden of vanwege een verlies van precisie door een of beide waarden blijken drijvende-kommawaarden die verondersteld worden identiek te zijn, vaak ongelijk te zijn vanwege verschillen in hun minst significante cijfers. Als gevolg hiervan worden aanroepen naar de Equals methode aangeroepen om te bepalen of twee waarden gelijk zijn, of aanroepen naar de methode om de CompareTo relatie tussen twee Double waarden te bepalen, leveren vaak onverwachte resultaten op. Dit is duidelijk in het volgende voorbeeld, waarbij twee schijnbaar gelijke Double waarden ongelijk blijken te zijn omdat de eerste 15 cijfers precisie heeft, terwijl de tweede 17 is.
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 gevallen waarin een verlies van precisie waarschijnlijk van invloed is op het resultaat van een vergelijking, kunt u een van de volgende alternatieven gebruiken voor het aanroepen van de Equals of CompareTo methode:
Roep de Math.Round methode aan om ervoor te zorgen dat beide waarden dezelfde precisie hebben. In het volgende voorbeeld wordt een eerder voorbeeld gewijzigd om deze methode te gebruiken, zodat twee breukwaarden gelijkwaardig zijn.
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: TrueHet probleem van precisie is nog steeds van toepassing op het afronden van middelpuntwaarden. Zie de Math.Round(Double, Int32, MidpointRounding) methode voor meer informatie.
Toets op benaderde gelijkheid in plaats van gelijkheid. Hiervoor moet u een absoluut bedrag definiëren waarmee de twee waarden kunnen verschillen, maar nog steeds gelijk zijn, of dat u een relatief bedrag definieert waarmee de kleinere waarde kan afwijken van de grotere waarde.
Warning
Double.Epsilon wordt soms gebruikt als een absolute meting van de afstand tussen twee Double waarden bij het testen op gelijkheid. Double.Epsilon Meet echter de kleinste mogelijke waarde die kan worden toegevoegd aan of afgetrokken van, waarvan de Double waarde nul is. Voor de meeste positieve en negatieve Double waarden is de waarde Double.Epsilon te klein om te worden gedetecteerd. Daarom, met uitzondering van waarden die nul zijn, raden we het gebruik ervan niet aan in tests voor gelijkheid.
In het volgende voorbeeld wordt de laatste methode gebruikt om een
IsApproximatelyEqualmethode te definiëren waarmee het relatieve verschil tussen twee waarden wordt getest. De methode deelt doorMath.Max(value1, value2)zodat de vergelijking relatief is ten opzichte van de grotere (op grootte) van de twee waarden, waardoor het resultaat in de juiste volgorde van grootte wordt geplaatst. AlsMath.Maxnul retourneert (wat gebeurt wanneer de ene waarde nul is en de ander negatief), valt de methode terug opMath.Min(value1, value2)en gebruikt de niet-nulwaarde als deler. Het contrasteert ook het resultaat van aanroepen naar deIsApproximatelyEqualmethode en de 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
Waarden en uitzonderingen voor drijvende komma
In tegenstelling tot bewerkingen met integrale typen, die een DivideByZeroException voor deling door nul of een OverflowException voor overloop in een gecontroleerde context genereren, genereren bewerkingen met drijvendekommawaarden geen uitzonderingen. In plaats daarvan is het resultaat in uitzonderlijke situaties van een floating-point bewerking nul, positief oneindig, negatief oneindig of geen getal (NaN).
Als het resultaat van een drijvende-kommabewerking te klein is voor de doelindeling, is het resultaat nul. Dit kan gebeuren wanneer twee zeer kleine getallen worden vermenigvuldigd, zoals in het volgende voorbeeld wordt weergegeven.
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: TrueAls de grootte van het resultaat van een drijvendekommabewerking het bereik van het bestemmingsformaat overschrijdt, is het resultaat van de bewerking PositiveInfinity of NegativeInfinity, afhankelijk van het teken van het resultaat. Het resultaat van een bewerking die overloopt Double.MaxValue is PositiveInfinity, en het resultaat van een bewerking die overloopt Double.MinValue is NegativeInfinity, zoals het volgende voorbeeld laat zien.
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 is ook het resultaat van een deling door nul met een positief dividend, en NegativeInfinity is het resultaat van een deling door nul met een negatief dividend.
Als een zwevende-komma-operatie ongeldig is, is NaN het resultaat van de bewerking. Bijvoorbeeld resultaten NaN van de volgende bewerkingen:
Delen door nul met een dividend van nul. Houd er rekening mee dat andere gevallen van deling door nul resulteren in PositiveInfinity of NegativeInfinity.
Elke drijvendekommabewerking met een ongeldige invoer. Het aanroepen van de Math.Sqrt methode met een negatieve waarde retourneert NaNbijvoorbeeld, net zoals het aanroepen van de Math.Acos methode met een waarde die groter is dan een of minder dan een negatief.
Elke bewerking met een argument waarvan de waarde is Double.NaN.
Typeconversies
De Double structuur definieert geen expliciete of impliciete conversieoperators. In plaats daarvan worden conversies geïmplementeerd door de compiler.
De conversie van de waarde van een primitief numeriek type naar een Double is een widening conversie en vereist daarom geen expliciete cast-operator of aanroep naar een conversiemethode, tenzij een compiler dit expliciet vereist. De C#-compiler vereist bijvoorbeeld een cast-operator voor conversies van Decimal naar Double, terwijl de Visual Basic-compiler dat niet doet. In het volgende voorbeeld wordt de minimum- of maximumwaarde van andere primitieve numerieke typen geconverteerd naar een Double.
dynamic[] values = { Byte.MinValue, Byte.MaxValue, Decimal.MinValue,
Decimal.MaxValue, Int16.MinValue, Int16.MaxValue,
Int32.MinValue, Int32.MaxValue, Int64.MinValue,
Int64.MaxValue, SByte.MinValue, SByte.MaxValue,
Single.MinValue, Single.MaxValue, UInt16.MinValue,
UInt16.MaxValue, UInt32.MinValue, UInt32.MaxValue,
UInt64.MinValue, UInt64.MaxValue };
double dblValue;
foreach (dynamic value in values)
{
if (value.GetType() == typeof(decimal))
dblValue = (double)value;
else
dblValue = value;
Console.WriteLine($"{value} ({value.GetType().Name}) --> " +
$"{dblValue:R} ({dblValue.GetType().Name})");
}
// The example displays the following output:
// 0 (Byte) --> 0 (Double)
// 255 (Byte) --> 255 (Double)
// -79228162514264337593543950335 (Decimal) --> -7.9228162514264338E+28 (Double)
// 79228162514264337593543950335 (Decimal) --> 7.9228162514264338E+28 (Double)
// -32768 (Int16) --> -32768 (Double)
// 32767 (Int16) --> 32767 (Double)
// -2147483648 (Int32) --> -2147483648 (Double)
// 2147483647 (Int32) --> 2147483647 (Double)
// -9223372036854775808 (Int64) --> -9.2233720368547758E+18 (Double)
// 9223372036854775807 (Int64) --> 9.2233720368547758E+18 (Double)
// -128 (SByte) --> -128 (Double)
// 127 (SByte) --> 127 (Double)
// -3.402823E+38 (Single) --> -3.4028234663852886E+38 (Double)
// 3.402823E+38 (Single) --> 3.4028234663852886E+38 (Double)
// 0 (UInt16) --> 0 (Double)
// 65535 (UInt16) --> 65535 (Double)
// 0 (UInt32) --> 0 (Double)
// 4294967295 (UInt32) --> 4294967295 (Double)
// 0 (UInt64) --> 0 (Double)
// 18446744073709551615 (UInt64) --> 1.8446744073709552E+19 (Double)
open System
let values: obj[] =
[| Byte.MinValue; Byte.MaxValue; Decimal.MinValue
Decimal.MaxValue; Int16.MinValue; Int16.MaxValue
Int32.MinValue; Int32.MaxValue; Int64.MinValue
Int64.MaxValue; SByte.MinValue; SByte.MaxValue
Single.MinValue; Single.MaxValue; UInt16.MinValue
UInt16.MaxValue; UInt32.MinValue, UInt32.MaxValue
UInt64.MinValue; UInt64.MaxValue |]
for value in values do
let dblValue = value :?> double
printfn $"{value} ({value.GetType().Name}) --> {dblValue:R} ({dblValue.GetType().Name})"
// The example displays the following output:
// 0 (Byte) --> 0 (Double)
// 255 (Byte) --> 255 (Double)
// -79228162514264337593543950335 (Decimal) --> -7.9228162514264338E+28 (Double)
// 79228162514264337593543950335 (Decimal) --> 7.9228162514264338E+28 (Double)
// -32768 (Int16) --> -32768 (Double)
// 32767 (Int16) --> 32767 (Double)
// -2147483648 (Int32) --> -2147483648 (Double)
// 2147483647 (Int32) --> 2147483647 (Double)
// -9223372036854775808 (Int64) --> -9.2233720368547758E+18 (Double)
// 9223372036854775807 (Int64) --> 9.2233720368547758E+18 (Double)
// -128 (SByte) --> -128 (Double)
// 127 (SByte) --> 127 (Double)
// -3.402823E+38 (Single) --> -3.4028234663852886E+38 (Double)
// 3.402823E+38 (Single) --> 3.4028234663852886E+38 (Double)
// 0 (UInt16) --> 0 (Double)
// 65535 (UInt16) --> 65535 (Double)
// 0 (UInt32) --> 0 (Double)
// 4294967295 (UInt32) --> 4294967295 (Double)
// 0 (UInt64) --> 0 (Double)
// 18446744073709551615 (UInt64) --> 1.8446744073709552E+19 (Double)
Module Example5
Public Sub Run()
Dim values() As Object = {Byte.MinValue, Byte.MaxValue, Decimal.MinValue,
Decimal.MaxValue, Int16.MinValue, Int16.MaxValue,
Int32.MinValue, Int32.MaxValue, Int64.MinValue,
Int64.MaxValue, SByte.MinValue, SByte.MaxValue,
Single.MinValue, Single.MaxValue, UInt16.MinValue,
UInt16.MaxValue, UInt32.MinValue, UInt32.MaxValue,
UInt64.MinValue, UInt64.MaxValue}
Dim dblValue As Double
For Each value In values
dblValue = value
Console.WriteLine("{0} ({1}) --> {2:R} ({3})",
value, value.GetType().Name,
dblValue, dblValue.GetType().Name)
Next
End Sub
End Module
' The example displays the following output:
' 0 (Byte) --> 0 (Double)
' 255 (Byte) --> 255 (Double)
' -79228162514264337593543950335 (Decimal) --> -7.9228162514264338E+28 (Double)
' 79228162514264337593543950335 (Decimal) --> 7.9228162514264338E+28 (Double)
' -32768 (Int16) --> -32768 (Double)
' 32767 (Int16) --> 32767 (Double)
' -2147483648 (Int32) --> -2147483648 (Double)
' 2147483647 (Int32) --> 2147483647 (Double)
' -9223372036854775808 (Int64) --> -9.2233720368547758E+18 (Double)
' 9223372036854775807 (Int64) --> 9.2233720368547758E+18 (Double)
' -128 (SByte) --> -128 (Double)
' 127 (SByte) --> 127 (Double)
' -3.402823E+38 (Single) --> -3.4028234663852886E+38 (Double)
' 3.402823E+38 (Single) --> 3.4028234663852886E+38 (Double)
' 0 (UInt16) --> 0 (Double)
' 65535 (UInt16) --> 65535 (Double)
' 0 (UInt32) --> 0 (Double)
' 4294967295 (UInt32) --> 4294967295 (Double)
' 0 (UInt64) --> 0 (Double)
' 18446744073709551615 (UInt64) --> 1.8446744073709552E+19 (Double)
Bovendien worden de Single waarden Single.NaN, Single.PositiveInfinityen Single.NegativeInfinity geconverteerd naar Double.NaNrespectievelijk , Double.PositiveInfinityen Double.NegativeInfinity, .
De conversie van de waarde van sommige numerieke typen naar een Double waarde kan leiden tot verlies van precisie. Zoals in het voorbeeld wordt geïllustreerd, is een verlies van precisie mogelijk bij het Decimalconverteren, Int64en UInt64 waarden naar Double waarden.
De conversie van een Double-waarde naar een waarde van een ander primitief numeriek gegevenstype is een smalle conversie en vereist een cast-operator (in C#), een conversiemethode (in Visual Basic) of een aanroep naar een Convert methode. Waarden die buiten het bereik van het doelgegevenstype vallen, zoals gedefinieerd door de MinValue en MaxValue eigenschappen van het doeltype, gedragen zich zoals weergegeven in de volgende tabel.
| Doeltype | Result |
|---|---|
| Elk geheel getype | Een OverflowException uitzondering als de conversie plaatsvindt in een gecontroleerde context. Als de conversie plaatsvindt in een niet-gecontroleerde context (de standaardinstelling in C#), slaagt de conversiebewerking, maar de waarde overloopt. |
| Decimal | Een OverflowException uitzondering. |
| Single |
Single.NegativeInfinity voor negatieve waarden. Single.PositiveInfinity voor positieve waarden. |
Daarnaast genereren Double.NaN, Double.PositiveInfinity en Double.NegativeInfinity een OverflowException voor conversies naar gehele getallen in een gecontroleerde context, maar deze waarden lopen over wanneer ze worden geconverteerd naar gehele getallen in een niet-gecontroleerde context. Voor conversies naar Decimal wordt er altijd een OverflowException gegooid. Voor conversies naar Single converteren ze respectievelijk naar Single.NaN, Single.PositiveInfinity en Single.NegativeInfinity.
Een verlies van precisie kan het gevolg zijn van het converteren van een Double waarde naar een ander numeriek type. In het geval van conversie naar een van de integrale typen, zoals de uitvoer uit het voorbeeld laat zien, gaat het breukonderdeel verloren wanneer de Double waarde wordt afgerond (zoals in Visual Basic) of afgekapt (zoals in C#). Voor conversies naar Decimal en Single waarden heeft de Double waarde mogelijk geen nauwkeurige weergave in het doelgegevenstype.
In het volgende voorbeeld wordt een aantal Double waarden geconverteerd naar verschillende andere numerieke typen. De conversies worden uitgevoerd in een gecontroleerde context in Visual Basic (de standaardinstelling), in C# (vanwege het trefwoord controle) en in F# (vanwege de module Controle). In de uitvoer van het voorbeeld ziet u het resultaat voor conversies in zowel een gecontroleerde als een niet-gecontroleerde context. U kunt conversies uitvoeren in een niet-gecontroleerde context in Visual Basic door te compileren met de /removeintchecks+ compilerswitch, in C# door de checked instructie te becommentariëren en in F# door de open Checked instructie te becommentariëren.
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)
Zie voor meer informatie over de conversie van numerieke typen Typeconversie in .NET en Typeconversietabellen.
Drijvende-komma-functionaliteit
De Double structuur en gerelateerde typen bieden methoden voor het uitvoeren van bewerkingen op de volgende gebieden:
Vergelijking van waarden. U kunt de Equals methode aanroepen om te bepalen of twee Double waarden gelijk zijn of de CompareTo methode om de relatie tussen twee waarden te bepalen.
De Double structuur ondersteunt ook een volledige set vergelijkingsoperatoren. U kunt bijvoorbeeld testen op gelijkheid of ongelijkheid of bepalen of de ene waarde groter is dan of gelijk is aan een andere waarde. Als een van de operanden een ander numeriek type is dan een Double, wordt deze geconverteerd naar een Double voordat de vergelijking wordt uitgevoerd.
Warning
Vanwege verschillen in precisie kunnen twee Double waarden waarvan u verwacht dat ze gelijk zijn, ongelijk zijn, wat van invloed is op het resultaat van de vergelijking. Zie de sectie Double voor informatie over het vergelijken van twee waarden.
U kunt ook de IsNaNmethoden , IsInfinityen IsPositiveInfinityIsNegativeInfinity methoden aanroepen om te testen op deze speciale waarden.
Wiskundige bewerkingen. Algemene rekenkundige bewerkingen, zoals optellen, aftrekken, vermenigvuldigen en delen, worden geïmplementeerd door taalcompilers en CIL-instructies (Common Intermediate Language) in plaats van op Double methoden. Als een van de operanden in een wiskundige bewerking een ander type is dan een Doublenumeriek type, wordt deze geconverteerd naar een Double voordat de bewerking wordt uitgevoerd. Het resultaat van de bewerking is ook een Double waarde.
Andere wiskundige bewerkingen kunnen worden uitgevoerd door methoden
static(Sharedin Visual Basic) aan te roepen in de klasse System.Math. Het bevat aanvullende methoden die vaak worden gebruikt voor rekenkundige bewerkingen (zoals Math.Abs, Math.Signen Math.Sqrt), geometrie (zoals Math.Cos en Math.Sin) en calculus (zoals Math.Log).U kunt ook de afzonderlijke bits in een Double waarde bewerken. De BitConverter.DoubleToInt64Bits methode behoudt het bitpatroon van een Double waarde in een 64-bits geheel getal. De BitConverter.GetBytes(Double) methode retourneert het bitpatroon in een bytematrix.
Afronden. Afronding wordt vaak gebruikt als techniek om de impact van verschillen tussen waarden te verminderen, veroorzaakt door problemen met de zwevendekommavoorstelling en precisie. U kunt een Double waarde afronden door de Math.Round methode aan te roepen.
Opmaak. U kunt een Double waarde converteren naar de tekenreeksweergave door de ToString methode aan te roepen of door de samengestelde opmaakfunctie te gebruiken. Zie Standaardtekenreeksen met numerieke notatie entekenreeksen voor aangepaste numerieke notatietekenreeksen voor meer informatie over hoe tekenreeksen voor opmaak de tekenreeksen van zwevende kommawaarden bepalen.
Tekenreeksen parseren. U kunt de tekenreeksweergave van een drijvende-kommawaarde converteren naar een Double waarde door de Parse of TryParse methode aan te roepen. Als de parseringsbewerking mislukt, genereert de Parse methode een uitzondering, terwijl de TryParse methode retourneert
false.Typeconversie. De Double structuur biedt een expliciete interface-implementatie voor de IConvertible interface, die ondersteuning biedt voor conversie tussen twee standaard .NET-gegevenstypen. Taalcompilers ondersteunen ook de impliciete conversie van waarden van alle andere standaard numerieke typen naar Double waarden. De conversie van een waarde van elk standaard numeriek type naar een Double is een verbreedingsconversie en vereist geen gebruiker van een cast-operator of conversiemethode,
Conversie van Int64 en Single waarden kunnen echter leiden tot verlies van precisie. De volgende tabel bevat de verschillen in precisie voor elk van deze typen:
Typ Maximale precisie Interne precisie Double 15 17 Int64 19 decimalen 19 decimalen Single 7 decimalen 9 decimalen Het probleem van precisie is het meest van invloed op Single waarden die worden geconverteerd naar Double waarden. In het volgende voorbeeld zijn twee waarden die door identieke deelbewerkingen worden geproduceerd, ongelijk omdat een van de waarden een drijvendekommawaarde met één precisie is die wordt geconverteerd naar een Double.
using System; public class Example13 { public static void Main() { Double value = .1; Double result1 = value * 10; Double result2 = 0; for (int ctr = 1; ctr <= 10; ctr++) result2 += value; Console.WriteLine($".1 * 10: {result1:R}"); Console.WriteLine($".1 Added 10 times: {result2:R}"); } } // The example displays the following output: // .1 * 10: 1 // .1 Added 10 times: 0.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
Velden
| Name | Description |
|---|---|
| E |
Vertegenwoordigt de natuurlijke logaritmische basis, opgegeven door de constante e. |
| Epsilon |
Vertegenwoordigt de kleinste positieve Double waarde die groter is dan nul. Dit veld is constant. |
| MaxValue |
Vertegenwoordigt de grootst mogelijke waarde van een Double. Dit veld is constant. |
| MinValue |
Vertegenwoordigt de kleinste mogelijke waarde van een Double. Dit veld is constant. |
| NaN |
Vertegenwoordigt een waarde die geen getal ( |
| NegativeInfinity |
Geeft een negatief oneindigheid aan. Dit veld is constant. |
| NegativeZero |
Vertegenwoordigt het getal negatief nul (-0). |
| Pi |
Vertegenwoordigt de verhouding van de omtrek van een cirkel tot de diameter, opgegeven door de constante, π. |
| PositiveInfinity |
Geeft positieve oneindigheid aan. Dit veld is constant. |
| Tau |
Vertegenwoordigt het aantal radialen op één beurt, opgegeven door de constante, τ. |
Methoden
| Name | Description |
|---|---|
| Abs(Double) |
Berekent de absolute waarde van een waarde. |
| Acos(Double) |
Berekent de boogcosinus van een waarde. |
| Acosh(Double) |
Berekent de hyperbolische boogcosinus van een waarde. |
| AcosPi(Double) |
Berekent de boogcosinus van een waarde en deelt het resultaat door |
| Asin(Double) |
Berekent de boogsinus van een waarde. |
| Asinh(Double) |
Berekent de sinus hyperbolische boog van een waarde. |
| AsinPi(Double) |
Berekent de boogsinus van een waarde en deelt het resultaat door |
| Atan(Double) |
Berekent de boogtangens van een waarde. |
| Atan2(Double, Double) |
Berekent de boogtangens van het quotiënt van twee waarden. |
| Atan2Pi(Double, Double) |
Berekent de boogtangens voor het quotiënt van twee waarden en deelt het resultaat door |
| Atanh(Double) |
Berekent de hyperbolische boogtangens van een waarde. |
| AtanPi(Double) |
Berekent de boogtangens van een waarde en deelt het resultaat door pi. |
| BitDecrement(Double) |
Retourneert de grootste waarde die kleiner is dan een opgegeven waarde. |
| BitIncrement(Double) |
Retourneert de kleinste waarde die groter is dan een opgegeven waarde. |
| Cbrt(Double) |
Berekent de kubushoofdmap van een waarde. |
| Ceiling(Double) |
Berekent het maximum van een waarde. |
| Clamp(Double, Double, Double) |
Klemmen een waarde tot een inclusieve minimum- en maximumwaarde. |
| ClampNative(Double, Double, Double) |
Klemmen een waarde tot een inclusieve minimum- en maximumwaarde met behulp van platformspecifiek gedrag voor |
| CompareTo(Double) |
Vergelijkt dit exemplaar met een opgegeven drijvendekommagetal met dubbele precisie en retourneert een geheel getal dat aangeeft of de waarde van dit exemplaar kleiner is dan, gelijk is aan of groter is dan de waarde van het opgegeven drijvendekommagetal met dubbele precisie. |
| CompareTo(Object) |
Vergelijkt dit exemplaar met een opgegeven object en retourneert een geheel getal dat aangeeft of de waarde van dit exemplaar kleiner is dan, gelijk is aan of groter is dan de waarde van het opgegeven object. |
| ConvertToInteger<TInteger>(Double) |
Converteert een waarde naar een opgegeven geheel getal met behulp van verzadiging bij overloop |
| ConvertToIntegerNative<TInteger>(Double) |
Converteert een waarde naar een opgegeven geheel getaltype met behulp van platformspecifiek gedrag bij overloop. |
| CopySign(Double, Double) |
Kopieert het teken van een waarde naar het teken van een andere waarde. |
| Cos(Double) |
Berekent de cosinus van een waarde. |
| Cosh(Double) |
Berekent de cosinus hyperbolicus van een waarde. |
| CosPi(Double) |
Berekent de cosinus van een waarde die is vermenigvuldigd door |
| CreateChecked<TOther>(TOther) |
Hiermee maakt u een exemplaar van het huidige type op basis van een waarde en genereert u een overloopuitzondering voor waarden die buiten het vertegenwoordigbare bereik van het huidige type vallen. |
| CreateSaturating<TOther>(TOther) |
Hiermee maakt u een exemplaar van het huidige type op basis van een waarde, waarbij alle waarden die buiten het vertegenwoordigbare bereik van het huidige type vallen, worden verzadiging weergegeven. |
| CreateTruncating<TOther>(TOther) |
Hiermee maakt u een exemplaar van het huidige type op basis van een waarde, waarbij alle waarden worden afgekapt die buiten het vertegenwoordigbare bereik van het huidige type vallen. |
| DegreesToRadians(Double) |
Converteert een bepaalde waarde van graden naar radialen. |
| Equals(Double) |
Retourneert een waarde die aangeeft of dit exemplaar en een opgegeven Double object dezelfde waarde vertegenwoordigen. |
| Equals(Object) |
Retourneert een waarde die aangeeft of dit exemplaar gelijk is aan een opgegeven object. |
| Exp(Double) |
Berekeningen |
| Exp10(Double) |
Berekeningen |
| Exp10M1(Double) |
Berekeningen |
| Exp2(Double) |
Berekeningen |
| Exp2M1(Double) |
Berekeningen |
| ExpM1(Double) |
Berekeningen |
| Floor(Double) |
Berekent de vloer van een waarde. |
| FusedMultiplyAdd(Double, Double, Double) |
Berekent de samenvoeging van drie waarden. |
| GetHashCode() |
Retourneert de hash-code voor dit exemplaar. |
| GetTypeCode() | |
| Hypot(Double, Double) |
Berekent de hypotenuse op basis van twee waarden die de lengten van de kortere zijden in een driehoek met een rechte hoek vertegenwoordigen. |
| Ieee754Remainder(Double, Double) |
Berekent de rest van twee waarden, zoals opgegeven door IEEE 754. |
| ILogB(Double) |
Berekent de logaritme van een geheel getal van een waarde. |
| IsEvenInteger(Double) |
Bepaalt of een waarde een even integraal getal vertegenwoordigt. |
| IsFinite(Double) |
Bepaalt of de opgegeven waarde eindig is (nul, subnormaal of normaal). |
| IsInfinity(Double) |
Retourneert een waarde die aangeeft of het opgegeven getal negatief of positief oneindig is. |
| IsInteger(Double) |
Bepaalt of een waarde een integrale waarde vertegenwoordigt. |
| IsNaN(Double) |
Retourneert een waarde die aangeeft of de opgegeven waarde geen getal (NaN) is. |
| IsNegative(Double) |
Bepaalt of de opgegeven waarde negatief is. |
| IsNegativeInfinity(Double) |
Retourneert een waarde die aangeeft of het opgegeven getal een negatieve oneindigheid oplevert. |
| IsNormal(Double) |
Bepaalt of de opgegeven waarde normaal is. |
| IsOddInteger(Double) |
Bepaalt of een waarde een oneven integraal getal vertegenwoordigt. |
| IsPositive(Double) |
Bepaalt of een waarde positief is. |
| IsPositiveInfinity(Double) |
Retourneert een waarde die aangeeft of het opgegeven getal positief oneindig is. |
| IsPow2(Double) |
Bepaalt of een waarde een macht van twee is. |
| IsRealNumber(Double) |
Bepaalt of een waarde een reëel getal vertegenwoordigt. |
| IsSubnormal(Double) |
Bepaalt of de opgegeven waarde subnormaal is. |
| Lerp(Double, Double, Double) |
Hiermee wordt een lineaire interpolatie tussen twee waarden uitgevoerd op basis van het opgegeven gewicht. |
| Log(Double, Double) |
Berekent de logaritme van een waarde in de opgegeven basis. |
| Log(Double) |
Berekent de natuurlijke ( |
| Log10(Double) |
Berekent de logaritme met grondtal 10 van een waarde. |
| Log10P1(Double) |
Berekent de logaritme met grondtal 10 van een waarde plus één. |
| Log2(Double) |
Berekent het logboek2 van een waarde. |
| Log2P1(Double) |
Berekent de logaritme met grondtal 2 van een waarde plus één. |
| LogP1(Double) |
Berekent de natuurlijke logaritme |
| Max(Double, Double) |
Vergelijkt twee waarden met berekeningen die groter zijn. |
| MaxMagnitude(Double, Double) |
Vergelijkt twee waarden met berekeningen die groter zijn. |
| MaxMagnitudeNumber(Double, Double) |
Vergelijkt twee waarden met berekeningen die de grotere grootte hebben en de andere waarde retourneren als een invoer is |
| MaxNative(Double, Double) |
Vergelijkt twee waarden met berekeningen die groter zijn met behulp van platformspecifiek gedrag voor |
| MaxNumber(Double, Double) |
Vergelijkt twee waarden met berekeningen die groter zijn en de andere waarde retourneren als een invoer is |
| Min(Double, Double) |
Vergelijkt twee waarden met berekeningen die kleiner zijn. |
| MinMagnitude(Double, Double) |
Vergelijkt twee waarden met berekeningen die kleiner zijn. |
| MinMagnitudeNumber(Double, Double) |
Vergelijkt twee waarden met berekeningen die de lagere grootte hebben en de andere waarde retourneren als een invoer is |
| MinNative(Double, Double) |
Vergelijkt twee waarden met berekeningen die minder gebruikmaken van platformspecifiek gedrag voor |
| MinNumber(Double, Double) |
Vergelijkt twee waarden met berekeningen die kleiner zijn en de andere waarde retourneren als een invoer is |
| MultiplyAddEstimate(Double, Double, Double) |
Berekent een schatting van ( |
| Parse(ReadOnlySpan<Byte>, IFormatProvider) |
Parseert een reeks UTF-8 tekens in een waarde. |
| Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider) |
Parseert een reeks UTF-8 tekens in een waarde. |
| Parse(ReadOnlySpan<Char>, IFormatProvider) |
Parseert een reeks tekens in een waarde. |
| Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider) |
Converteert een tekenspanne die de tekenreeksweergave van een getal in een opgegeven stijl en cultuurspecifieke notatie bevat naar het equivalent van drijvendekommagetal met dubbele precisie. |
| Parse(String, IFormatProvider) |
Converteert de tekenreeksweergave van een getal in een opgegeven cultuurspecifieke notatie naar het equivalent van een drijvendekommagetal met dubbele precisie. |
| Parse(String, NumberStyles, IFormatProvider) |
Converteert de tekenreeksweergave van een getal in een opgegeven stijl en cultuurspecifieke notatie naar het equivalent van een drijvendekommagetal met dubbele precisie. |
| Parse(String, NumberStyles) |
Converteert de tekenreeksweergave van een getal in een opgegeven stijl naar het equivalent van een getal met dubbele precisie. |
| Parse(String) |
Converteert de tekenreeksweergave van een getal naar het equivalent van een getal met dubbele precisie. |
| Pow(Double, Double) |
Berekent een waarde die is verhoogd tot een bepaalde macht. |
| RadiansToDegrees(Double) |
Converteert een bepaalde waarde van radialen naar graden. |
| ReciprocalEstimate(Double) |
Berekent een schatting van de wederkerigheid van een waarde. |
| ReciprocalSqrtEstimate(Double) |
Berekent een schatting van de wederzijdse vierkantswortel van een waarde. |
| RootN(Double, Int32) |
Berekent de n-th-hoofdmap van een waarde. |
| Round(Double, Int32, MidpointRounding) |
Rondt een waarde af op een opgegeven aantal fractionele cijfers met behulp van de standaard afgeronde modus (ToEven). |
| Round(Double, Int32) |
Rondt een waarde af op een opgegeven aantal fractionele cijfers met behulp van de standaard afgeronde modus (ToEven). |
| Round(Double, MidpointRounding) |
Rondt een waarde af op het dichtstbijzijnde gehele getal met behulp van de opgegeven afrondingsmodus. |
| Round(Double) |
Rondt een waarde af op het dichtstbijzijnde gehele getal met behulp van de standaard afrondingsmodus (ToEven). |
| ScaleB(Double, Int32) |
Berekent het product van een waarde en de basis-radix die tot de opgegeven macht zijn verheven. |
| Sign(Double) |
Berekent het teken van een waarde. |
| Sin(Double) |
Berekent de sinus van een waarde. |
| SinCos(Double) |
Berekent de sinus en cosinus van een waarde. |
| SinCosPi(Double) |
Berekent de sinus en cosinus van een waarde. |
| Sinh(Double) |
Berekent de sinus hyperbolicus van een waarde. |
| SinPi(Double) |
Berekent de sinus van een waarde die is vermenigvuldigd met |
| Sqrt(Double) |
Berekent de vierkantswortel van een waarde. |
| Tan(Double) |
Berekent de tangens van een waarde. |
| Tanh(Double) |
Berekent de tangens hyperbolicus van een waarde. |
| TanPi(Double) |
Berekent de tangens van een waarde die is vermenigvuldigd door |
| ToString() |
Converteert de numerieke waarde van dit exemplaar naar de equivalente tekenreeksweergave. |
| ToString(IFormatProvider) |
Converteert de numerieke waarde van dit exemplaar naar de equivalente tekenreeksweergave met behulp van de opgegeven cultuurspecifieke notatiegegevens. |
| ToString(String, IFormatProvider) |
Converteert de numerieke waarde van dit exemplaar naar de equivalente tekenreeksweergave met behulp van de opgegeven indeling en cultuurspecifieke notatiegegevens. |
| ToString(String) |
Converteert de numerieke waarde van dit exemplaar naar de equivalente tekenreeksweergave, met behulp van de opgegeven indeling. |
| Truncate(Double) |
Kapt een waarde af. |
| TryFormat(Span<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider) |
Probeert de waarde van het huidige exemplaar op te maken als UTF-8 in het opgegeven bereik van bytes. |
| TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider) |
Hiermee wordt geprobeerd de waarde van het huidige dubbele exemplaar op te maken in de opgegeven reeks tekens. |
| TryParse(ReadOnlySpan<Byte>, Double) |
Hiermee wordt geprobeerd een UTF-8-tekenbereik te converteren dat de tekenreeksweergave van een getal bevat naar het equivalent van een getal met dubbele precisie. |
| TryParse(ReadOnlySpan<Byte>, IFormatProvider, Double) |
Probeert een reeks UTF-8 tekens te parseren in een waarde. |
| TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, Double) |
Probeert een reeks UTF-8 tekens te parseren in een waarde. |
| TryParse(ReadOnlySpan<Char>, Double) |
Converteert de spanweergave van een getal in een opgegeven stijl en cultuurspecifieke notatie naar het equivalent van een drijvendekommagetal met dubbele precisie. Een retourwaarde geeft aan of de conversie is geslaagd of mislukt. |
| TryParse(ReadOnlySpan<Char>, IFormatProvider, Double) |
Probeert een reeks tekens te parseren in een waarde. |
| TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Double) |
Converteert een tekenspanne met de tekenreeksweergave van een getal in een opgegeven stijl en cultuurspecifieke notatie naar het getal-equivalent met dubbele precisie. Een retourwaarde geeft aan of de conversie is geslaagd of mislukt. |
| TryParse(String, Double) |
Converteert de tekenreeksweergave van een getal naar het equivalent van een getal met dubbele precisie. Een retourwaarde geeft aan of de conversie is geslaagd of mislukt. |
| TryParse(String, IFormatProvider, Double) |
Probeert een tekenreeks te parseren in een waarde. |
| TryParse(String, NumberStyles, IFormatProvider, Double) |
Converteert de tekenreeksweergave van een getal in een opgegeven stijl en cultuurspecifieke notatie naar het equivalent van een drijvendekommagetal met dubbele precisie. Een retourwaarde geeft aan of de conversie is geslaagd of mislukt. |
Operators
| Name | Description |
|---|---|
| Equality(Double, Double) |
Retourneert een waarde die aangeeft of twee opgegeven Double waarden gelijk zijn. |
| GreaterThan(Double, Double) |
Retourneert een waarde die aangeeft of een opgegeven Double waarde groter is dan een andere opgegeven Double waarde. |
| GreaterThanOrEqual(Double, Double) |
Retourneert een waarde die aangeeft of een opgegeven Double waarde groter is dan of gelijk is aan een andere opgegeven Double waarde. |
| Inequality(Double, Double) |
Retourneert een waarde die aangeeft of twee opgegeven Double waarden niet gelijk zijn. |
| LessThan(Double, Double) |
Retourneert een waarde die aangeeft of een opgegeven Double waarde kleiner is dan een andere opgegeven Double waarde. |
| LessThanOrEqual(Double, Double) |
Retourneert een waarde die aangeeft of een opgegeven Double waarde kleiner is dan of gelijk is aan een andere opgegeven Double waarde. |
Expliciete interface-implementaties
| Name | Description |
|---|---|
| IAdditionOperators<Double,Double,Double>.Addition(Double, Double) |
Voegt twee waarden samen om de som te berekenen. |
| IAdditiveIdentity<Double,Double>.AdditiveIdentity |
Hiermee haalt u de additieve identiteit van het huidige type op. |
| IBinaryNumber<Double>.AllBitsSet |
Hiermee haalt u een exemplaar op van het binaire type waarin alle bits zijn ingesteld. |
| IBitwiseOperators<Double,Double,Double>.BitwiseAnd(Double, Double) |
Berekent de bitsgewijze en van twee waarden. |
| IBitwiseOperators<Double,Double,Double>.BitwiseOr(Double, Double) |
Berekent de bitsgewijze of twee waarden. |
| IBitwiseOperators<Double,Double,Double>.ExclusiveOr(Double, Double) |
Berekent de exclusieve of twee waarden. |
| IBitwiseOperators<Double,Double,Double>.OnesComplement(Double) |
Berekent de een-complementweergave van een bepaalde waarde. |
| IComparable.CompareTo(Object) |
Vergelijkt het huidige exemplaar met een ander object van hetzelfde type en retourneert een geheel getal dat aangeeft of de huidige instantie voorafgaat aan, volgt of zich op dezelfde positie in de sorteervolgorde bevindt als het andere object. |
| IConvertible.GetTypeCode() |
Retourneert het TypeCode voor dit exemplaar. |
| IConvertible.ToBoolean(IFormatProvider) |
Zie voor een beschrijving van dit lid ToBoolean(IFormatProvider). |
| IConvertible.ToByte(IFormatProvider) |
Zie voor een beschrijving van dit lid ToByte(IFormatProvider). |
| IConvertible.ToChar(IFormatProvider) |
Deze conversie wordt niet ondersteund. Als u deze methode probeert te gebruiken, wordt er een InvalidCastException. |
| IConvertible.ToDateTime(IFormatProvider) |
Deze conversie wordt niet ondersteund. Als u deze methode probeert te gebruiken, wordt er een InvalidCastException. |
| IConvertible.ToDecimal(IFormatProvider) |
Zie voor een beschrijving van dit lid ToDecimal(IFormatProvider). |
| IConvertible.ToDouble(IFormatProvider) |
Zie voor een beschrijving van dit lid ToDouble(IFormatProvider). |
| IConvertible.ToInt16(IFormatProvider) |
Zie voor een beschrijving van dit lid ToInt16(IFormatProvider). |
| IConvertible.ToInt32(IFormatProvider) |
Zie voor een beschrijving van dit lid ToInt32(IFormatProvider). |
| IConvertible.ToInt64(IFormatProvider) |
Zie voor een beschrijving van dit lid ToInt64(IFormatProvider). |
| IConvertible.ToSByte(IFormatProvider) |
Zie voor een beschrijving van dit lid ToSByte(IFormatProvider). |
| IConvertible.ToSingle(IFormatProvider) |
Zie voor een beschrijving van dit lid ToSingle(IFormatProvider). |
| IConvertible.ToType(Type, IFormatProvider) |
Zie voor een beschrijving van dit lid ToType(Type, IFormatProvider). |
| IConvertible.ToUInt16(IFormatProvider) |
Zie voor een beschrijving van dit lid ToUInt16(IFormatProvider). |
| IConvertible.ToUInt32(IFormatProvider) |
Zie voor een beschrijving van dit lid ToUInt32(IFormatProvider). |
| IConvertible.ToUInt64(IFormatProvider) |
Zie voor een beschrijving van dit lid ToUInt64(IFormatProvider). |
| IDecrementOperators<Double>.Decrement(Double) |
Een waarde verlagen. |
| IDivisionOperators<Double,Double,Double>.Division(Double, Double) |
Verdeelt de ene waarde door een andere om het quotiënt te berekenen. |
| IFloatingPoint<Double>.GetExponentByteCount() |
Hiermee haalt u het aantal bytes op dat wordt geschreven als onderdeel van TryWriteExponentLittleEndian(Span<Byte>, Int32). |
| IFloatingPoint<Double>.GetExponentShortestBitLength() |
Hiermee haalt u de lengte, in bits, van de kortste twee's complementweergave van de huidige exponent. |
| IFloatingPoint<Double>.GetSignificandBitLength() |
Hiermee wordt de lengte, in bits, van de huidige significand. |
| IFloatingPoint<Double>.GetSignificandByteCount() |
Hiermee haalt u het aantal bytes op dat wordt geschreven als onderdeel van TryWriteSignificandLittleEndian(Span<Byte>, Int32). |
| IFloatingPoint<Double>.TryWriteExponentBigEndian(Span<Byte>, Int32) |
Probeert de huidige exponent, in big-endian-indeling, naar een bepaalde periode te schrijven. |
| IFloatingPoint<Double>.TryWriteExponentLittleEndian(Span<Byte>, Int32) |
Probeert de huidige exponent, in little-endian-indeling, naar een bepaalde periode te schrijven. |
| IFloatingPoint<Double>.TryWriteSignificandBigEndian(Span<Byte>, Int32) |
Probeert het huidige teken te schrijven, in big-endian-indeling, naar een bepaalde periode. |
| IFloatingPoint<Double>.TryWriteSignificandLittleEndian(Span<Byte>, Int32) |
Probeert het huidige teken te schrijven, in little-endian-indeling, naar een bepaalde periode. |
| IFloatingPointConstants<Double>.E |
Hiermee haalt u de wiskundige constante |
| IFloatingPointConstants<Double>.Pi |
Hiermee haalt u de wiskundige constante |
| IFloatingPointConstants<Double>.Tau |
Hiermee haalt u de wiskundige constante |
| IFloatingPointIeee754<Double>.Epsilon |
Hiermee haalt u de kleinste waarde op die kan worden toegevoegd aan |
| IFloatingPointIeee754<Double>.NaN |
Hiermee haalt u een waarde op die staat voor |
| IFloatingPointIeee754<Double>.NegativeInfinity |
Hiermee wordt een waarde opgehaald die een negatieve |
| IFloatingPointIeee754<Double>.NegativeZero |
Hiermee wordt een waarde opgehaald die een negatieve |
| IFloatingPointIeee754<Double>.PositiveInfinity |
Hiermee wordt een waarde opgehaald die positief |
| IIncrementOperators<Double>.Increment(Double) |
Hiermee wordt een waarde verhoogd. |
| IMinMaxValue<Double>.MaxValue |
Hiermee wordt de maximumwaarde van het huidige type opgehaald. |
| IMinMaxValue<Double>.MinValue |
Hiermee wordt de minimumwaarde van het huidige type opgehaald. |
| IModulusOperators<Double,Double,Double>.Modulus(Double, Double) |
Verdeelt twee waarden samen om hun modulus of restgetal te berekenen. |
| IMultiplicativeIdentity<Double,Double>.MultiplicativeIdentity |
Hiermee haalt u de vermenigvuldigende identiteit van het huidige type op. |
| IMultiplyOperators<Double,Double,Double>.Multiply(Double, Double) |
Vermenigvuldigt twee waarden samen om het product te berekenen. |
| INumberBase<Double>.IsCanonical(Double) |
Bepaalt of een waarde zich in de canonieke weergave bevindt. |
| INumberBase<Double>.IsComplexNumber(Double) |
Bepaalt of een waarde een complex getal vertegenwoordigt. |
| INumberBase<Double>.IsImaginaryNumber(Double) |
Bepaalt of een waarde een puur imaginair getal vertegenwoordigt. |
| INumberBase<Double>.IsZero(Double) |
Bepaalt of een waarde nul is. |
| INumberBase<Double>.One |
Hiermee haalt u de waarde |
| INumberBase<Double>.Radix |
Bepaalt de radix of basis voor een type. |
| INumberBase<Double>.TryConvertFromChecked<TOther>(TOther, Double) |
Vertegenwoordigt een drijvendekommagetal met dubbele precisie. |
| INumberBase<Double>.TryConvertFromSaturating<TOther>(TOther, Double) |
Vertegenwoordigt een drijvendekommagetal met dubbele precisie. |
| INumberBase<Double>.TryConvertFromTruncating<TOther>(TOther, Double) |
Vertegenwoordigt een drijvendekommagetal met dubbele precisie. |
| INumberBase<Double>.TryConvertToChecked<TOther>(Double, TOther) |
Probeert een exemplaar van het huidige type te converteren naar een ander type, waardoor een overloop-uitzondering wordt gegenereerd voor waarden die buiten het vertegenwoordigbare bereik van het huidige type vallen. |
| INumberBase<Double>.TryConvertToSaturating<TOther>(Double, TOther) |
Hiermee wordt geprobeerd een exemplaar van het huidige type te converteren naar een ander type, waarbij alle waarden die buiten het vertegenwoordigbare bereik van het huidige type vallen, worden verzadigingswaarden weergegeven. |
| INumberBase<Double>.TryConvertToTruncating<TOther>(Double, TOther) |
Hiermee wordt geprobeerd een exemplaar van het huidige type te converteren naar een ander type, waarbij alle waarden worden afgekapt die buiten het vertegenwoordigbare bereik van het huidige type vallen. |
| INumberBase<Double>.Zero |
Hiermee haalt u de waarde |
| ISignedNumber<Double>.NegativeOne |
Hiermee haalt u de waarde |
| ISubtractionOperators<Double,Double,Double>.Subtraction(Double, Double) |
Trekt twee waarden af om het verschil te berekenen. |
| IUnaryNegationOperators<Double,Double>.UnaryNegation(Double) |
Berekent de unaire negatie van een waarde. |
| IUnaryPlusOperators<Double,Double>.UnaryPlus(Double) |
Berekent het unaire plusteken van een waarde. |
Van toepassing op
Veiligheid thread
Alle leden van dit type zijn thread-veilig. Leden die de exemplaarstatus lijken te wijzigen, retourneren daadwerkelijk een nieuw exemplaar dat is geïnitialiseerd met de nieuwe waarde. Net als bij elk ander type moet lezen en schrijven naar een gedeelde variabele die een exemplaar van dit type bevat, worden beveiligd door een vergrendeling om de veiligheid van threads te garanderen.
