Double 結構

定義

命名空間:

System

組件:

netstandard.dll, System.Runtime.dll

來源:

Double.cs

表示雙精度浮點數。

public 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 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>

type 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>

Public 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)

繼承

Object

ValueType

Double

實作

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>

範例

下列程式代碼範例說明 如何使用 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

備註

實 Double 值類型代表雙精確度 64 位數位，其值範圍從負 1.79769313486232e308 到正 1.79769313486232e308，以及正數或負零、 PositiveInfinity、、 NegativeInfinity而非數位 （NaN）。 它旨在表示極大的數值（例如行星或星系之間的距離）或極小的（例如物質的分子質量（以公斤計），且通常不精確（例如地球到另一個太陽系的距離）。 Double 類型符合二進位浮點算術的 IEC 60559：1989（IEEE 754） 標準。

浮點表示法和精確度

Double資料類型會以 64 位二進位格式儲存雙精確度浮點值，如下表所示：

部分	位元
Significand 或 mantissa	0-51
Exponent	52-62
符號 （0 = 正數，1 = 負數）	63

就像小數分數無法精確表示某些小數值（例如 1/3 或 Math.PI），二進位分數無法代表某些小數值。 例如，1/10 會以 .1 精確表示為十進位分數，以 .001100110011表示為二進位分數，而模式 “0011” 會重複到無限大。 在此情況下，浮點值會提供其所代表數位的不精確表示。 對原始浮點值執行額外的數學運算通常會增加其缺乏精確度。 例如，如果你比較將 0.1 乘以 10 的結果與 0.1 連續加總九次的結果，你會發現因為後者多了八次運算，結果變得較不精確。 （在.NET 10之前，這種差異僅在使用「R」字串Double顯示兩個 值時才明顯，該字串顯示Double型態所支援的最多 17 位數精度。）

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

由於有些數字無法精確表示為小數二進位值，浮點數只能近似實數。

所有浮點數也有有限的有效位數，這也決定浮點值如何精確近似實數。 Double 值最多可達小數的精度位數 15 位，而系統內部最多支援 17 位。 這表示某些浮點運算可能缺乏改變浮點數值的精確度。 下列範例提供一個實例。 它定義了一個非常大的浮點值，然後將 Double.Epsilon 與一千兆的乘積加到這個浮點值中。 不過，產品太小，無法修改原始浮點值。 其最小有效位數為千分之一，而產品中最重要的數位為^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

浮點數的有限精度會產生數個影響：

• 兩個在特定精度下看似相等的浮點數，可能不會相等，因為它們的最低位數不同。 在下列範例中，一連串的數字會加在一起，其總和與預期總和進行比較。

  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).
  

  兩個值不相等，是因為加法運算時精度下降。 在此情況下，您可以藉由呼叫 Math.Round(Double, Int32) 方法，將 Double 值四捨五入至所需的精確度，再執行比較，來解決此問題。

• 如果使用十進位數，使用浮點數的數學或比較運算可能不會產生相同的結果，因為二進位浮點數可能不等於十進位數。 在上一個範例中，我們通過將 0.1 乘以 10 然後多次添加 0.1 的結果來說明這一點。

  當數值運算的準確度很重要時，你可以使用 Decimal 類型而非 Double 類型。 當數值運算中整數值超出Int128UInt128類型範圍，且需要精確度時，請使用BigInteger類型。

• Single 的數值精度低於 Double 的數值。 因為精度差異，Single數值轉換為看似等同的Double時，往往不等於該Double數值。 在下列範例中，相同的除法作業結果會指派給 Double 和 Single 值。 將 Single 值轉換成 Double之後，兩個值的比較會顯示它們不相等。

  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: False
  

  open 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: False
  

  Module 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: False
  

  若要避免這個問題，請使用 Double 取代 Single 數據類型，或使用 Round 方法，從而使兩個值具有相同的精度。

此外，Double 值的算術運算和賦值運算的結果可能因 Double 類型的精度損失而在不同平台上略有差異。 例如，指派一個文字值 Double 的結果，在 32 位元和 64 位元版本的 .NET 中可能有所不同。 下列範例說明了當將常值 -4.42330604244772E-305 與值為 -4.42330604244772E-305 的變數分別指定給一個 Double 變數時，這個差異。 請注意，在此情況下，方法的結果 Parse(String) 不會因為精確度遺失而受到影響。

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

進行相等性測試

若要視為相等，兩個 Double 值必須代表相同的值。 不過，由於數值之間的精度差異，或者其中一個或兩個數值的精度受到損失，因此預期相同的浮點數值通常因其最低有效位數的不同而不相等。 因此，呼叫 Equals 方法來判斷兩個值是否相等，或呼叫 CompareTo 方法來判斷兩個 Double 值之間的關聯性，通常會產生非預期的結果。 這在以下範例中很明顯，Double 中的兩個看似相等的值結果並不相等，因為第一個有 15 位數的精度，而第二個則有 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

如果遺失精確度可能會影響比較的結果，您可以採用下列任何替代方法呼叫 Equals 或 CompareTo 方法：

• 呼叫 Math.Round 方法，以確保這兩個值具有相同的精度。 下列範例會修改先前的範例，以使用此方法，讓兩個小數值相等。

  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: True
  

  open 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: True
  

  Module 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: True
  

  精確度問題仍適用於中間點值的四捨五入。 如需詳細資訊，請參閱 Math.Round(Double, Int32, MidpointRounding) 方法。

• 測試大約相等，而不是完全相等。 這需要您定義兩個值可以相差但仍相等的絕對量，或定義較小的值可以從較大值中除以的相對量。

  Warning

  當測試是否相等時，Double.Epsilon 有時會當做兩個 Double 值之間距離的絕對量值。 不過，Double.Epsilon 測量可以加到或減去其值為零的 Double 的最小可能值。 對於大部分的正負 Double 值，Double.Epsilon 的值太小而無法偵測。 因此，除了零值，我們不建議用於相等性測試。

  下列範例會使用後者方法來定義 IsApproximatelyEqual 方法，以測試兩個值之間的相對差異。 該方法除以 Math.Max(value1, value2)，因此比較是相對於兩者中絕對值較大的值，從而使結果達到正確的數量級。 如果 Math.Max 回傳為零（當一個值為零且另一個為負時），方法會回退到 Math.Min(value1, value2) 使用非零值作為除子。 它也會對比呼叫 IsApproximatelyEqual 方法和 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: True
  

  open 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: True
  

  Module 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
  

浮點值和例外狀況

與整數型態的操作不同，後者會在DivideByZeroException中拋出 a OverflowException 以除以零，或拋出 a 以溢位，浮點數運算不會拋出例外。 相反地，在特殊情況下，浮點運算的結果為零、正無限大、負無限大，或不是數位 （NaN）：

• 如果浮點運算的結果對目的格式而言太小，則結果為零。 當兩個非常小的數位相乘時，就會發生這種情況，如下列範例所示。

  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: True
  

  let 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: True
  

  Module 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: True
  

• 如果浮點運算的結果大於目的格式的範圍，則依據結果的正負號，作業的結果會是 PositiveInfinity 或 NegativeInfinity。 Double.MaxValue 溢位作業的結果是 PositiveInfinity，而溢位 Double.MinValue 的作業結果 NegativeInfinity，如下列範例所示。

  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: True
  

  open 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: True
  

  Module 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: True
  

  PositiveInfinity 也由正的被除數除以零產生，而 NegativeInfinity 則由負的被除數除以零產生。

• 如果浮點運算無效，作業的結果會 NaN。 例如，NaN 是由下列操作得出的結果：

  • 以零作為被除數進行除以零的運算。 請注意，其他除以零的情況結果為PositiveInfinity或NegativeInfinity。

  • 任何具有無效輸入的浮點運算。 例如，呼叫 Math.Sqrt 方法時使用負值會傳回NaN，就像呼叫 Math.Acos 方法時，若值大於一或小於負一。

  • 任何具有其值為Double.NaN的引數的運算。

類型轉換

Double 結構未定義任何明確或隱含轉換運算符;相反地，編譯程式會實作轉換。

將任何基本數值型別的值轉換成 Double 是一種擴大轉換，因此，除非編譯器明確要求，否則不需要明確的轉換運算符或呼叫轉換方法。 例如，C# 編譯器需要一個鑄造運算子來將 Decimal 轉換到 Double，而 Visual Basic 編譯器則不需要。 下列範例會將其他基本數值類型的 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)

此外，Single 值 Single.NaN、Single.PositiveInfinity和 Single.NegativeInfinity 分別轉換成 Double.NaN、Double.PositiveInfinity和 Double.NegativeInfinity。

請注意，將某些數值型別的值轉換成 Double 值，可能涉及精確度遺失。 如範例所示，將 Decimal、Int64 和 UInt64 值轉換成 Double 值時，可能會遺失有效位數。

將 Double 值轉換成任何其他原始數值資料型態的值，是一種狹窄轉換，需要在 C# 中使用鑄造運算子、在 Visual Basic 中使用轉換方法，或呼叫 Convert 方法。 目標數據類型範圍以外的值，這些值是由目標類型的 MinValue 和 MaxValue 屬性所定義，其行為如下表所示。

目標類型	Result
任何整數類型	如果轉換發生在已檢查的內容中，則為 OverflowException 例外狀況。 如果轉換發生在未核取的內容中（C# 中的預設值），轉換作業會成功，但值溢位。
Decimal	一個OverflowException例外。
Single	Single.NegativeInfinity 用於表示負值。 Single.PositiveInfinity 代表正值。

此外，Double.NaN、Double.PositiveInfinity和 Double.NegativeInfinity 會擲回 OverflowException，以便在已檢查的上下文中轉換成整數，但這些值在未檢查的上下文中轉換成整數時會溢位。 若要轉換成 Decimal，它們一律會拋出 OverflowException。 若要轉換成 Single，它們分別轉換成 Single.NaN、Single.PositiveInfinity和 Single.NegativeInfinity。

將數 Double 值轉換成其他數值類型可能會導致精度損失。 在將值轉換為任何整數型別時，如範例輸出所示，當 Double 值被四捨五入（如在 Visual Basic 中）或截斷（如在 C# 中），小數部分就會被捨去。 對於轉換到 Decimal 和 Single 值，Double 的值可能無法精確表示為目標資料類型。

下列範例會將一些 Double 值轉換成數個其他數值類型。 轉換發生在 Visual Basic 中已核取的內容中（預設值）、C# 中（因為 checked 關鍵詞），以及 F# 中（因為 Checked 模組）。 範例的輸出顯示在已檢查和未檢查環境中進行轉換的結果。 你可以在未受檢查的環境中進行轉換，Visual Basic 中透過使用編譯器開關/removeintchecks+進行編譯，在 C# 中註解checked語句，在 F# 中註解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)

如需數值型別轉換的詳細資訊，請參閱 .NET 中的 型別轉換和 類型轉換資料表。

浮點功能

結構和 Double 相關類型提供方法，以在下列區域中執行作業：

• 的值比較。 您可以呼叫 Equals 方法來判斷兩個 Double 值是否相等，或判斷兩個值之間的關聯性 CompareTo 方法。

  Double 結構也支援一組完整的比較運算符。 例如，您可以測試是否相等或不等，或判斷某個值是否大於或等於另一個值。 如果其中一個運算元是非 Double 的數值類型，在執行比較之前，會先將其轉換為 Double。

  Warning

  由於精度差異，原本預期相等的兩個 Double 數值可能會不相等，這會影響比較結果。 關於比較兩個 Double 數值的資訊，請參閱「 相等檢驗 」章節。

  您也可以呼叫 IsNaN、IsInfinity、IsPositiveInfinity和 IsNegativeInfinity 方法來測試這些特殊值。

• 數學運算。 常見的算術運算，例如加法、減法、乘法和除法，都是由語言編譯程式和通用中繼語言 （CIL） 指令實作，而不是由 Double 方法實作。 如果數學運算中的某個運算元是非 a Double的數值型態，則在執行操作前會先轉換成 a Double 。 作業的結果也是值 Double 。

  您可以透過在 static 類別中呼叫 Shared 方法（在 Visual Basic 中為 System.Math）來執行其他數學運算。 它包含一些常用於算術的方法（例如 Math.Abs、Math.Sign 和 Math.Sqrt）、幾何（例如 Math.Cos 和 Math.Sin）以及微積分（例如 Math.Log）。

  您也可以操作 Double 值中的單個位元。 方法 BitConverter.DoubleToInt64Bits 會在 Double 64位整數中保留值的位模式。 BitConverter.GetBytes(Double) 方法會將其位元模式返回到位元組數列中。

• 四捨五入。 四捨五入通常用來作為減少浮點表示和精確度問題所造成值差異影響的技術。 您可以呼叫 Double 方法來四捨五入 Math.Round 值。

• 格式化. 您可以將 Double 值轉換為其字串表示法，方法是呼叫 ToString 方法或使用複合格式功能。 為了瞭解格式字串如何控制浮點值的字串表示，請參閱標準數值格式字串和自訂數值格式字串。

• 解析字串。 您可以呼叫 Double 或 Parse 方法，將浮點值的字串表示轉換成TryParse值。 如果剖析作業失敗，Parse 方法會擲回例外狀況，而 TryParse 方法會傳回 false。

• 類型轉換。 Double 結構為 IConvertible 介面提供了明確的介面實作，支援任意兩種標準.NET資料型態之間的轉換。 語言編譯程式也支援將所有其他標準數值類型的值隱含轉換成 Double 值。 將任何標準數字型別的值轉換為 Double 是一種擴大轉換，這不需要使用轉型運算符或轉換方法。

  不過，Int64 和 Single 值的轉換可能會導致精確度降低。 下表列出這些類型的精確度差異：

  類型	最大精度	內部精度
  Double	15	17
  Int64	19個十進位數	19個十進位數
  Single	7 個十進位數	9 個十進位數

  精確度問題最常影響的是 Single 值在轉換成 Double 值的過程中。 在下列範例中，相同除法運算所產生的兩個值不相等，因為其中一個值是轉換成 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
  

欄位

名稱	Description
E	代表自然對數底，由常數 e 表示。
Epsilon	代表大於零的最小正 Double 值。 此欄位是常數。
MaxValue	代表 的最大可能值 Double。 此欄位是常數。
MinValue	代表 的最小值 Double。 此欄位是常數。
NaN	代表一個非數字的值（NaN）。 此欄位是常數。
NegativeInfinity	代表負無限。 此欄位是常數。
NegativeZero	代表數字負零（-0）。
Pi	代表圓周長與直徑的比值，由常數π表示。
PositiveInfinity	代表正無限。 此欄位是常數。
Tau	表示一回合內弧度數，由常數 τ 表示。

方法

名稱	Description
Abs(Double)	計算值的絕對值。
Acos(Double)	計算一個值的弧餘弦。
Acosh(Double)	計算一個值的雙曲弧餘弦。
AcosPi(Double)	計算一個值的弧餘弦，並將結果除以 pi。
Asin(Double)	計算一個值的弧正弦。
Asinh(Double)	計算一個值的雙曲弧正弦。
AsinPi(Double)	計算一個值的弧正弦，並將結果除以 pi。
Atan(Double)	計算值的弧切。
Atan2(Double, Double)	計算兩個值商的弧切線。
Atan2Pi(Double, Double)	計算兩個值的商的弧切，並將結果除以 pi。
Atanh(Double)	計算一個值的雙曲弧切線。
AtanPi(Double)	計算一個值的弧切，並將結果除以圓周率。
BitDecrement(Double)	回傳比較值小於指定值的最大值。
BitIncrement(Double)	回傳比大於指定值的最小值。
Cbrt(Double)	計算一個值的立方根。
Ceiling(Double)	計算某個數值的上限。
Clamp(Double, Double, Double)	將值夾在內含最小值和最大值。
ClampNative(Double, Double, Double)	利用平台特定的行為將值夾定為包含的最小值與最大值，且 。NaNNegativeZero
CompareTo(Double)	將此實例與指定的雙精度浮點數比較，並回傳一個整數，表示該實例值是小於、等於還是大於指定的雙精度浮點數值。
CompareTo(Object)	將此實例與指定物件比較，並回傳一個整數，表示該實例的值是小於、等於還是大於指定物件的值。
ConvertToInteger<TInteger>(Double)	利用溢位時的飽和將值轉換為指定的整數型別
ConvertToIntegerNative<TInteger>(Double)	利用平台特定的行為在溢位時將值轉換成指定的整數類型。
CopySign(Double, Double)	將值的正負號複製到另一個值的正負號。
Cos(Double)	計算一個值的餘弦值。
Cosh(Double)	計算一個值的雙曲餘弦值。
CosPi(Double)	計算乘以 pi的值的餘弦值。
CreateChecked<TOther>(TOther)	從值建立目前型別的實例，針對落在目前類型可表示範圍以外的任何值擲回溢位例外狀況。
CreateSaturating<TOther>(TOther)	從值建立目前型別的實例，使落在目前類型可表示範圍以外的任何值飽和。
CreateTruncating<TOther>(TOther)	從值建立目前型別的實例，截斷任何落在目前類型可表示範圍以外的值。
DegreesToRadians(Double)	將給定值從度數轉換為弧度。
Equals(Double)	回傳一個值，表示該實例與指定 Double 物件是否代表相同值。
Equals(Object)	傳回值，指出這個實例是否等於指定的物件。
Exp(Double)	計算將 E 提升到給定的冪次方。
Exp10(Double)	計算將 10 提升到給定的冪次方。
Exp10M1(Double)	計算將升 10 為給定的冪次方並減去一。
Exp2(Double)	計算將 2 提升到給定的冪次方。
Exp2M1(Double)	計算將升 2 為給定的冪次方並減去一。
ExpM1(Double)	計算將升 E 為給定的冪次方並減去一。
Floor(Double)	計算一個值的底線。
FusedMultiplyAdd(Double, Double, Double)	計算三個值的融合乘法加法。
GetHashCode()	傳回這個實例的哈希碼。
GetTypeCode()	回傳 TypeCode 的值型別 Double。
Hypot(Double, Double)	計算斜邊，給定兩個代表直角三角形中較短邊長的值。
Ieee754Remainder(Double, Double)	計算 IEEE 754 規定的兩個剩餘數值。
ILogB(Double)	計算一個值的整數對數。
IsEvenInteger(Double)	判斷值是否代表偶數整數。
IsFinite(Double)	判斷指定值是有限的（零、次正規或正常）。
IsInfinity(Double)	回傳一個值，表示指定數字是負無限大還是正無限大。
IsInteger(Double)	判斷一個值是否代表整數值。
IsNaN(Double)	回傳一個值，指示該指定值是否為數字（NaN）。
IsNegative(Double)	判斷指定值是否為負值。
IsNegativeInfinity(Double)	回傳一個值，表示指定數字是否值為負無限大。
IsNormal(Double)	判斷指定值是否為正常值。
IsOddInteger(Double)	判斷值是否代表奇數整數。
IsPositive(Double)	判斷值是否為正數。
IsPositiveInfinity(Double)	回傳一個值，表示指定數字是否值為正無限大。
IsPow2(Double)	判斷值是否為兩個乘冪。
IsRealNumber(Double)	判斷值是否代表實數。
IsSubnormal(Double)	判斷指定值是否低於正常值。
Lerp(Double, Double, Double)	根據給定權重，在兩個值之間進行線性插值。
Log(Double, Double)	計算指定基底下某值的對數。
Log(Double)	計算一個值的自然（base-E 對數）。
Log10(Double)	計算一個值的以10為底的對數。
Log10P1(Double)	計算一個值加一的以十為底的對數。
Log2(Double)	計算 值的log2。
Log2P1(Double)	計算一個值加一的底數2對數。
LogP1(Double)	計算值加一的自然base-E（）對數。
Max(Double, Double)	比較兩個值與計算，這兩個值更大。
MaxMagnitude(Double, Double)	比較兩個值與計算，這兩個值更大。
MaxMagnitudeNumber(Double, Double)	比較兩個值以計算出哪個大小較大，若輸入為 NaN則返回另一個值。
MaxNative(Double, Double)	比較兩個值以計算，利用平台特定行為計算 NaN 和 NegativeZero。
MaxNumber(Double, Double)	比較兩個值以計算較大的值，若輸入為 NaN則返回另一個值。
Min(Double, Double)	比較兩個值與計算比較較少。
MinMagnitude(Double, Double)	比較兩個值與計算比較較少。
MinMagnitudeNumber(Double, Double)	比較兩個值以計算大小較小的值，若輸入為 NaN則返回另一個值。
MinNative(Double, Double)	比較兩個值，利用平台特定行為計算 NaN 和 NegativeZero，哪個較小。
MinNumber(Double, Double)	比較兩個值以計算一個較小的值，若輸入為 NaN則返回另一個值。
MultiplyAddEstimate(Double, Double, Double)	計算估計值為（left * right） + 。 addend
Parse(ReadOnlySpan<Byte>, IFormatProvider)	將UTF-8字元的範圍剖析為值。
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)	將UTF-8字元的範圍剖析為值。
Parse(ReadOnlySpan<Char>, IFormatProvider)	將字元範圍剖析為值。
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	將字元範圍，其中包含指定樣式和特定文化特性格式之數位的字串表示，轉換為其對等的雙精確度浮點數。
Parse(String, IFormatProvider)	將指定文化特性特定格式之數位的字串表示轉換為其對等的雙精確度浮點數。
Parse(String, NumberStyles, IFormatProvider)	將指定樣式和特定文化特性格式之數位的字串表示轉換為其對等的雙精確度浮點數。
Parse(String, NumberStyles)	將指定樣式中數位的字串表示轉換為對等的雙精確度浮點數。
Parse(String)	將數位的字串表示轉換為其對等的雙精確度浮點數。
Pow(Double, Double)	計算一個提升至給定冪次方的值。
RadiansToDegrees(Double)	將給定值從弧度轉換為度數。
ReciprocalEstimate(Double)	計算值的倒數估計值。
ReciprocalSqrtEstimate(Double)	計算一個值的倒數平方根估計值。
RootN(Double, Int32)	計算一個值的第 n 次根。
Round(Double, Int32, MidpointRounding)	使用預設的四捨五入模式（）ToEven將數值四捨五入至指定數量的分數位數。
Round(Double, Int32)	使用預設的四捨五入模式（）ToEven將數值四捨五入至指定數量的分數位數。
Round(Double, MidpointRounding)	使用指定的四捨五入模式將值捨入至最近的整數。
Round(Double)	使用預設的四捨五入模式（ToEven）將值捨入至最近的整數。
ScaleB(Double, Int32)	計算一個值與其基數乘積至指定冪次方的乘積。
Sign(Double)	計算值的符號。
Sin(Double)	計算一個值的正弦值。
SinCos(Double)	計算值的正弦與餘弦。
SinCosPi(Double)	計算值的正弦與餘弦。
Sinh(Double)	計算值的雙曲正弦。
SinPi(Double)	計算乘以 pi的值的正弦值。
Sqrt(Double)	計算一個值的平方根。
Tan(Double)	計算一個值的切線。
Tanh(Double)	計算一個值的雙曲切線。
TanPi(Double)	計算乘以 pi的值的切線。
ToString()	將這個實例的數值轉換為其相等的字串表示。
ToString(IFormatProvider)	利用指定的文化特定格式資訊，將此實例的數值轉換為其等效字串表示。
ToString(String, IFormatProvider)	使用指定的格式和文化特性特定格式資訊，將這個實例的數值轉換為其相等的字串表示。
ToString(String)	使用指定的格式，將這個實例的數值轉換為其相等的字串表示。
Truncate(Double)	截斷一個數值。
TryFormat(Span<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider)	嘗試將目前實例的值格式化為UTF-8到提供的位元組範圍。
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	嘗試將當前雙重實例的值格式化為所提供的字元範圍。
TryParse(ReadOnlySpan<Byte>, Double)	嘗試將包含數位字串表示的UTF-8字元範圍轉換為其對等雙精確度浮點數。
TryParse(ReadOnlySpan<Byte>, IFormatProvider, Double)	嘗試將UTF-8字元的範圍剖析為值。
TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, Double)	嘗試將UTF-8字元的範圍剖析為值。
TryParse(ReadOnlySpan<Char>, Double)	將指定樣式和特定文化特性格式的數位範圍表示轉換為其對等的雙精確度浮點數。 傳回值表示轉換成功或失敗。
TryParse(ReadOnlySpan<Char>, IFormatProvider, Double)	嘗試將字元範圍剖析成值。
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Double)	將包含指定樣式和特定文化特性格式之數位的字串表示的字元範圍轉換為其對等的雙精確度浮點數。 傳回值表示轉換成功或失敗。
TryParse(String, Double)	將數位的字串表示轉換為其對等的雙精確度浮點數。 傳回值表示轉換成功或失敗。
TryParse(String, IFormatProvider, Double)	嘗試將字串剖析成值。
TryParse(String, NumberStyles, IFormatProvider, Double)	將指定樣式和特定文化特性格式之數位的字串表示轉換為其對等的雙精確度浮點數。 傳回值表示轉換成功或失敗。

操作員

名稱	Description
Equality(Double, Double)	回傳一個值，表示兩個指定 Double 值是否相等。
GreaterThan(Double, Double)	回傳一個值，指示某特定 Double 值是否大於另一個指定 Double 值。
GreaterThanOrEqual(Double, Double)	回傳一個值，表示指定 Double 值是否大於或等於另一個指定 Double 值。
Inequality(Double, Double)	回傳一個值，表示兩個指定 Double 值是否不相等。
LessThan(Double, Double)	回傳一個值，指示某指定 Double 值是否小於另一個指定 Double 值。
LessThanOrEqual(Double, Double)	回傳一個值，表示指定值是否 Double 小於或等於另一個指定 Double 值。

明確介面實作

名稱	Description
IAdditionOperators<Double,Double,Double>.Addition(Double, Double)	將兩個值加在一起以計算其總和。
IAdditiveIdentity<Double,Double>.AdditiveIdentity	取得目前型別的加法識別。
IBinaryNumber<Double>.AllBitsSet	取得已設定所有位之二進位型別的實例。
IBitwiseOperators<Double,Double,Double>.BitwiseAnd(Double, Double)	計算兩個值的位和 。
IBitwiseOperators<Double,Double,Double>.BitwiseOr(Double, Double)	計算兩個值的位或兩個值。
IBitwiseOperators<Double,Double,Double>.ExclusiveOr(Double, Double)	計算兩個值的獨佔或兩個值。
IBitwiseOperators<Double,Double,Double>.OnesComplement(Double)	計算指定值的 ones-complement 表示法。
IConvertible.ToBoolean(IFormatProvider)	關於此成員的描述，請參見 ToBoolean(IFormatProvider)。
IConvertible.ToByte(IFormatProvider)	關於此成員的描述，請參見 ToByte(IFormatProvider)。
IConvertible.ToChar(IFormatProvider)	此轉換不被支援。 嘗試使用此方法會拋出一個 InvalidCastException。
IConvertible.ToDateTime(IFormatProvider)	此轉換不被支援。 嘗試使用此方法會拋出一個 InvalidCastException。
IConvertible.ToDecimal(IFormatProvider)	關於此成員的描述，請參見 ToDecimal(IFormatProvider)。
IConvertible.ToDouble(IFormatProvider)	關於此成員的描述，請參見 ToDouble(IFormatProvider)。
IConvertible.ToInt16(IFormatProvider)	關於此成員的描述，請參見 ToInt16(IFormatProvider)。
IConvertible.ToInt32(IFormatProvider)	關於此成員的描述，請參見 ToInt32(IFormatProvider)。
IConvertible.ToInt64(IFormatProvider)	關於此成員的描述，請參見 ToInt64(IFormatProvider)。
IConvertible.ToSByte(IFormatProvider)	關於此成員的描述，請參見 ToSByte(IFormatProvider)。
IConvertible.ToSingle(IFormatProvider)	關於此成員的描述，請參見 ToSingle(IFormatProvider)。
IConvertible.ToType(Type, IFormatProvider)	關於此成員的描述，請參見 ToType(Type, IFormatProvider)。
IConvertible.ToUInt16(IFormatProvider)	關於此成員的描述，請參見 ToUInt16(IFormatProvider)。
IConvertible.ToUInt32(IFormatProvider)	關於此成員的描述，請參見 ToUInt32(IFormatProvider)。
IConvertible.ToUInt64(IFormatProvider)	關於此成員的描述，請參見 ToUInt64(IFormatProvider)。
IDecrementOperators<Double>.Decrement(Double)	遞減值。
IDivisionOperators<Double,Double,Double>.Division(Double, Double)	將一個值除以計算其商數。
IFloatingPoint<Double>.GetExponentByteCount()	取得將被寫入為 TryWriteExponentLittleEndian(Span<Byte>, Int32)的一部分的位元組數。
IFloatingPoint<Double>.GetExponentShortestBitLength()	得到目前指數中最短二補數表示的長度（位元）。
IFloatingPoint<Double>.GetSignificandBitLength()	得到當前符號的長度（以位元為單位）。
IFloatingPoint<Double>.GetSignificandByteCount()	取得將被寫入為 TryWriteSignificandLittleEndian(Span<Byte>, Int32)的一部分的位元組數。
IFloatingPoint<Double>.TryWriteExponentBigEndian(Span<Byte>, Int32)	嘗試將當前指數以大端格式寫入給定的範圍。
IFloatingPoint<Double>.TryWriteExponentLittleEndian(Span<Byte>, Int32)	嘗試將當前指數以小端格式寫入給定的範圍。
IFloatingPoint<Double>.TryWriteSignificandBigEndian(Span<Byte>, Int32)	嘗試將當前的意義以大端序格式寫入給定的區域。
IFloatingPoint<Double>.TryWriteSignificandLittleEndian(Span<Byte>, Int32)	嘗試以小端格式寫入給定範圍的當前意義。
IFloatingPointConstants<Double>.E	得到數學常數 e。
IFloatingPointConstants<Double>.Pi	得到數學常數 pi。
IFloatingPointConstants<Double>.Tau	得到數學常數 tau。
IFloatingPointIeee754<Double>.Epsilon	得到最小的值，使得 可以加 0 到且不產生 0。
IFloatingPointIeee754<Double>.NaN	得到一個代表 NaN的值。
IFloatingPointIeee754<Double>.NegativeInfinity	得到一個代表負 infinity值的值。
IFloatingPointIeee754<Double>.NegativeZero	得到一個代表負 zero值的值。
IFloatingPointIeee754<Double>.PositiveInfinity	得到一個代表正值 infinity的值。
IIncrementOperators<Double>.Increment(Double)	遞增值。
IMinMaxValue<Double>.MaxValue	取得目前型別的最大值。
IMinMaxValue<Double>.MinValue	取得目前型別的最小值。
IModulusOperators<Double,Double,Double>.Modulus(Double, Double)	將兩個值分割在一起，以計算其模數或餘數。
IMultiplicativeIdentity<Double,Double>.MultiplicativeIdentity	取得目前型別的乘法識別。
IMultiplyOperators<Double,Double,Double>.Multiply(Double, Double)	將兩個值相乘以計算其產品。
INumberBase<Double>.IsCanonical(Double)	判斷值是否在其標準表示法中。
INumberBase<Double>.IsComplexNumber(Double)	判斷值是否代表複數。
INumberBase<Double>.IsImaginaryNumber(Double)	判斷值是否代表純虛數。
INumberBase<Double>.IsZero(Double)	判斷值是否為零。
INumberBase<Double>.One	取得該類型的數值 1 。
INumberBase<Double>.Radix	取得型別的進位或基底。
INumberBase<Double>.TryConvertFromChecked<TOther>(TOther, Double)	表示雙精度浮點數。
INumberBase<Double>.TryConvertFromSaturating<TOther>(TOther, Double)	表示雙精度浮點數。
INumberBase<Double>.TryConvertFromTruncating<TOther>(TOther, Double)	表示雙精度浮點數。
INumberBase<Double>.TryConvertToChecked<TOther>(Double, TOther)	嘗試將目前類型的實例轉換成另一個類型，針對落在目前類型可表示範圍以外的任何值擲回溢位例外狀況。
INumberBase<Double>.TryConvertToSaturating<TOther>(Double, TOther)	嘗試將目前類型的實例轉換成另一個類型，使任何落在目前類型可表示範圍以外的值飽和。
INumberBase<Double>.TryConvertToTruncating<TOther>(Double, TOther)	嘗試將目前類型的實例轉換成另一個類型，截斷落在目前類型可表示範圍以外的任何值。
INumberBase<Double>.Zero	取得該類型的數值 0 。
ISignedNumber<Double>.NegativeOne	取得該類型的數值 -1 。
ISubtractionOperators<Double,Double,Double>.Subtraction(Double, Double)	減去兩個值來計算其差異。
IUnaryNegationOperators<Double,Double>.UnaryNegation(Double)	計算值的一元負值。
IUnaryPlusOperators<Double,Double>.UnaryPlus(Double)	計算值的一元加號。

執行緒安全性

此類型的所有成員都是安全線程。 看似修改實例狀態的成員實際上會傳回以新值初始化的新實例。 如同任何其他類型，讀取和寫入包含此類型實例的共用變數必須受到鎖定的保護，以確保線程安全性。

另請參閱

• Decimal
• Single
• 範例：.NET Core WinForms 格式化公用程式 （C#）
• 範例：.NET Core WinForms 格式化公用程式 （Visual Basic）