System.Double 結構

發行項
01/08/2024

本文提供此 API 參考文件的補充備註。

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

浮點表示法和精確度

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

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

如同小數分數無法精確表示某些小數值（例如 1/3 或 Math.PI），二進位分數無法代表某些小數值。例如，1/10 會以 .1 精確表示為十進位分數，以 .001100110011表示為二進位分數，而模式 “0011” 會重複到無限大。在此情況下，浮點值會提供其所代表數位的不精確表示。對原始浮點值執行額外的數學運算通常會增加其缺乏精確度。例如，如果我們比較將 .1 乘以 10 的結果，並將 .1 加到 .1 九倍，我們就會看到該加法，因為它涉及另外八個作業，因此會產生較不精確的結果。請注意，只有當我們使用「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:           {0:R}", result1);
        Console.WriteLine(".1 Added 10 times: {0:R}", result2);
    }
}
// The example displays the following output:
//       .1 * 10:           1
//       .1 Added 10 times: 0.99999999999999989

let value = 0.1
let result1 = value * 10.
let mutable result2 = 0.
for i = 1 to 10 do
    result2 <- result2 + value

printfn $".1 * 10:           {result1:R}"
printfn $".1 Added 10 times: {result2:R}"
// The example displays the following output:
//       .1 * 10:           1
//       .1 Added 10 times: 0.99999999999999989

Module Example14
    Public Sub Main()
        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("{0} + {1} = {2}", value, additional,
                                             value + additional);
    }
}
// The example displays the following output:
//    123456789012.346 + 4.94065645841247E-309 = 123456789012.346

open System

let value = 123456789012.34567
let additional = Double.Epsilon * 1e15
printfn $"{value} + {additional} = {value + additional}"
// The example displays the following output:
//    123456789012.346 + 4.94065645841247E-309 = 123456789012.346

Module Example15
    Public Sub Main()
        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

浮點數的有限有效位數有數個後果：

對特定有效位數相等的兩個浮點數，可能因為它們的最低有效位數不同，而不相等。在下列範例中，一連串的數位會加在一起，而且其總計會與預期的總計進行比較。雖然這兩個值似乎相同，但對方法的 Equals 呼叫表示它們不是。

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 ({0}) does not equal the total ({1}).",
                              total, result);
    }
}
// The example displays the following output:
//      The sum of the values (36.64) does not equal the total (36.64).
//
// If the index items in the Console.WriteLine statement are changed to {0:R},
// the example displays the following output:
//       The sum of the values (27.639999999999997) does not equal the total (27.64).

let values = [ 10.0; 2.88; 2.88; 2.88; 9.0 ]
let result = 27.64
let total = List.sum values

if total.Equals result then
    printfn "The sum of the values equals the total."
else
    printfn $"The sum of the values ({total}) does not equal the total ({result})."
// The example displays the following output:
//      The sum of the values (36.64) does not equal the total (36.64).
//
// If the index items in the Console.WriteLine statement are changed to {0:R},
// the example displays the following output:
//       The sum of the values (27.639999999999997) does not equal the total (27.64).

Module Example11
    Public Sub Main()
        Dim values() As Double = {10.0, 2.88, 2.88, 2.88, 9.0}
        Dim result As Double = 27.64
        Dim total As Double
        For Each value In values
            total += value
        Next
        If total.Equals(result) Then
            Console.WriteLine("The sum of the values equals the total.")
        Else
            Console.WriteLine("The sum of the values ({0}) does not equal the total ({1}).",
                           total, result)
        End If
    End Sub
End Module
' The example displays the following output:
'      The sum of the values (36.64) does not equal the total (36.64).   
'
' If the index items in the Console.WriteLine statement are changed to {0:R},
' the example displays the following output:
'       The sum of the values (27.639999999999997) does not equal the total (27.64).

如果您將語句中的 Console.WriteLine(String, Object, Object) 格式專案從 {0} 和 {1} 變更為 {0:R} ， {1:R} 並顯示這兩 Double 個值的所有有效位數，則很明顯，這兩個值在加法作業期間遺失有效位數而不相等。在此情況下，您可以藉由呼叫 Math.Round(Double, Int32) 方法來將值四捨五入 Double 至所需的精確度，再執行比較，以解決此問題。

如果使用十進位數，使用浮點數的數學或比較運算可能不會產生相同的結果，因為二進位浮點數可能不等於十進位數。上一個範例將 .1 乘以 10 並加入 .1 次，藉此說明這一點。

當具有小數值的數值運算精確度很重要時，您可以使用 Decimal 而非型別 Double 。當數值運算的精確度與整數值超出或 UInt64 類型的範圍Int64時，請使用 BigInteger 類型。

如果涉及浮點數，值可能不會來回。如果作業將原始浮點數轉換成另一種形式，反向運算會將轉換后的窗體轉換成浮點數，而最終浮點數不等於原始浮點數，則值會表示往返。來回行程可能會失敗，因為轉換中遺失或變更了一或多個最小有效位數。在下列範例中，三 Double 個值會轉換成字串，並儲存在檔案中。不過，如輸出所示，即使值看起來完全相同，還原的值不等於原始值。

using System;
using System.IO;

public class Example11
{
    public static void Main()
    {
        StreamWriter sw = new StreamWriter(@".\Doubles.dat");
        Double[] values = { 2.2 / 1.01, 1.0 / 3, Math.PI };
        for (int ctr = 0; ctr < values.Length; ctr++)
        {
            sw.Write(values[ctr].ToString());
            if (ctr != values.Length - 1)
                sw.Write("|");
        }
        sw.Close();

        Double[] restoredValues = new Double[values.Length];
        StreamReader sr = new StreamReader(@".\Doubles.dat");
        string temp = sr.ReadToEnd();
        string[] tempStrings = temp.Split('|');
        for (int ctr = 0; ctr < tempStrings.Length; ctr++)
            restoredValues[ctr] = Double.Parse(tempStrings[ctr]);

        for (int ctr = 0; ctr < values.Length; ctr++)
            Console.WriteLine("{0} {2} {1}", values[ctr],
                              restoredValues[ctr],
                              values[ctr].Equals(restoredValues[ctr]) ? "=" : "<>");
    }
}
// The example displays the following output:
//       2.17821782178218 <> 2.17821782178218
//       0.333333333333333 <> 0.333333333333333
//       3.14159265358979 <> 3.14159265358979

open System
open System.IO

let values = [ 2.2 / 1.01; 1. / 3.; Math.PI ]

using (new StreamWriter(@".\Doubles.dat")) (fun sw ->
    for i = 0 to values.Length - 1 do
        sw.Write(string values[i])
        if i <> values.Length - 1 then
            sw.Write "|")

using (new StreamReader(@".\Doubles.dat")) (fun sr ->
    let temp = sr.ReadToEnd()
    let tempStrings = temp.Split '|'

    let restoredValues =
        [ for i = 0 to tempStrings.Length - 1 do
              Double.Parse tempStrings[i] ]

    for i = 0 to values.Length - 1 do
        printfn $"""{values[i]} {if values[ i ].Equals restoredValues[i] then "=" else "<>"} {restoredValues[i]}""")

// The example displays the following output:
//       2.17821782178218 <> 2.17821782178218
//       0.333333333333333 <> 0.333333333333333
//       3.14159265358979 <> 3.14159265358979

Imports System.IO

Module Example12
    Public Sub Main()
        Dim sw As New StreamWriter(".\Doubles.dat")
        Dim values() As Double = {2.2 / 1.01, 1.0 / 3, Math.PI}
        For ctr As Integer = 0 To values.Length - 1
            sw.Write(values(ctr).ToString())
            If ctr <> values.Length - 1 Then sw.Write("|")
        Next
        sw.Close()

        Dim restoredValues(values.Length - 1) As Double
        Dim sr As New StreamReader(".\Doubles.dat")
        Dim temp As String = sr.ReadToEnd()
        Dim tempStrings() As String = temp.Split("|"c)
        For ctr As Integer = 0 To tempStrings.Length - 1
            restoredValues(ctr) = Double.Parse(tempStrings(ctr))
        Next

        For ctr As Integer = 0 To values.Length - 1
            Console.WriteLine("{0} {2} {1}", values(ctr),
                           restoredValues(ctr),
                           If(values(ctr).Equals(restoredValues(ctr)), "=", "<>"))
        Next
    End Sub
End Module
' The example displays the following output:
'       2.17821782178218 <> 2.17821782178218
'       0.333333333333333 <> 0.333333333333333
'       3.14159265358979 <> 3.14159265358979

在此情況下，可以使用「G17」標準數值格式字串成功四捨五入，以保留值的完整有效位數 Double ，如下列範例所示。

using System;
using System.IO;

public class Example12
{
    public static void Main()
    {
        StreamWriter sw = new StreamWriter(@".\Doubles.dat");
        Double[] values = { 2.2 / 1.01, 1.0 / 3, Math.PI };
        for (int ctr = 0; ctr < values.Length; ctr++)
            sw.Write("{0:G17}{1}", values[ctr], ctr < values.Length - 1 ? "|" : "");

        sw.Close();

        Double[] restoredValues = new Double[values.Length];
        StreamReader sr = new StreamReader(@".\Doubles.dat");
        string temp = sr.ReadToEnd();
        string[] tempStrings = temp.Split('|');
        for (int ctr = 0; ctr < tempStrings.Length; ctr++)
            restoredValues[ctr] = Double.Parse(tempStrings[ctr]);

        for (int ctr = 0; ctr < values.Length; ctr++)
            Console.WriteLine("{0} {2} {1}", values[ctr],
                              restoredValues[ctr],
                              values[ctr].Equals(restoredValues[ctr]) ? "=" : "<>");
    }
}
// The example displays the following output:
//       2.17821782178218 = 2.17821782178218
//       0.333333333333333 = 0.333333333333333
//       3.14159265358979 = 3.14159265358979

open System
open System.IO

let values = [ 2.2 / 1.01; 1. / 3.; Math.PI ]

using (new StreamWriter(@".\Doubles.dat")) (fun sw -> 
    for i = 0 to values.Length - 1 do
        sw.Write $"""{values[i]:G17}{if i < values.Length - 1 then "|" else ""}""")

using (new StreamReader(@".\Doubles.dat")) (fun sr ->
    let temp = sr.ReadToEnd()
    let tempStrings = temp.Split '|'
    
    let restoredValues = 
      [ for i = 0 to tempStrings.Length - 1 do
            Double.Parse tempStrings[i] ]

    for i = 0 to values.Length - 1 do
        printfn $"""{restoredValues[i]} {if values[i].Equals restoredValues[i] then "=" else "<>"} {values[i]}""")

// The example displays the following output:
//       2.17821782178218 = 2.17821782178218
//       0.333333333333333 = 0.333333333333333
//       3.14159265358979 = 3.14159265358979

Imports System.IO

Module Example13
    Public Sub Main()
        Dim sw As New StreamWriter(".\Doubles.dat")
        Dim values() As Double = {2.2 / 1.01, 1.0 / 3, Math.PI}
        For ctr As Integer = 0 To values.Length - 1
            sw.Write("{0:G17}{1}", values(ctr),
                  If(ctr < values.Length - 1, "|", ""))
        Next
        sw.Close()

        Dim restoredValues(values.Length - 1) As Double
        Dim sr As New StreamReader(".\Doubles.dat")
        Dim temp As String = sr.ReadToEnd()
        Dim tempStrings() As String = temp.Split("|"c)
        For ctr As Integer = 0 To tempStrings.Length - 1
            restoredValues(ctr) = Double.Parse(tempStrings(ctr))
        Next

        For ctr As Integer = 0 To values.Length - 1
            Console.WriteLine("{0} {2} {1}", values(ctr),
                           restoredValues(ctr),
                           If(values(ctr).Equals(restoredValues(ctr)), "=", "<>"))
        Next
    End Sub
End Module
' The example displays the following output:
'       2.17821782178218 = 2.17821782178218
'       0.333333333333333 = 0.333333333333333
'       3.14159265358979 = 3.14159265358979

重要

搭配 Double 值使用時，在某些情況下，“R” 格式規範無法成功往返原始值。若要確保 Double 值能順利往返，請使用「G17」格式規範。

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

using System;

public class Example9
{
    public static void Main()
    {
        Double value1 = 1 / 3.0;
        Single sValue2 = 1 / 3.0f;
        Double value2 = (Double)sValue2;
        Console.WriteLine("{0:R} = {1:R}: {2}", value1, value2,
                                            value1.Equals(value2));
    }
}
// The example displays the following output:
//        0.33333333333333331 = 0.3333333432674408: 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 Main()
        Dim value1 As Double = 1 / 3
        Dim sValue2 As Single = 1 / 3
        Dim value2 As Double = CDbl(sValue2)
        Console.WriteLine("{0} = {1}: {2}", value1, value2, value1.Equals(value2))
    End Sub
End Module
' The example displays the following output:
'       0.33333333333333331 = 0.3333333432674408: 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);
// On 32-bit versions of the .NET Framework, the output is:
//    Double value from literal:        -4.42330604244772E-305
//    Double value from variable:       -4.42330604244772E-305
//    Double value from Parse method:   -4.42330604244772E-305
//
// On other versions of the .NET Framework, the output is:
//    Double value from literal:      -4.4233060424477198E-305
//    Double value from variable:     -4.4233060424477198E-305
//    Double value from Parse method:   -4.42330604244772E-305

let value = -4.42330604244772E-305

let fromLiteral = -4.42330604244772E-305
let fromVariable = value
let fromParse = Double.Parse "-4.42330604244772E-305"

printfn $"Double value from literal: {fromLiteral,29:R}"
printfn $"Double value from variable: {fromVariable,28:R}"
printfn $"Double value from Parse method: {fromParse,24:R}"
// On 32-bit versions of the .NET Framework, the output is:
//    Double value from literal:        -4.42330604244772E-305
//    Double value from variable:       -4.42330604244772E-305
//    Double value from Parse method:   -4.42330604244772E-305
//
// On other versions of the .NET Framework, the output is:
//    Double value from literal:      -4.4233060424477198E-305
//    Double value from variable:     -4.4233060424477198E-305
//    Double value from Parse method:   -4.42330604244772E-305

Dim value As Double = -4.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)
' 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

測試是否相等

若要視為相等，兩個 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("{0:R} = {1:R}: {2}", value1, value2, value1.Equals(value2));
   }
}
// The example displays the following output:
//        0.333333333333333 = 0.33333333333333331: False

open System

let value1 = 0.333333333333333
let value2 = 1. / 3.
printfn $"{value1:R} = {value2:R}: {value1.Equals value2}"
// The example displays the following output:
//        0.333333333333333 = 0.33333333333333331: False

Module Example1
    Public Sub Main()
        Dim value1 As Double = 0.333333333333333
        Dim value2 As Double = 1 / 3
        Console.WriteLine("{0:R} = {1:R}: {2}", value1, value2, value1.Equals(value2))
    End Sub
End Module
' The example displays the following output:
'       0.333333333333333 = 0.33333333333333331: False

遵循不同程式代碼路徑且以不同方式操作的導出值通常會證明不相等。在下列範例中，一個 Double 值是平方，然後計算平方根來還原原始值。第二個 Double 乘以 3.51，並在結果的平方根除以 3.51 以還原原始值之前。雖然這兩個值看起來完全相同，但對方法的 Equals(Double) 呼叫表示它們不相等。使用「R」標準格式字串傳回結果字串，以顯示每個 Double 值的所有有效位數，顯示第二個值小於第一個值。0000000000001小於第一個。

using System;

public class Example1
{
    public static void Main()
    {
        double value1 = 100.10142;
        value1 = Math.Sqrt(Math.Pow(value1, 2));
        double value2 = Math.Pow(value1 * 3.51, 2);
        value2 = Math.Sqrt(value2) / 3.51;
        Console.WriteLine("{0} = {1}: {2}\n",
                          value1, value2, value1.Equals(value2));
        Console.WriteLine("{0:R} = {1:R}", value1, value2);
    }
}
// The example displays the following output:
//    100.10142 = 100.10142: False
//
//    100.10142 = 100.10141999999999

open System

let value1 = 
    Math.Pow(100.10142, 2)
    |> sqrt

let value2 = 
    let v = pown (value1 * 3.51) 2
    (Math.Sqrt v) / 3.51

printfn $"{value1} = {value2}: {value1.Equals value2}\n"
printfn $"{value1:R} = {value2:R}"
// The example displays the following output:
//    100.10142 = 100.10142: False
//
//    100.10142 = 100.10141999999999

Module Example2
    Public Sub Main()
        Dim value1 As Double = 100.10142
        value1 = Math.Sqrt(Math.Pow(value1, 2))
        Dim value2 As Double = Math.Pow(value1 * 3.51, 2)
        value2 = Math.Sqrt(value2) / 3.51
        Console.WriteLine("{0} = {1}: {2}",
                        value1, value2, value1.Equals(value2))
        Console.WriteLine()
        Console.WriteLine("{0:R} = {1:R}", value1, value2)
    End Sub
End Module
' The example displays the following output:
'    100.10142 = 100.10142: False
'    
'    100.10142 = 100.10141999999999

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

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

using System;

public class Example2
{
    public static void Main()
    {
        double value1 = .333333333333333;
        double value2 = 1.0 / 3;
        int precision = 7;
        value1 = Math.Round(value1, precision);
        value2 = Math.Round(value2, precision);
        Console.WriteLine("{0:R} = {1:R}: {2}", value1, value2, value1.Equals(value2));
    }
}
// The example displays the following output:
//        0.3333333 = 0.3333333: 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 Main()
        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:R} = {1:R}: {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) 方法。

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

警告

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

下列範例會使用後者方法來定義方法，以測試兩個 IsApproximatelyEqual 值之間的相對差異。它也會對比對 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("{0:R} = {1:R}: {2}", one1, one2, one1.Equals(one2));
        Console.WriteLine("{0:R} is approximately equal to {1:R}: {2}",
                          one1, one2,
                          IsApproximatelyEqual(one1, one2, .000000001));
    }

    static bool IsApproximatelyEqual(double value1, double value2, double epsilon)
    {
        // If they are equal anyway, just return True.
        if (value1.Equals(value2))
            return true;

        // Handle NaN, Infinity.
        if (Double.IsInfinity(value1) | Double.IsNaN(value1))
            return value1.Equals(value2);
        else if (Double.IsInfinity(value2) | Double.IsNaN(value2))
            return value1.Equals(value2);

        // Handle zero to avoid division by zero
        double divisor = Math.Max(value1, value2);
        if (divisor.Equals(0))
            divisor = Math.Min(value1, value2);

        return Math.Abs((value1 - value2) / divisor) <= epsilon;
    }
}
// The example displays the following output:
//       1 = 0.99999999999999989: False
//       1 is approximately equal to 0.99999999999999989: 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 Main()
        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:R} = {1:R}: {2}", one1, one2, one1.Equals(one2))
        Console.WriteLine("{0:R} is approximately equal to {1:R}: {2}",
                        one1, one2,
                        IsApproximatelyEqual(one1, one2, 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

浮點值和例外狀況

不同於整數型別的作業，在溢位或不合法的作業時擲回例外狀況，例如除以零，具有浮點值的作業不會擲回例外狀況。相反地，在特殊情況下，浮點運算的結果為零、正無限大、負無限大，或不是數位（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("{0} * {1} = {2}", value1, value2, result);
        Console.WriteLine("{0} = 0: {1}", result, result.Equals(0.0));
    }
}
// The example displays the following output:
//       1.16328759815342E-225 * 9.1642346778E-175 = 0
//       0 = 0: 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 Main()
        Dim value1 As Double = 1.1632875981534209E-225
        Dim value2 As Double = 9.1642346778E-175
        Dim result As Double = value1 * value2
        Console.WriteLine("{0} * {1} = {2}", value1, value2, result)
        Console.WriteLine("{0} = 0: {1}", result, result.Equals(0.0))
    End Sub
End Module
' The example displays the following output:
'       1.16328759815342E-225 * 9.1642346778E-175 = 0
'       0 = 0: True

如果浮點運算的結果大小超過目的格式的範圍，則作業的結果會 PositiveInfinity 是或 NegativeInfinity，適合結果的正負號。溢位作業的結果為 PositiveInfinity，而溢位Double.MaxValue 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: {0}",
                           Double.IsPositiveInfinity(result));
        Console.WriteLine("NegativeInfinity: {0}\n",
                          Double.IsNegativeInfinity(result));

        value1 = -value1;
        result = value1 * value2;
        Console.WriteLine("PositiveInfinity: {0}",
                           Double.IsPositiveInfinity(result));
        Console.WriteLine("NegativeInfinity: {0}",
                          Double.IsNegativeInfinity(result));
    }
}

// The example displays the following output:
//       PositiveInfinity: True
//       NegativeInfinity: False
//
//       PositiveInfinity: False
//       NegativeInfinity: 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 Main()
        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最小值或最大值轉換為。

using System;

public class Example4
{
    public static void Main()
    {
        dynamic[] values = { Byte.MinValue, Byte.MaxValue, Decimal.MinValue,
                           Decimal.MaxValue, Int16.MinValue, Int16.MaxValue,
                           Int32.MinValue, Int32.MaxValue, Int64.MinValue,
                           Int64.MaxValue, SByte.MinValue, SByte.MaxValue,
                           Single.MinValue, Single.MaxValue, UInt16.MinValue,
                           UInt16.MaxValue, UInt32.MinValue, UInt32.MaxValue,
                           UInt64.MinValue, UInt64.MaxValue };
        double dblValue;
        foreach (var value in values)
        {
            if (value.GetType() == typeof(Decimal))
                dblValue = (Double)value;
            else
                dblValue = value;
            Console.WriteLine("{0} ({1}) --> {2:R} ({3})",
                              value, value.GetType().Name,
                              dblValue, dblValue.GetType().Name);
        }
    }
}
// The example displays the following output:
//    0 (Byte) --> 0 (Double)
//    255 (Byte) --> 255 (Double)
//    -79228162514264337593543950335 (Decimal) --> -7.9228162514264338E+28 (Double)
//    79228162514264337593543950335 (Decimal) --> 7.9228162514264338E+28 (Double)
//    -32768 (Int16) --> -32768 (Double)
//    32767 (Int16) --> 32767 (Double)
//    -2147483648 (Int32) --> -2147483648 (Double)
//    2147483647 (Int32) --> 2147483647 (Double)
//    -9223372036854775808 (Int64) --> -9.2233720368547758E+18 (Double)
//    9223372036854775807 (Int64) --> 9.2233720368547758E+18 (Double)
//    -128 (SByte) --> -128 (Double)
//    127 (SByte) --> 127 (Double)
//    -3.402823E+38 (Single) --> -3.4028234663852886E+38 (Double)
//    3.402823E+38 (Single) --> 3.4028234663852886E+38 (Double)
//    0 (UInt16) --> 0 (Double)
//    65535 (UInt16) --> 65535 (Double)
//    0 (UInt32) --> 0 (Double)
//    4294967295 (UInt32) --> 4294967295 (Double)
//    0 (UInt64) --> 0 (Double)
//    18446744073709551615 (UInt64) --> 1.8446744073709552E+19 (Double)

open System

let values: obj[] = 
    [| Byte.MinValue; Byte.MaxValue; Decimal.MinValue
       Decimal.MaxValue; Int16.MinValue; Int16.MaxValue
       Int32.MinValue; Int32.MaxValue; Int64.MinValue
       Int64.MaxValue; SByte.MinValue; SByte.MaxValue
       Single.MinValue; Single.MaxValue; UInt16.MinValue
       UInt16.MaxValue; UInt32.MinValue, UInt32.MaxValue
       UInt64.MinValue; UInt64.MaxValue |]

for value in values do
    let dblValue = value :?> double
    printfn $"{value} ({value.GetType().Name}) --> {dblValue:R} ({dblValue.GetType().Name})"
// The example displays the following output:
//    0 (Byte) --> 0 (Double)
//    255 (Byte) --> 255 (Double)
//    -79228162514264337593543950335 (Decimal) --> -7.9228162514264338E+28 (Double)
//    79228162514264337593543950335 (Decimal) --> 7.9228162514264338E+28 (Double)
//    -32768 (Int16) --> -32768 (Double)
//    32767 (Int16) --> 32767 (Double)
//    -2147483648 (Int32) --> -2147483648 (Double)
//    2147483647 (Int32) --> 2147483647 (Double)
//    -9223372036854775808 (Int64) --> -9.2233720368547758E+18 (Double)
//    9223372036854775807 (Int64) --> 9.2233720368547758E+18 (Double)
//    -128 (SByte) --> -128 (Double)
//    127 (SByte) --> 127 (Double)
//    -3.402823E+38 (Single) --> -3.4028234663852886E+38 (Double)
//    3.402823E+38 (Single) --> 3.4028234663852886E+38 (Double)
//    0 (UInt16) --> 0 (Double)
//    65535 (UInt16) --> 65535 (Double)
//    0 (UInt32) --> 0 (Double)
//    4294967295 (UInt32) --> 4294967295 (Double)
//    0 (UInt64) --> 0 (Double)
//    18446744073709551615 (UInt64) --> 1.8446744073709552E+19 (Double)

Module Example5
    Public Sub Main()
        Dim values() As Object = {Byte.MinValue, Byte.MaxValue, Decimal.MinValue,
                                 Decimal.MaxValue, Int16.MinValue, Int16.MaxValue,
                                 Int32.MinValue, Int32.MaxValue, Int64.MinValue,
                                 Int64.MaxValue, SByte.MinValue, SByte.MaxValue,
                                 Single.MinValue, Single.MaxValue, UInt16.MinValue,
                                 UInt16.MaxValue, UInt32.MinValue, UInt32.MaxValue,
                                 UInt64.MinValue, UInt64.MaxValue}
        Dim dblValue As Double
        For Each value In values
            dblValue = value
            Console.WriteLine("{0} ({1}) --> {2:R} ({3})",
                           value, value.GetType().Name,
                           dblValue, dblValue.GetType().Name)
        Next
    End Sub
End Module
' The example displays the following output:
'    0 (Byte) --> 0 (Double)
'    255 (Byte) --> 255 (Double)
'    -79228162514264337593543950335 (Decimal) --> -7.9228162514264338E+28 (Double)
'    79228162514264337593543950335 (Decimal) --> 7.9228162514264338E+28 (Double)
'    -32768 (Int16) --> -32768 (Double)
'    32767 (Int16) --> 32767 (Double)
'    -2147483648 (Int32) --> -2147483648 (Double)
'    2147483647 (Int32) --> 2147483647 (Double)
'    -9223372036854775808 (Int64) --> -9.2233720368547758E+18 (Double)
'    9223372036854775807 (Int64) --> 9.2233720368547758E+18 (Double)
'    -128 (SByte) --> -128 (Double)
'    127 (SByte) --> 127 (Double)
'    -3.402823E+38 (Single) --> -3.4028234663852886E+38 (Double)
'    3.402823E+38 (Single) --> 3.4028234663852886E+38 (Double)
'    0 (UInt16) --> 0 (Double)
'    65535 (UInt16) --> 65535 (Double)
'    0 (UInt32) --> 0 (Double)
'    4294967295 (UInt32) --> 4294967295 (Double)
'    0 (UInt64) --> 0 (Double)
'    18446744073709551615 (UInt64) --> 1.8446744073709552E+19 (Double)

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

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

將值轉換成 Double 任何其他基本數值數據類型的值是縮小轉換，而且需要轉換運算元（在 C#中）、轉換方法（在 Visual Basic 中），或呼叫 Convert 方法。超出目標數據類型範圍的值，這些數據類型是由目標類型的 MinValue 和 MaxValue 屬性所定義，其行為如下表所示。

目標類型	結果
任何整數類型	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 中所示）或截斷時，小數部分就會遺失。若要轉換成 Decimal 和 Single 值，值 Double 在目標數據類型中可能沒有精確的表示法。

下列範例會將一些 Double 值轉換成數個其他數值類型。轉換發生在 Visual Basic 中已核取的內容中（預設值）、C# 中（因為 checked 關鍵詞），以及 F# 中（因為 Checked 模組）。範例的輸出會顯示已核取未核取內容中轉換的結果。您可以在 Visual Basic 中未核取的內容中執行轉換，方法是使用/removeintchecks+編譯程式參數進行編譯、在 C# 中將語句批注化，並在 F# 中將語句批注checkedopen 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("{0} ({1}) --> {2} (0x{2:X16}) ({3})",
                                      value, value.GetType().Name,
                                      lValue, lValue.GetType().Name);
                }
                catch (OverflowException)
                {
                    Console.WriteLine("Unable to convert {0} to Int64.", value);
                }
                try
                {
                    UInt64 ulValue = (ulong)value;
                    Console.WriteLine("{0} ({1}) --> {2} (0x{2:X16}) ({3})",
                                      value, value.GetType().Name,
                                      ulValue, ulValue.GetType().Name);
                }
                catch (OverflowException)
                {
                    Console.WriteLine("Unable to convert {0} to UInt64.", value);
                }
                try
                {
                    Decimal dValue = (decimal)value;
                    Console.WriteLine("{0} ({1}) --> {2} ({3})",
                                      value, value.GetType().Name,
                                      dValue, dValue.GetType().Name);
                }
                catch (OverflowException)
                {
                    Console.WriteLine("Unable to convert {0} to Decimal.", value);
                }
                try
                {
                    Single sValue = (float)value;
                    Console.WriteLine("{0} ({1}) --> {2} ({3})",
                                      value, value.GetType().Name,
                                      sValue, sValue.GetType().Name);
                }
                catch (OverflowException)
                {
                    Console.WriteLine("Unable to convert {0} to Single.", value);
                }
                Console.WriteLine();
            }
        }
    }
}
// The example displays the following output for conversions performed
// in a checked context:
//       Unable to convert -1.79769313486232E+308 to Int64.
//       Unable to convert -1.79769313486232E+308 to UInt64.
//       Unable to convert -1.79769313486232E+308 to Decimal.
//       -1.79769313486232E+308 (Double) --> -Infinity (Single)
//
//       -67890.1234 (Double) --> -67890 (0xFFFFFFFFFFFEF6CE) (Int64)
//       Unable to convert -67890.1234 to UInt64.
//       -67890.1234 (Double) --> -67890.1234 (Decimal)
//       -67890.1234 (Double) --> -67890.13 (Single)
//
//       -12345.6789 (Double) --> -12345 (0xFFFFFFFFFFFFCFC7) (Int64)
//       Unable to convert -12345.6789 to UInt64.
//       -12345.6789 (Double) --> -12345.6789 (Decimal)
//       -12345.6789 (Double) --> -12345.68 (Single)
//
//       12345.6789 (Double) --> 12345 (0x0000000000003039) (Int64)
//       12345.6789 (Double) --> 12345 (0x0000000000003039) (UInt64)
//       12345.6789 (Double) --> 12345.6789 (Decimal)
//       12345.6789 (Double) --> 12345.68 (Single)
//
//       67890.1234 (Double) --> 67890 (0x0000000000010932) (Int64)
//       67890.1234 (Double) --> 67890 (0x0000000000010932) (UInt64)
//       67890.1234 (Double) --> 67890.1234 (Decimal)
//       67890.1234 (Double) --> 67890.13 (Single)
//
//       Unable to convert 1.79769313486232E+308 to Int64.
//       Unable to convert 1.79769313486232E+308 to UInt64.
//       Unable to convert 1.79769313486232E+308 to Decimal.
//       1.79769313486232E+308 (Double) --> Infinity (Single)
//
//       Unable to convert NaN to Int64.
//       Unable to convert NaN to UInt64.
//       Unable to convert NaN to Decimal.
//       NaN (Double) --> NaN (Single)
//
//       Unable to convert Infinity to Int64.
//       Unable to convert Infinity to UInt64.
//       Unable to convert Infinity to Decimal.
//       Infinity (Double) --> Infinity (Single)
//
//       Unable to convert -Infinity to Int64.
//       Unable to convert -Infinity to UInt64.
//       Unable to convert -Infinity to Decimal.
//       -Infinity (Double) --> -Infinity (Single)
// The example displays the following output for conversions performed
// in an unchecked context:
//       -1.79769313486232E+308 (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       -1.79769313486232E+308 (Double) --> 9223372036854775808 (0x8000000000000000) (UInt64)
//       Unable to convert -1.79769313486232E+308 to Decimal.
//       -1.79769313486232E+308 (Double) --> -Infinity (Single)
//
//       -67890.1234 (Double) --> -67890 (0xFFFFFFFFFFFEF6CE) (Int64)
//       -67890.1234 (Double) --> 18446744073709483726 (0xFFFFFFFFFFFEF6CE) (UInt64)
//       -67890.1234 (Double) --> -67890.1234 (Decimal)
//       -67890.1234 (Double) --> -67890.13 (Single)
//
//       -12345.6789 (Double) --> -12345 (0xFFFFFFFFFFFFCFC7) (Int64)
//       -12345.6789 (Double) --> 18446744073709539271 (0xFFFFFFFFFFFFCFC7) (UInt64)
//       -12345.6789 (Double) --> -12345.6789 (Decimal)
//       -12345.6789 (Double) --> -12345.68 (Single)
//
//       12345.6789 (Double) --> 12345 (0x0000000000003039) (Int64)
//       12345.6789 (Double) --> 12345 (0x0000000000003039) (UInt64)
//       12345.6789 (Double) --> 12345.6789 (Decimal)
//       12345.6789 (Double) --> 12345.68 (Single)
//
//       67890.1234 (Double) --> 67890 (0x0000000000010932) (Int64)
//       67890.1234 (Double) --> 67890 (0x0000000000010932) (UInt64)
//       67890.1234 (Double) --> 67890.1234 (Decimal)
//       67890.1234 (Double) --> 67890.13 (Single)
//
//       1.79769313486232E+308 (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       1.79769313486232E+308 (Double) --> 0 (0x0000000000000000) (UInt64)
//       Unable to convert 1.79769313486232E+308 to Decimal.
//       1.79769313486232E+308 (Double) --> Infinity (Single)
//
//       NaN (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       NaN (Double) --> 0 (0x0000000000000000) (UInt64)
//       Unable to convert NaN to Decimal.
//       NaN (Double) --> NaN (Single)
//
//       Infinity (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       Infinity (Double) --> 0 (0x0000000000000000) (UInt64)
//       Unable to convert Infinity to Decimal.
//       Infinity (Double) --> Infinity (Single)
//
//       -Infinity (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       -Infinity (Double) --> 9223372036854775808 (0x8000000000000000) (UInt64)
//       Unable to convert -Infinity to Decimal.
//       -Infinity (Double) --> -Infinity (Single)

open System
open Checked

let values = 
    [| Double.MinValue; -67890.1234; -12345.6789
       12345.6789; 67890.1234; Double.MaxValue
       Double.NaN; Double.PositiveInfinity;
       Double.NegativeInfinity |]

for value in values do
    try
        let lValue = int64 value
        printfn $"{value} ({value.GetType().Name}) --> {lValue} (0x{lValue:X16}) ({lValue.GetType().Name})"
    with :? OverflowException ->
        printfn $"Unable to convert {value} to Int64."
    try
        let ulValue = uint64 value
        printfn $"{value} ({value.GetType().Name}) --> {ulValue} (0x{ulValue:X16}) ({ulValue.GetType().Name})"
    with :? OverflowException ->
        printfn $"Unable to convert {value} to UInt64."
    try
        let dValue = decimal value
        printfn $"{value} ({value.GetType().Name}) --> {dValue} ({dValue.GetType().Name})"
    with :? OverflowException ->
        printfn $"Unable to convert {value} to Decimal."
    try
        let sValue = float32 value
        printfn $"{value} ({value.GetType().Name}) --> {sValue} ({sValue.GetType().Name})"
    with :? OverflowException ->
        printfn $"Unable to convert {value} to Single."
    printfn ""
// The example displays the following output for conversions performed
// in a checked context:
//       Unable to convert -1.79769313486232E+308 to Int64.
//       Unable to convert -1.79769313486232E+308 to UInt64.
//       Unable to convert -1.79769313486232E+308 to Decimal.
//       -1.79769313486232E+308 (Double) --> -Infinity (Single)
//
//       -67890.1234 (Double) --> -67890 (0xFFFFFFFFFFFEF6CE) (Int64)
//       Unable to convert -67890.1234 to UInt64.
//       -67890.1234 (Double) --> -67890.1234 (Decimal)
//       -67890.1234 (Double) --> -67890.13 (Single)
//
//       -12345.6789 (Double) --> -12345 (0xFFFFFFFFFFFFCFC7) (Int64)
//       Unable to convert -12345.6789 to UInt64.
//       -12345.6789 (Double) --> -12345.6789 (Decimal)
//       -12345.6789 (Double) --> -12345.68 (Single)
//
//       12345.6789 (Double) --> 12345 (0x0000000000003039) (Int64)
//       12345.6789 (Double) --> 12345 (0x0000000000003039) (UInt64)
//       12345.6789 (Double) --> 12345.6789 (Decimal)
//       12345.6789 (Double) --> 12345.68 (Single)
//
//       67890.1234 (Double) --> 67890 (0x0000000000010932) (Int64)
//       67890.1234 (Double) --> 67890 (0x0000000000010932) (UInt64)
//       67890.1234 (Double) --> 67890.1234 (Decimal)
//       67890.1234 (Double) --> 67890.13 (Single)
//
//       Unable to convert 1.79769313486232E+308 to Int64.
//       Unable to convert 1.79769313486232E+308 to UInt64.
//       Unable to convert 1.79769313486232E+308 to Decimal.
//       1.79769313486232E+308 (Double) --> Infinity (Single)
//
//       Unable to convert NaN to Int64.
//       Unable to convert NaN to UInt64.
//       Unable to convert NaN to Decimal.
//       NaN (Double) --> NaN (Single)
//
//       Unable to convert Infinity to Int64.
//       Unable to convert Infinity to UInt64.
//       Unable to convert Infinity to Decimal.
//       Infinity (Double) --> Infinity (Single)
//
//       Unable to convert -Infinity to Int64.
//       Unable to convert -Infinity to UInt64.
//       Unable to convert -Infinity to Decimal.
//       -Infinity (Double) --> -Infinity (Single)
// The example displays the following output for conversions performed
// in an unchecked context:
//       -1.79769313486232E+308 (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       -1.79769313486232E+308 (Double) --> 9223372036854775808 (0x8000000000000000) (UInt64)
//       Unable to convert -1.79769313486232E+308 to Decimal.
//       -1.79769313486232E+308 (Double) --> -Infinity (Single)
//
//       -67890.1234 (Double) --> -67890 (0xFFFFFFFFFFFEF6CE) (Int64)
//       -67890.1234 (Double) --> 18446744073709483726 (0xFFFFFFFFFFFEF6CE) (UInt64)
//       -67890.1234 (Double) --> -67890.1234 (Decimal)
//       -67890.1234 (Double) --> -67890.13 (Single)
//
//       -12345.6789 (Double) --> -12345 (0xFFFFFFFFFFFFCFC7) (Int64)
//       -12345.6789 (Double) --> 18446744073709539271 (0xFFFFFFFFFFFFCFC7) (UInt64)
//       -12345.6789 (Double) --> -12345.6789 (Decimal)
//       -12345.6789 (Double) --> -12345.68 (Single)
//
//       12345.6789 (Double) --> 12345 (0x0000000000003039) (Int64)
//       12345.6789 (Double) --> 12345 (0x0000000000003039) (UInt64)
//       12345.6789 (Double) --> 12345.6789 (Decimal)
//       12345.6789 (Double) --> 12345.68 (Single)
//
//       67890.1234 (Double) --> 67890 (0x0000000000010932) (Int64)
//       67890.1234 (Double) --> 67890 (0x0000000000010932) (UInt64)
//       67890.1234 (Double) --> 67890.1234 (Decimal)
//       67890.1234 (Double) --> 67890.13 (Single)
//
//       1.79769313486232E+308 (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       1.79769313486232E+308 (Double) --> 0 (0x0000000000000000) (UInt64)
//       Unable to convert 1.79769313486232E+308 to Decimal.
//       1.79769313486232E+308 (Double) --> Infinity (Single)
//
//       NaN (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       NaN (Double) --> 0 (0x0000000000000000) (UInt64)
//       Unable to convert NaN to Decimal.
//       NaN (Double) --> NaN (Single)
//
//       Infinity (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       Infinity (Double) --> 0 (0x0000000000000000) (UInt64)
//       Unable to convert Infinity to Decimal.
//       Infinity (Double) --> Infinity (Single)
//
//       -Infinity (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       -Infinity (Double) --> 9223372036854775808 (0x8000000000000000) (UInt64)
//       Unable to convert -Infinity to Decimal.
//       -Infinity (Double) --> -Infinity (Single)

Module Example6
    Public Sub Main()
        Dim values() As Double = {Double.MinValue, -67890.1234, -12345.6789,
                                 12345.6789, 67890.1234, Double.MaxValue,
                                 Double.NaN, Double.PositiveInfinity,
                                 Double.NegativeInfinity}
        For Each value In values
            Try
                Dim lValue As Int64 = CLng(value)
                Console.WriteLine("{0} ({1}) --> {2} (0x{2:X16}) ({3})",
                               value, value.GetType().Name,
                               lValue, lValue.GetType().Name)
            Catch e As OverflowException
                Console.WriteLine("Unable to convert {0} to Int64.", value)
            End Try
            Try
                Dim ulValue As UInt64 = CULng(value)
                Console.WriteLine("{0} ({1}) --> {2} (0x{2:X16}) ({3})",
                               value, value.GetType().Name,
                               ulValue, ulValue.GetType().Name)
            Catch e As OverflowException
                Console.WriteLine("Unable to convert {0} to UInt64.", value)
            End Try
            Try
                Dim dValue As Decimal = CDec(value)
                Console.WriteLine("{0} ({1}) --> {2} ({3})",
                               value, value.GetType().Name,
                               dValue, dValue.GetType().Name)
            Catch e As OverflowException
                Console.WriteLine("Unable to convert {0} to Decimal.", value)
            End Try
            Try
                Dim sValue As Single = CSng(value)
                Console.WriteLine("{0} ({1}) --> {2} ({3})",
                               value, value.GetType().Name,
                               sValue, sValue.GetType().Name)
            Catch e As OverflowException
                Console.WriteLine("Unable to convert {0} to Single.", value)
            End Try
            Console.WriteLine()
        Next
    End Sub
End Module
' The example displays the following output for conversions performed
' in a checked context:
'       Unable to convert -1.79769313486232E+308 to Int64.
'       Unable to convert -1.79769313486232E+308 to UInt64.
'       Unable to convert -1.79769313486232E+308 to Decimal.
'       -1.79769313486232E+308 (Double) --> -Infinity (Single)
'
'       -67890.1234 (Double) --> -67890 (0xFFFFFFFFFFFEF6CE) (Int64)
'       Unable to convert -67890.1234 to UInt64.
'       -67890.1234 (Double) --> -67890.1234 (Decimal)
'       -67890.1234 (Double) --> -67890.13 (Single)
'
'       -12345.6789 (Double) --> -12346 (0xFFFFFFFFFFFFCFC6) (Int64)
'       Unable to convert -12345.6789 to UInt64.
'       -12345.6789 (Double) --> -12345.6789 (Decimal)
'       -12345.6789 (Double) --> -12345.68 (Single)
'
'       12345.6789 (Double) --> 12346 (0x000000000000303A) (Int64)
'       12345.6789 (Double) --> 12346 (0x000000000000303A) (UInt64)
'       12345.6789 (Double) --> 12345.6789 (Decimal)
'       12345.6789 (Double) --> 12345.68 (Single)
'
'       67890.1234 (Double) --> 67890 (0x0000000000010932) (Int64)
'       67890.1234 (Double) --> 67890 (0x0000000000010932) (UInt64)
'       67890.1234 (Double) --> 67890.1234 (Decimal)
'       67890.1234 (Double) --> 67890.13 (Single)
'
'       Unable to convert 1.79769313486232E+308 to Int64.
'       Unable to convert 1.79769313486232E+308 to UInt64.
'       Unable to convert 1.79769313486232E+308 to Decimal.
'       1.79769313486232E+308 (Double) --> Infinity (Single)
'
'       Unable to convert NaN to Int64.
'       Unable to convert NaN to UInt64.
'       Unable to convert NaN to Decimal.
'       NaN (Double) --> NaN (Single)
'
'       Unable to convert Infinity to Int64.
'       Unable to convert Infinity to UInt64.
'       Unable to convert Infinity to Decimal.
'       Infinity (Double) --> Infinity (Single)
'
'       Unable to convert -Infinity to Int64.
'       Unable to convert -Infinity to UInt64.
'       Unable to convert -Infinity to Decimal.
'       -Infinity (Double) --> -Infinity (Single)
' The example displays the following output for conversions performed
' in an unchecked context:
'       -1.79769313486232E+308 (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
'       -1.79769313486232E+308 (Double) --> 9223372036854775808 (0x8000000000000000) (UInt64)
'       Unable to convert -1.79769313486232E+308 to Decimal.
'       -1.79769313486232E+308 (Double) --> -Infinity (Single)
'
'       -67890.1234 (Double) --> -67890 (0xFFFFFFFFFFFEF6CE) (Int64)
'       -67890.1234 (Double) --> 18446744073709483726 (0xFFFFFFFFFFFEF6CE) (UInt64)
'       -67890.1234 (Double) --> -67890.1234 (Decimal)
'       -67890.1234 (Double) --> -67890.13 (Single)
'
'       -12345.6789 (Double) --> -12346 (0xFFFFFFFFFFFFCFC6) (Int64)
'       -12345.6789 (Double) --> 18446744073709539270 (0xFFFFFFFFFFFFCFC6) (UInt64)
'       -12345.6789 (Double) --> -12345.6789 (Decimal)
'       -12345.6789 (Double) --> -12345.68 (Single)
'
'       12345.6789 (Double) --> 12346 (0x000000000000303A) (Int64)
'       12345.6789 (Double) --> 12346 (0x000000000000303A) (UInt64)
'       12345.6789 (Double) --> 12345.6789 (Decimal)
'       12345.6789 (Double) --> 12345.68 (Single)
'
'       67890.1234 (Double) --> 67890 (0x0000000000010932) (Int64)
'       67890.1234 (Double) --> 67890 (0x0000000000010932) (UInt64)
'       67890.1234 (Double) --> 67890.1234 (Decimal)
'       67890.1234 (Double) --> 67890.13 (Single)
'
'       1.79769313486232E+308 (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
'       1.79769313486232E+308 (Double) --> 0 (0x0000000000000000) (UInt64)
'       Unable to convert 1.79769313486232E+308 to Decimal.
'       1.79769313486232E+308 (Double) --> Infinity (Single)
'
'       NaN (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
'       NaN (Double) --> 0 (0x0000000000000000) (UInt64)
'       Unable to convert NaN to Decimal.
'       NaN (Double) --> NaN (Single)
'
'       Infinity (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
'       Infinity (Double) --> 0 (0x0000000000000000) (UInt64)
'       Unable to convert Infinity to Decimal.
'       Infinity (Double) --> Infinity (Single)
'
'       -Infinity (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
'       -Infinity (Double) --> 9223372036854775808 (0x8000000000000000) (UInt64)
'       Unable to convert -Infinity to Decimal.
'       -Infinity (Double) --> -Infinity (Single)

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

浮點功能

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

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

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

警告

由於精確度的差異，您預期相等的兩 Double 個值可能會不相等，這會影響比較的結果。如需比較兩個 Double值的詳細資訊，請參閱測試是否相等一節。

您也可以呼叫 IsNaN、 IsInfinity、 IsPositiveInfinity和 IsNegativeInfinity 方法來測試這些特殊值。
數學運算。常見的算術運算，例如加法、減法、乘法和除法，都是由語言編譯程式和通用中繼語言（CIL）指令實作，而不是由 Double 方法實作。如果數學運算中的其中一個操作數是以外的 Double數值類型，則會在執行作業之前轉換為 Double 。作業的結果也是值 Double 。

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

您也可以操作值中的 Double 個別位。方法 BitConverter.DoubleToInt64Bits 會在 Double 64位整數中保留值的位模式。方法 BitConverter.GetBytes(Double) 會在位元組陣列中傳回其位模式。
四捨五入。四捨五入通常用來作為減少浮點表示和精確度問題所造成值差異影響的技術。您可以呼叫 Math.Round 方法來四捨五入Double值。
格式化。您可以呼叫 ToString 方法或使用複合格式功能，將值轉換成Double其字串表示法。如需格式字串如何控制浮點值的字串表示的詳細資訊，請參閱標準數值格式字串和自定義數值格式字串主題。
剖析字串。您可以呼叫 Parse 或 TryParse 方法，將浮點值的字串表示轉換成Double值。如果剖析作業失敗， 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:           {0:R}", result1);
        Console.WriteLine(".1 Added 10 times: {0:R}", result2);
    }
}
// The example displays the following output:
//       .1 * 10:           1
//       .1 Added 10 times: 0.99999999999999989

let value = 0.1
let result1 = value * 10.
let mutable result2 = 0.
for i = 1 to 10 do
    result2 <- result2 + value

printfn $".1 * 10:           {result1:R}"
printfn $".1 Added 10 times: {result2:R}"
// The example displays the following output:
//       .1 * 10:           1
//       .1 Added 10 times: 0.99999999999999989

Module Example14
    Public Sub Main()
        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：

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