Double Struktura
Definice
Důležité
Některé informace platí pro předběžně vydaný produkt, který se může zásadně změnit, než ho výrobce nebo autor vydá. Microsoft neposkytuje žádné záruky, výslovné ani předpokládané, týkající se zde uváděných informací.
Představuje číslo s plovoucí desetinnou čárkou s dvojitou přesností.
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- Dědičnost
- Atributy
- Implementuje
-
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>
Příklady
Následující příklad kódu znázorňuje použití 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
Poznámky
Typ hodnoty Double představuje 64bitové číslo s dvojitou přesností s hodnotami v rozsahu od záporné 1,79769313486232e308 na kladné 1,79769313486232e308, stejně jako kladné nebo záporné nuly, PositiveInfinity, NegativeInfinitya ne číslo (NaN). Má představovat hodnoty, které jsou extrémně velké (například vzdálenosti mezi planetami nebo galaxiemi) nebo extrémně malé (například molekulární hmotnost látky v kg) a které jsou často nepřesné (například vzdálenost od země k jinému slunečnímu systému). Typ Double odpovídá standardu IEC 60559:1989 (IEEE 754) pro binární plovoucí desetinnou čárku.
Reprezentace a přesnost čísel s plovoucí desetinnou čárkou
Datový typ Double ukládá hodnoty s plovoucí desetinnou čárkou s dvojitou přesností v 64bitovém binárním formátu, jak je znázorněno v následující tabulce:
| Část | Bity |
|---|---|
| signifikand nebo mantisa | 0-51 |
| Exponent | 52-62 |
| Znaménko (0 = kladné, 1 = záporné) | 63 |
Stejně jako desetinné zlomky nemohou přesně reprezentovat některé desetinné hodnoty (například 1/3 nebo Math.PI), binární zlomky nemohou představovat některé desetinné hodnoty. Například 1/10, který je reprezentován přesně jako desetinné číslo 0,1, je reprezentován jako binární zlomek ,001100110011 se vzorem "0011", který se opakuje donekonečna. V tomto případě hodnota s plovoucí desetinnou čárkou reprezentuje číslo nepřesně. Provádění dalších matematických operací s původní hodnotou s plovoucí řádovou čárkou má často tendenci zvyšovat nepřesnost. Pokud například porovnáte výsledek násobení 0,1 o 10 a přičtením 0,1 na 0,1 devětkrát, uvidíte, že sčítání, protože zahrnovalo osm dalších operací, vytvořilo méně přesný výsledek. (Před .NET 10 se tato rozdílnost projeví pouze v případě, že zobrazíte dvě hodnoty Double pomocí řetězce standardního číselného formátu, který zobrazuje až 17 číslic přesnosti podporovaných typem 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
Protože některá čísla nemohou být reprezentována přesně jako binární zlomkové hodnoty, mohou čísla s plovoucí desetinnou čárkou pouze přibližně reprezentovat reálná čísla.
Všechny čísla s pohyblivou desetinnou čárkou mají také omezené množství významných číslic, což také určuje, jak přesně hodnota s pohyblivou desetinnou čárkou přibližuje k reálnému číslu. Hodnota Double má až 15 desetinných míst přesnosti, i když se interně udržuje maximálně 17 číslic. To znamená, že některé operace s plovoucí desetinnou čárkou nemusí mít dostatečnou přesnost ke změně hodnoty s plovoucí desetinnou čárkou. V následujícím příkladu je uvedena ukázka. Definuje velmi velkou plovoucí hodnotu a poté k ní přidá součin Double.Epsilon a jednoho kvadrilionu. Produkt je však příliš malý na úpravu původní hodnoty v plovoucí řádové čárce. Nejméně významná číslice je tisíciny, zatímco nejvýznamnější číslice v produktu je 10-309.
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
Omezená přesnost plovoucího čísla má několik důsledků:
Dvě čísla s plovoucí desetinnou čárkou, která se zdají být pro určitou přesnost stejná, nemusí být považována za stejná, protože jejich nejméně významné číslice se liší. V následujícím příkladu se sečtou řady čísel a jejich celkový součet se porovná s očekávaným součtem.
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).Tyto dvě hodnoty jsou nerovné kvůli ztrátě přesnosti během operací sčítání. V takovém případě je možné problém vyřešit voláním metody Math.Round(Double, Int32), která před porovnáním zaokrouhlí hodnoty Double na požadovanou přesnost.
Matematická nebo porovnávací operace, která používá číslo s plovoucí desetinnou čárkou, nemusí přinést stejný výsledek, pokud se použije desetinné číslo, protože binární číslo s plovoucí desetinnou čárkou se nemusí shodovat s desetinným číslem. Předchozí příklad to ilustroval zobrazením výsledku vynásobení 0,1 deseti a přičtením 0,1.
Pokud je přesnost v numerických operacích s desetinnými hodnotami důležitá, můžete místo typu Decimal použít Double typ. Pokud je přesnost v numerických operacích s celočíselnými hodnotami nad rámec rozsahu typů Int128UInt128 důležitá, použijte typ BigInteger.
Single hodnoty mají menší přesnost než Double hodnoty. Hodnota Single převedená na zdánlivě ekvivalentní Double hodnotu se často nerovná Double z důvodu rozdílů v přesnosti. V následujícím příkladu je výsledek identických operací dělení přiřazen k Double a Single hodnotě. Po přetypování hodnoty Single na Doubleukazuje porovnání dvou hodnot, že jsou nerovné.
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: FalseChcete-li se tomuto problému vyhnout, použijte Double místo datového typu Single nebo použijte metodu Round, aby obě hodnoty měly stejnou přesnost.
Kromě toho se výsledek aritmetických operací a operací přiřazení s Double hodnotami může mírně lišit podle platformy kvůli ztrátě přesnosti Double typu. Například výsledek přiřazení hodnoty literálu Double se může lišit v 32bitové a 64bitové verzi .NET. Následující příklad ukazuje tento rozdíl, když literálová hodnota -4,42330604244772E-305 a proměnná, jejíž hodnota je -4,42330604244772E-305 jsou přiřazeny proměnné Double. Všimněte si, že výsledek metody Parse(String) v tomto případě netrpí ztrátou přesnosti.
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
Testování rovnosti
Aby byly považovány za stejné, musí dvě Double hodnoty představovat stejné hodnoty. Vzhledem k rozdílům v přesnosti mezi hodnotami nebo kvůli ztrátě přesnosti jedné nebo obou hodnot se však stává, že hodnoty s plovoucí desetinnou čárkou, u nichž se očekává, že budou identické, často nejsou stejné kvůli rozdílům v jejich nejméně významných číslicích. Výsledkem je, že volání Equals metody určující, zda jsou dvě hodnoty stejné, nebo volání CompareTo metody k určení vztahu mezi dvěma Double hodnotami, často poskytují neočekávané výsledky. To je zřejmé v následujícím příkladu, kdy se dvě zdánlivě stejné Double hodnoty ukázaly jako nerovné, protože první má 15 číslic přesnosti, zatímco druhý má 17.
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
V případech, kdy ztráta přesnosti pravděpodobně ovlivní výsledek porovnání, můžete přijmout některou z následujících alternativ volání Equals nebo CompareTo metody:
Zavolejte metodu Math.Round, abyste zajistili, že obě hodnoty mají stejnou přesnost. Následující příklad upraví předchozí příklad tak, aby tento přístup používal tak, aby dvě desetinné hodnoty byly ekvivalentní.
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: TrueProblém přesnosti se stále týká zaokrouhlování středních hodnot. Další informace najdete v metodě Math.Round(Double, Int32, MidpointRounding).
Otestujte přibližnou rovnost místo rovnosti. To vyžaduje, abyste definovali buď absolutní hodnotu, o kterou se tyto dvě hodnoty mohou lišit, ale stále se rovnají, nebo definujete relativní množství, o které se menší hodnota může od větší hodnoty lišit.
Warning
Double.Epsilon se při testování rovnosti někdy používá jako absolutní míra vzdálenosti mezi dvěma Double hodnotami. Double.Epsilon však měří nejmenší možnou hodnotu, kterou lze přičíst k, nebo odečíst od, Double, jehož hodnota je nula. U většiny kladných a záporných hodnot Double je hodnota Double.Epsilon příliš malá, aby se zjistila. Proto s výjimkou hodnot, které jsou nula, nedoporučujeme jeho použití v testech rovnosti.
Následující příklad používá druhý přístup k definování
IsApproximatelyEqualmetody, která testuje relativní rozdíl mezi dvěma hodnotami. Metoda dělíMath.Max(value1, value2), aby bylo porovnání relativní vůči větší hodnotě (podle velikosti) ze dvou, což umístí výsledek do správného řádu velikosti. PokudMath.Maxvrátí nulu (což se stane, když jedna hodnota je nula a druhá je záporná), vrátí metoda zpětMath.Min(value1, value2)k použití nenulové hodnoty jako dělitele. Také kontrastuje výsledky volání metodyIsApproximatelyEquala metody Equals(Double).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
Hodnoty a výjimky s plovoucí řádovou čárkou
Na rozdíl od operací s celočíselnými typy, které vyvolají DivideByZeroException při dělení nulou nebo OverflowException při přetečení v kontrolovaném kontextu, operace s hodnotami řádové čárky nevyvolává výjimky. Ve výjimečných situacích je výsledkem operace s plovoucí desetinnou čárkou nula, kladné nekonečno, záporné nekonečno nebo ne číslo (NaN):
Pokud je výsledek operace s plovoucí desetinnou čárkou příliš malý pro cílový formát, výsledek se stává nula. K tomu může dojít, když se vynásobí dvě velmi malá čísla, jak ukazuje následující příklad.
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: TruePokud velikost výsledku operace s plovoucí desetinnou čárkou překročí rozsah cílového formátu, výsledek operace je PositiveInfinity nebo NegativeInfinity, v závislosti na znaménku výsledku. Výsledek operace přetékající Double.MaxValue je PositiveInfinitya operace přetékající Double.MinValue je NegativeInfinity, jak ukazuje následující příklad.
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 je také výsledkem dělení nulou pro kladný dividenda a NegativeInfinity je výsledkem dělení nulou pro záporný dividenda.
Pokud je operace s plovoucí desetinnou čárkou neplatná, výsledek operace je NaN. Například NaN vzniká z následujících operací:
Dělení nulou, kde dělenec je nula. Všimněte si, že jiné případy dělení nulou mají za následek PositiveInfinity nebo NegativeInfinity.
Jakákoli operace s plovoucí desetinnou čárkou a neplatným vstupem. Například volání Math.Sqrt metoda se zápornou hodnotou vrátí NaN, stejně jako volání Math.Acos metoda s hodnotou, která je větší než jedna nebo menší než záporná.
Jakákoli operace s argumentem, jehož hodnota je Double.NaN.
Převody typů
Struktura Double nedefinuje žádné explicitní ani implicitní převodní operátory; místo toho kompilátor implementuje převody.
Převod hodnoty libovolného primitivního číselného typu na Double je rozšiřující převod, a proto nevyžaduje explicitní operátor přetypování nebo volání metody převodu, pokud to kompilátor explicitně nevyžaduje. Kompilátor jazyka C# například vyžaduje operátor přetypování pro převody z Decimal na Double, zatímco kompilátor jazyka Visual Basic ne. Následující příklad převede minimální nebo maximální hodnotu jiných primitivních číselných typů na 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)
Kromě toho se hodnoty SingleSingle.NaN, Single.PositiveInfinitya Single.NegativeInfinity převedou na Double.NaN, Double.PositiveInfinitya Double.NegativeInfinity.
Všimněte si, že převod hodnoty některých číselných typů na hodnotu Double může zahrnovat ztrátu přesnosti. Jak ukazuje příklad, při převodu hodnot Decimal, Int64a UInt64 na hodnoty Double může dojít ke ztrátě přesnosti.
Převod hodnoty Double na hodnotu jakéhokoli jiného primitivního číselného datového typu je zužující převod a vyžaduje operátor přetypování (v jazyce C#), metodu převodu (v jazyce Visual Basic) nebo volání metody Convert. Hodnoty, které jsou mimo rozsah cílového datového typu, definované vlastnostmi MinValue a MaxValue tohoto typu, se chovají, jak je znázorněno v následující tabulce.
| Typ cíle | Result |
|---|---|
| Libovolný celočíselný typ | Výjimka OverflowException, pokud dojde k převodu v kontrolovaném kontextu. Pokud k převodu dojde v neověřeném kontextu (což je výchozí nastavení v jazyce C#), operace proběhne úspěšně, ale dojde k přetečení hodnoty. |
| Decimal | Výjimka OverflowException. |
| Single |
Single.NegativeInfinity pro záporné hodnoty. Single.PositiveInfinity pro kladné hodnoty. |
Kromě toho Double.NaN, Double.PositiveInfinitya Double.NegativeInfinity vyvolají OverflowException pro převody na celá čísla v kontrolovaném kontextu, ale tyto hodnoty přetékají při převodu na celá čísla v nekontrolovaném kontextu. Pro převody na Decimalvždy vyvolají OverflowException. Při převodech na Singlese přemění na Single.NaN, Single.PositiveInfinitya Single.NegativeInfinity, v uvedeném pořadí.
Ztráta přesnosti může mít za následek převod hodnoty Double na jiný číselný typ. V případě převodu na některý z integrálních typů, jak ukazuje výstup z příkladu, se zlomková komponenta ztratí, když je hodnota Double buď zaokrouhlená (jako v Visual Basic), nebo zkrácená (jako v jazyce C#). Pro převody na hodnoty Decimal a Single nemusí mít hodnota Double přesné vyjádření v cílovém datovém typu.
Následující příklad převede počet Double hodnot na několik dalších číselných typů. Převody probíhají v kontrolovaném kontextu v jazyce Visual Basic (výchozí), v jazyce C# (kvůli zaškrtnutému klíčovému slovu) a v jazyce F# (kvůli modulu Checked). Výstup z příkladu ukazuje výsledek pro převody jak v zaškrtnutém, tak i nezaškrtnutém kontextu. Převody v nezaškrtnutém kontextu v jazyce Visual Basic můžete provést kompilováním přepínače kompilátoru /removeintchecks+, v jazyce C# zakomentováním příkazu checked a v jazyce F# zakomentováním příkazu open Checked.
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)
Další informace o převodu číselných typů naleznete v tématu Type Conversion in .NET and Type Conversion Tables.
Funkce s plovoucí čárkou
Struktura Double a související typy poskytují metody pro provádění operací v následujících oblastech:
Porovnání hodnot. Metodu Equals můžete volat, abyste zjistili, zda jsou dvě Double hodnoty stejné, nebo CompareTo metodu pro určení vztahu mezi dvěma hodnotami.
Struktura Double také podporuje úplnou sadu relačních operátorů. Můžete například otestovat rovnost nebo nerovnost nebo určit, jestli je jedna hodnota větší nebo rovna jiné. Pokud je jeden z operandů číselný typ jiný než Double, převede se na Double před provedením porovnání.
Warning
Vzhledem k rozdílům v přesnosti můžou být dvě Double hodnoty, u kterých očekáváte, že budou stejné, budou nerovné, což má vliv na výsledek porovnání. Informace o porovnávání dvou Double hodnot najdete v části Testování rovnosti .
Můžete také volat metody IsNaN, IsInfinity, IsPositiveInfinitya IsNegativeInfinity pro testování těchto speciálních hodnot.
matematické operace. Běžné aritmetické operace, jako jsou sčítání, odčítání, násobení a dělení, jsou implementovány kompilátory jazyka a instrukcemi CIL (Common Intermediate Language), nikoli metodami Double. Pokud je jeden z operandů v matematické operaci jiný číselný typ než Double, je před provedením operace převeden na Double. Výsledek operace je také hodnota Double.
Jiné matematické operace lze provádět voláním metod
static(Sharedv Visual Basic) ve třídě System.Math. Zahrnuje další metody běžně používané pro aritmetické metody (například Math.Abs, Math.Signa Math.Sqrt), geometrii (například Math.Cos a Math.Sin) a výpočet (například Math.Log).Můžete také manipulovat s jednotlivými bity v hodnotě Double. Metoda BitConverter.DoubleToInt64Bits zachovává bitový vzor hodnoty Double v 64bitovém celočíselném čísle. Metoda BitConverter.GetBytes(Double) vrátí svůj bitový vzor v bajtovém poli.
zaokrouhlování. Zaokrouhlování se často používá jako technika pro snížení dopadu rozdílů mezi hodnotami způsobených problémy plovoucí desetinné reprezentace a problémy s přesností. Hodnotu Double můžete zaokrouhlit voláním metody Math.Round.
Formátování. Hodnotu Double můžete převést na řetězcovou reprezentaci voláním metody ToString nebo pomocí funkce složeného formátování. Informace o tom, jak formátovací řetězce řídí řetězcové vyjádření hodnot s plovoucí desetinnou čárkou, naleznete v tématu Standardní řetězce číselného formátu a vlastní řetězce číselného formátu.
parsování řetězců. Řetězcovou reprezentaci hodnoty s plovoucí desetinnou čárkou můžete převést na hodnotu Double voláním metody Parse nebo TryParse. Pokud operace analýzy selže, vyvolá metoda Parse výjimku, zatímco metoda TryParse vrátí
false.Převod typu. Struktura Double poskytuje explicitní implementaci rozhraní pro rozhraní IConvertible, které podporuje převod mezi libovolnými dvěma standardními datovými typy .NET. Kompilátory jazyků také podporují implicitní převod hodnot všech ostatních standardních číselných typů na Double hodnoty. Převod hodnoty libovolného standardního číselného typu na Double je rozšiřující převod a nevyžaduje použití operátoru přetypování nebo metody převodu.
Převod hodnot Int64 a Single však může zahrnovat ztrátu přesnosti. Následující tabulka uvádí rozdíly v přesnosti pro každý z těchto typů:
Typ Maximální přesnost Vnitřní přesnost Double 15 17 Int64 19 desítkových číslic 19 desítkových číslic Single 7 desítkových číslic 9 desítkových číslic Problém přesnosti nejčastěji ovlivňuje hodnoty Single, které jsou převáděny na hodnoty Double. V následujícím příkladu jsou dvě hodnoty vytvořené identickými operacemi dělení nerovné, protože jedna z hodnot je hodnota s plovoucí desetinnou čárkou s jednoduchou přesností převedená na 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
Pole
| Name | Description |
|---|---|
| E |
Představuje přirozený logaritmický základ určený konstantou e. |
| Epsilon |
Představuje nejmenší kladnou Double hodnotu, která je větší než nula. Toto pole je konstantní. |
| MaxValue |
Představuje největší možnou Doublehodnotu . Toto pole je konstantní. |
| MinValue |
Představuje nejmenší možnou Doublehodnotu . Toto pole je konstantní. |
| NaN |
Představuje hodnotu, která není číslo ( |
| NegativeInfinity |
Představuje záporné nekonečno. Toto pole je konstantní. |
| NegativeZero |
Představuje číslo záporné nuly (-0). |
| Pi |
Představuje poměr obvodu kruhu k jeho průměru určenému konstantou π. |
| PositiveInfinity |
Představuje kladné nekonečno. Toto pole je konstantní. |
| Tau |
Představuje počet radiánů na jednom turnu určený konstantou, τ. |
Metody
| Name | Description |
|---|---|
| Abs(Double) |
Vypočítá absolutní hodnotu. |
| Acos(Double) |
Vypočítá arkus kosinus hodnoty. |
| Acosh(Double) |
Vypočítá hyperbolický arkus kosinus hodnoty. |
| AcosPi(Double) |
Vypočítá arkus kosinus hodnoty a vydělí výsledek |
| Asin(Double) |
Vypočítá arkus sinus hodnoty. |
| Asinh(Double) |
Vypočítá hyperbolický arkus sinus hodnoty. |
| AsinPi(Double) |
Vypočítá arkus sinus hodnoty a vydělí výsledek |
| Atan(Double) |
Vypočítá arkus tangens hodnoty. |
| Atan2(Double, Double) |
Vypočítá arkus tangens podílu dvou hodnot. |
| Atan2Pi(Double, Double) |
Vypočítá arkus tangens pro podíl dvou hodnot a vydělí výsledek |
| Atanh(Double) |
Vypočítá hyperbolický arkustangens hodnoty. |
| AtanPi(Double) |
Vypočítá arkus tangens hodnoty a vydělí výsledek pí. |
| BitDecrement(Double) |
Vrátí největší hodnotu, která porovnává menší než zadanou hodnotu. |
| BitIncrement(Double) |
Vrátí nejmenší hodnotu, která porovnává větší než zadaná hodnota. |
| Cbrt(Double) |
Vypočítá kořen datové krychle hodnoty. |
| Ceiling(Double) |
Vypočítá strop hodnoty. |
| Clamp(Double, Double, Double) |
Uchytá hodnotu na inkluzivní minimální a maximální hodnotu. |
| ClampNative(Double, Double, Double) |
Uchytá hodnotu na inkluzivní minimální a maximální hodnotu pomocí chování specifického pro platformu a |
| CompareTo(Double) |
Porovná tuto instanci se zadaným číslem s plovoucí desetinnou čárkou s dvojitou přesností a vrátí celé číslo, které určuje, zda je hodnota této instance menší, rovna nebo větší než hodnota zadaného čísla s plovoucí desetinnou čárkou s dvojitou přesností. |
| CompareTo(Object) |
Porovná tuto instanci se zadaným objektem a vrátí celé číslo, které určuje, zda je hodnota této instance menší, rovna nebo větší než hodnota zadaného objektu. |
| ConvertToInteger<TInteger>(Double) |
Převede hodnotu na zadaný celočíselnou typ pomocí sytosti při přetečení. |
| ConvertToIntegerNative<TInteger>(Double) |
Převede hodnotu na zadaný celočíselnou typ pomocí chování specifického pro platformu při přetečení. |
| CopySign(Double, Double) |
Zkopíruje znaménko hodnoty na znaménko jiné hodnoty. |
| Cos(Double) |
Vypočítá kosinus hodnoty. |
| Cosh(Double) |
Vypočítá hyperbolický kosinus hodnoty. |
| CosPi(Double) |
Vypočítá kosinus hodnoty, která byla násobkem |
| CreateChecked<TOther>(TOther) |
Vytvoří instanci aktuálního typu z hodnoty, která vyvolá výjimku přetečení pro všechny hodnoty, které spadají mimo reprezentovatelný rozsah aktuálního typu. |
| CreateSaturating<TOther>(TOther) |
Vytvoří instanci aktuálního typu z hodnoty, která saturuje všechny hodnoty, které spadají mimo reprezentovatelný rozsah aktuálního typu. |
| CreateTruncating<TOther>(TOther) |
Vytvoří instanci aktuálního typu z hodnoty a zkrátí všechny hodnoty, které spadají mimo reprezentovatelný rozsah aktuálního typu. |
| DegreesToRadians(Double) |
Převede danou hodnotu ze stupňů na radiány. |
| Equals(Double) |
Vrátí hodnotu určující, zda tato instance a zadaný Double objekt představují stejnou hodnotu. |
| Equals(Object) |
Vrátí hodnotu určující, zda je tato instance rovna zadanému objektu. |
| Exp(Double) |
|
| Exp10(Double) |
|
| Exp10M1(Double) |
|
| Exp2(Double) |
|
| Exp2M1(Double) |
|
| ExpM1(Double) |
|
| Floor(Double) |
Vypočítá podlahu hodnoty. |
| FusedMultiplyAdd(Double, Double, Double) |
Vypočítá součet násobení tří hodnot. |
| GetHashCode() |
Vrátí kód hash pro tuto instanci. |
| GetTypeCode() | |
| Hypot(Double, Double) |
Vypočítá hypotenuse zadanou dvě hodnoty představující délky kratších stran v pravoúhlém trojúhelníku. |
| Ieee754Remainder(Double, Double) |
Vypočítá zbytek dvou hodnot podle specifikace IEEE 754. |
| ILogB(Double) |
Vypočítá celočíselnou logaritmus hodnoty. |
| IsEvenInteger(Double) |
Určuje, zda hodnota představuje sudé celočíselné číslo. |
| IsFinite(Double) |
Určuje, zda je zadaná hodnota konečná (nula, podnormální hodnota nebo normální). |
| IsInfinity(Double) |
Vrátí hodnotu určující, jestli se zadané číslo vyhodnotí jako záporné nebo kladné nekonečno. |
| IsInteger(Double) |
Určuje, zda hodnota představuje celočíselnou hodnotu. |
| IsNaN(Double) |
Vrátí hodnotu, která určuje, zda zadaná hodnota není číslo (NaN). |
| IsNegative(Double) |
Určuje, zda je zadaná hodnota záporná. |
| IsNegativeInfinity(Double) |
Vrátí hodnotu určující, jestli se zadané číslo vyhodnotí jako záporné nekonečno. |
| IsNormal(Double) |
Určuje, zda je zadaná hodnota normální. |
| IsOddInteger(Double) |
Určuje, zda hodnota představuje liché celočíselné číslo. |
| IsPositive(Double) |
Určuje, jestli je hodnota kladná. |
| IsPositiveInfinity(Double) |
Vrátí hodnotu určující, jestli se zadané číslo vyhodnotí jako kladné nekonečno. |
| IsPow2(Double) |
Určuje, zda je hodnota mocnina dvou. |
| IsRealNumber(Double) |
Určuje, zda hodnota představuje reálné číslo. |
| IsSubnormal(Double) |
Určuje, zda je zadaná hodnota subnormální. |
| Lerp(Double, Double, Double) |
Provede lineární interpolaci mezi dvěma hodnotami na základě dané váhy. |
| Log(Double, Double) |
Vypočítá logaritmus hodnoty v zadaném základu. |
| Log(Double) |
Vypočítá přirozený ( |
| Log10(Double) |
Vypočítá logaritmus hodnoty base-10. |
| Log10P1(Double) |
Vypočítá logaritmus hodnoty se základem 10 plus jedna. |
| Log2(Double) |
Vypočítá protokol 2 hodnoty. |
| Log2P1(Double) |
Vypočítá logaritmus hodnoty base-2 plus jednu. |
| LogP1(Double) |
Vypočítá přirozený |
| Max(Double, Double) |
Porovná dvě hodnoty s výpočty, které jsou větší. |
| MaxMagnitude(Double, Double) |
Porovná dvě hodnoty s výpočty, které jsou větší. |
| MaxMagnitudeNumber(Double, Double) |
Porovná dvě hodnoty k výpočtu, které mají větší velikost a vrátí druhou hodnotu, pokud je |
| MaxNative(Double, Double) |
Porovná dvě hodnoty s výpočtem, což je větší pomocí chování specifického pro platformu a |
| MaxNumber(Double, Double) |
Porovná dvě hodnoty k výpočtu, což je větší a vrátí druhou hodnotu, pokud je |
| Min(Double, Double) |
Porovná dvě hodnoty s výpočetními prostředky, které jsou menší. |
| MinMagnitude(Double, Double) |
Porovná dvě hodnoty s výpočetními prostředky, které jsou menší. |
| MinMagnitudeNumber(Double, Double) |
Porovná dvě hodnoty k výpočtu, které mají menší velikost a vrátí druhou hodnotu, pokud je |
| MinNative(Double, Double) |
Porovná dvě hodnoty s výpočetními prostředky, které jsou menší pomocí chování specifického pro platformu a |
| MinNumber(Double, Double) |
Porovná dvě hodnoty k výpočtu, což je menší a vrátí druhou hodnotu, pokud je |
| MultiplyAddEstimate(Double, Double, Double) |
Vypočítá odhad ( |
| Parse(ReadOnlySpan<Byte>, IFormatProvider) |
Parsuje rozsah znaků UTF-8 do hodnoty. |
| Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider) |
Parsuje rozsah znaků UTF-8 do hodnoty. |
| Parse(ReadOnlySpan<Char>, IFormatProvider) |
Parsuje rozsah znaků do hodnoty. |
| Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider) |
Převede rozsah znaků obsahující řetězcovou reprezentaci čísla v zadaném stylu a formátu specifickém pro jazykovou verzi na ekvivalent čísla s plovoucí desetinnou čárkou s dvojitou přesností. |
| Parse(String, IFormatProvider) |
Převede řetězcovou reprezentaci čísla v zadaném formátu specifickém pro jazykovou verzi na ekvivalent čísla s plovoucí desetinnou čárkou s dvojitou přesností. |
| Parse(String, NumberStyles, IFormatProvider) |
Převede řetězcovou reprezentaci čísla v zadaném stylu a formátu specifickém pro jazykovou verzi na ekvivalent čísla s plovoucí desetinnou čárkou s dvojitou přesností. |
| Parse(String, NumberStyles) |
Převede řetězcovou reprezentaci čísla v zadaném stylu na ekvivalent čísla s plovoucí desetinnou čárkou s dvojitou přesností. |
| Parse(String) |
Převede řetězcovou reprezentaci čísla na ekvivalent čísla s plovoucí desetinnou čárkou s dvojitou přesností. |
| Pow(Double, Double) |
Vypočítá hodnotu vyvolanou na danou mocninu. |
| RadiansToDegrees(Double) |
Převede danou hodnotu z radiánů na stupně. |
| ReciprocalEstimate(Double) |
Vypočítá odhad reciproční hodnoty. |
| ReciprocalSqrtEstimate(Double) |
Vypočítá odhad reciproční druhou odmocninu hodnoty. |
| RootN(Double, Int32) |
Vypočítá n-tý kořen hodnoty. |
| Round(Double, Int32, MidpointRounding) |
Zaokrouhlí hodnotu na zadaný počet desetinných míst pomocí výchozího režimu zaokrouhlování (ToEven). |
| Round(Double, Int32) |
Zaokrouhlí hodnotu na zadaný počet desetinných míst pomocí výchozího režimu zaokrouhlování (ToEven). |
| Round(Double, MidpointRounding) |
Zaokrouhlí hodnotu na nejbližší celé číslo pomocí zadaného režimu zaokrouhlování. |
| Round(Double) |
Zaokrouhlí hodnotu na nejbližší celé číslo pomocí výchozího režimu zaokrouhlování (ToEven). |
| ScaleB(Double, Int32) |
Vypočítá součin hodnoty a jeho základ-radix vyvolaný na zadanou mocninu. |
| Sign(Double) |
Vypočítá znaménko hodnoty. |
| Sin(Double) |
Vypočítá sinus hodnoty. |
| SinCos(Double) |
Vypočítá sinus a kosinus hodnoty. |
| SinCosPi(Double) |
Vypočítá sinus a kosinus hodnoty. |
| Sinh(Double) |
Vypočítá hyperbolický sinus hodnoty. |
| SinPi(Double) |
Vypočítá sinus hodnoty, která byla vynásobená |
| Sqrt(Double) |
Vypočítá druhou odmocninu hodnoty. |
| Tan(Double) |
Vypočítá tangens hodnoty. |
| Tanh(Double) |
Vypočítá hyperbolický tangens hodnoty. |
| TanPi(Double) |
Vypočítá tangens hodnoty, která byla násobkem |
| ToString() |
Převede číselnou hodnotu této instance na ekvivalentní řetězcové vyjádření. |
| ToString(IFormatProvider) |
Převede číselnou hodnotu této instance na ekvivalentní řetězcové vyjádření pomocí zadaných informací o formátu specifickém pro jazykovou verzi. |
| ToString(String, IFormatProvider) |
Převede číselnou hodnotu této instance na ekvivalentní řetězcové vyjádření pomocí zadaného formátu a informací o formátu specifickém pro jazykovou verzi. |
| ToString(String) |
Převede číselnou hodnotu této instance na ekvivalentní řetězcové vyjádření pomocí zadaného formátu. |
| Truncate(Double) |
Zkrátí hodnotu. |
| TryFormat(Span<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider) |
Pokusí se naformátovat hodnotu aktuální instance jako UTF-8 do poskytnutého rozsahu bajtů. |
| TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider) |
Pokusí se naformátovat hodnotu aktuální dvojité instance do zadaného rozsahu znaků. |
| TryParse(ReadOnlySpan<Byte>, Double) |
Pokusí se převést rozsah znaků UTF-8 obsahující řetězcovou reprezentaci čísla na ekvivalent čísla s dvojitou přesností s plovoucí desetinnou čárkou. |
| TryParse(ReadOnlySpan<Byte>, IFormatProvider, Double) |
Pokusí se analyzovat rozsah znaků UTF-8 do hodnoty. |
| TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, Double) |
Pokusí se analyzovat rozsah znaků UTF-8 do hodnoty. |
| TryParse(ReadOnlySpan<Char>, Double) |
Převede reprezentaci čísla v zadaném stylu a formátu specifickém pro jazykovou verzi na ekvivalent čísla s plovoucí desetinnou čárkou s dvojitou přesností. Vrácená hodnota označuje, jestli byl převod úspěšný nebo neúspěšný. |
| TryParse(ReadOnlySpan<Char>, IFormatProvider, Double) |
Pokusí se analyzovat rozsah znaků do hodnoty. |
| TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Double) |
Převede rozsah znaků obsahující řetězcovou reprezentaci čísla v zadaném stylu a formátu specifickém pro jazykovou verzi na ekvivalent čísla s plovoucí desetinnou čárkou s dvojitou přesností. Vrácená hodnota označuje, jestli byl převod úspěšný nebo neúspěšný. |
| TryParse(String, Double) |
Převede řetězcovou reprezentaci čísla na ekvivalent čísla s plovoucí desetinnou čárkou s dvojitou přesností. Vrácená hodnota označuje, jestli byl převod úspěšný nebo neúspěšný. |
| TryParse(String, IFormatProvider, Double) |
Pokusí se analyzovat řetězec do hodnoty. |
| TryParse(String, NumberStyles, IFormatProvider, Double) |
Převede řetězcovou reprezentaci čísla v zadaném stylu a formátu specifickém pro jazykovou verzi na ekvivalent čísla s plovoucí desetinnou čárkou s dvojitou přesností. Vrácená hodnota označuje, jestli byl převod úspěšný nebo neúspěšný. |
Operátory
| Name | Description |
|---|---|
| Equality(Double, Double) |
Vrátí hodnotu, která určuje, zda jsou dvě zadané Double hodnoty stejné. |
| GreaterThan(Double, Double) |
Vrátí hodnotu, která určuje, zda je zadaná Double hodnota větší než jiná zadaná Double hodnota. |
| GreaterThanOrEqual(Double, Double) |
Vrátí hodnotu, která určuje, zda je zadaná Double hodnota větší nebo rovna jiné zadané Double hodnotě. |
| Inequality(Double, Double) |
Vrátí hodnotu, která označuje, zda jsou dvě zadané Double hodnoty nerovny. |
| LessThan(Double, Double) |
Vrátí hodnotu, která určuje, zda je zadaná Double hodnota menší než jiná zadaná Double hodnota. |
| LessThanOrEqual(Double, Double) |
Vrátí hodnotu, která určuje, zda je zadaná Double hodnota menší nebo rovna jiné zadané Double hodnotě. |
Explicitní implementace rozhraní
| Name | Description |
|---|---|
| IAdditionOperators<Double,Double,Double>.Addition(Double, Double) |
Sečte dvě hodnoty ke výpočtu jejich součtu. |
| IAdditiveIdentity<Double,Double>.AdditiveIdentity |
Získá přídatnou identitu aktuálního typu. |
| IBinaryNumber<Double>.AllBitsSet |
Získá instanci binárního typu, ve které jsou nastaveny všechny bity. |
| IBitwiseOperators<Double,Double,Double>.BitwiseAnd(Double, Double) |
Vypočítá bitové a dvě hodnoty. |
| IBitwiseOperators<Double,Double,Double>.BitwiseOr(Double, Double) |
Vypočítá bitové nebo dvě hodnoty. |
| IBitwiseOperators<Double,Double,Double>.ExclusiveOr(Double, Double) |
Vypočítá výhradní nebo dvě hodnoty. |
| IBitwiseOperators<Double,Double,Double>.OnesComplement(Double) |
Vypočítá reprezentaci daného doplňku. |
| IComparable.CompareTo(Object) |
Porovná aktuální instanci s jiným objektem stejného typu a vrátí celé číslo, které určuje, zda aktuální instance předchází, následuje nebo se vyskytuje ve stejném pořadí řazení jako druhý objekt. |
| IConvertible.GetTypeCode() |
TypeCode Vrátí hodnotu pro tuto instanci. |
| IConvertible.ToBoolean(IFormatProvider) |
Popis tohoto člena naleznete v tématu ToBoolean(IFormatProvider). |
| IConvertible.ToByte(IFormatProvider) |
Popis tohoto člena naleznete v tématu ToByte(IFormatProvider). |
| IConvertible.ToChar(IFormatProvider) |
Tento převod není podporován. Pokus o použití této metody vyvolá výjimku InvalidCastException. |
| IConvertible.ToDateTime(IFormatProvider) |
Tento převod není podporován. Pokus o použití této metody vyvolá výjimku InvalidCastException. |
| IConvertible.ToDecimal(IFormatProvider) |
Popis tohoto člena naleznete v tématu ToDecimal(IFormatProvider). |
| IConvertible.ToDouble(IFormatProvider) |
Popis tohoto člena naleznete v tématu ToDouble(IFormatProvider). |
| IConvertible.ToInt16(IFormatProvider) |
Popis tohoto člena naleznete v tématu ToInt16(IFormatProvider). |
| IConvertible.ToInt32(IFormatProvider) |
Popis tohoto člena naleznete v tématu ToInt32(IFormatProvider). |
| IConvertible.ToInt64(IFormatProvider) |
Popis tohoto člena naleznete v tématu ToInt64(IFormatProvider). |
| IConvertible.ToSByte(IFormatProvider) |
Popis tohoto člena naleznete v tématu ToSByte(IFormatProvider). |
| IConvertible.ToSingle(IFormatProvider) |
Popis tohoto člena naleznete v tématu ToSingle(IFormatProvider). |
| IConvertible.ToType(Type, IFormatProvider) |
Popis tohoto člena naleznete v tématu ToType(Type, IFormatProvider). |
| IConvertible.ToUInt16(IFormatProvider) |
Popis tohoto člena naleznete v tématu ToUInt16(IFormatProvider). |
| IConvertible.ToUInt32(IFormatProvider) |
Popis tohoto člena naleznete v tématu ToUInt32(IFormatProvider). |
| IConvertible.ToUInt64(IFormatProvider) |
Popis tohoto člena naleznete v tématu ToUInt64(IFormatProvider). |
| IDecrementOperators<Double>.Decrement(Double) |
Dekrementuje hodnotu. |
| IDivisionOperators<Double,Double,Double>.Division(Double, Double) |
Vydělí jednu hodnotu jinou, aby se vypočítá jejich podíl. |
| IFloatingPoint<Double>.GetExponentByteCount() |
Získá počet bajtů, které budou zapsány jako součást TryWriteExponentLittleEndian(Span<Byte>, Int32). |
| IFloatingPoint<Double>.GetExponentShortestBitLength() |
Získá délku v bitech nejkratšího dvojúrovňového doplňku reprezentace aktuální exponentu. |
| IFloatingPoint<Double>.GetSignificandBitLength() |
Získá délku aktuálního znaku v bitech. |
| IFloatingPoint<Double>.GetSignificandByteCount() |
Získá počet bajtů, které budou zapsány jako součást TryWriteSignificandLittleEndian(Span<Byte>, Int32). |
| IFloatingPoint<Double>.TryWriteExponentBigEndian(Span<Byte>, Int32) |
Snaží se napsat aktuální exponent ve formátu big-endian do daného rozsahu. |
| IFloatingPoint<Double>.TryWriteExponentLittleEndian(Span<Byte>, Int32) |
Snaží se napsat aktuální exponent v malém endovském formátu do daného rozsahu. |
| IFloatingPoint<Double>.TryWriteSignificandBigEndian(Span<Byte>, Int32) |
Snaží se napsat aktuální znak a do daného rozsahu ve formátu big-endian. |
| IFloatingPoint<Double>.TryWriteSignificandLittleEndian(Span<Byte>, Int32) |
Snaží se napsat aktuální znak a v malém endian formátu do daného rozsahu. |
| IFloatingPointConstants<Double>.E |
Získá matematickou konstantu |
| IFloatingPointConstants<Double>.Pi |
Získá matematickou konstantu |
| IFloatingPointConstants<Double>.Tau |
Získá matematickou konstantu |
| IFloatingPointIeee754<Double>.Epsilon |
Získá nejmenší hodnotu, která může být přidána k |
| IFloatingPointIeee754<Double>.NaN |
Získá hodnotu, která představuje |
| IFloatingPointIeee754<Double>.NegativeInfinity |
Získá hodnotu, která představuje záporné |
| IFloatingPointIeee754<Double>.NegativeZero |
Získá hodnotu, která představuje záporné |
| IFloatingPointIeee754<Double>.PositiveInfinity |
Získá hodnotu, která představuje kladné |
| IIncrementOperators<Double>.Increment(Double) |
Zvýší hodnotu. |
| IMinMaxValue<Double>.MaxValue |
Získá maximální hodnotu aktuálního typu. |
| IMinMaxValue<Double>.MinValue |
Získá minimální hodnotu aktuálního typu. |
| IModulusOperators<Double,Double,Double>.Modulus(Double, Double) |
Rozdělí dvě hodnoty dohromady a vypočítá jejich moduly nebo zbytek. |
| IMultiplicativeIdentity<Double,Double>.MultiplicativeIdentity |
Získá multiplikativní identitu aktuálního typu. |
| IMultiplyOperators<Double,Double,Double>.Multiply(Double, Double) |
Vynásobí dvě hodnoty dohromady pro výpočet jejich produktu. |
| INumberBase<Double>.IsCanonical(Double) |
Určuje, zda je hodnota v kanonickém vyjádření. |
| INumberBase<Double>.IsComplexNumber(Double) |
Určuje, zda hodnota představuje komplexní číslo. |
| INumberBase<Double>.IsImaginaryNumber(Double) |
Určuje, jestli hodnota představuje čisté imaginární číslo. |
| INumberBase<Double>.IsZero(Double) |
Určuje, jestli je hodnota nula. |
| INumberBase<Double>.One |
Získá hodnotu |
| INumberBase<Double>.Radix |
Získá radix (základ číselné soustavy) pro typ. |
| INumberBase<Double>.TryConvertFromChecked<TOther>(TOther, Double) |
Představuje číslo s plovoucí desetinnou čárkou s dvojitou přesností. |
| INumberBase<Double>.TryConvertFromSaturating<TOther>(TOther, Double) |
Představuje číslo s plovoucí desetinnou čárkou s dvojitou přesností. |
| INumberBase<Double>.TryConvertFromTruncating<TOther>(TOther, Double) |
Představuje číslo s plovoucí desetinnou čárkou s dvojitou přesností. |
| INumberBase<Double>.TryConvertToChecked<TOther>(Double, TOther) |
Pokusí se převést instanci aktuálního typu na jiný typ a vyvolá výjimku přetečení pro všechny hodnoty, které spadají mimo reprezentovatelný rozsah aktuálního typu. |
| INumberBase<Double>.TryConvertToSaturating<TOther>(Double, TOther) |
Pokusí se převést instanci aktuálního typu na jiný typ a nasytí všechny hodnoty, které spadají mimo reprezentovatelný rozsah aktuálního typu. |
| INumberBase<Double>.TryConvertToTruncating<TOther>(Double, TOther) |
Pokusí se převést instanci aktuálního typu na jiný typ a zkrátí všechny hodnoty, které spadají mimo reprezentovatelný rozsah aktuálního typu. |
| INumberBase<Double>.Zero |
Získá hodnotu |
| ISignedNumber<Double>.NegativeOne |
Získá hodnotu |
| ISubtractionOperators<Double,Double,Double>.Subtraction(Double, Double) |
Odečte dvě hodnoty pro výpočet jejich rozdílu. |
| IUnaryNegationOperators<Double,Double>.UnaryNegation(Double) |
Vypočítá unární negaci hodnoty. |
| IUnaryPlusOperators<Double,Double>.UnaryPlus(Double) |
Vypočítá unární plus hodnoty. |
Platí pro
Bezpečný přístup z více vláken
Všichni členové tohoto typu jsou bezpečné pro přístup z více vláken. Členové, kteří se zdá, že upravují stav instance, ve skutečnosti vrátí novou instanci inicializovanou s novou hodnotou. Stejně jako u jakéhokoli jiného typu musí být čtení a zápis do sdílené proměnné, která obsahuje instanci tohoto typu, chráněn zámkem, aby se zajistilo zabezpečení vlákna.
