System.Double, struktura

Ten artykuł zawiera dodatkowe uwagi dotyczące dokumentacji referencyjnej dla tego interfejsu API.

Typ wartości Double reprezentuje liczbę 64-bitową o podwójnej precyzji z wartościami od ujemnych 1,79769313486232e308 do dodatnich 1,79769313486232e308, a także dodatniego lub ujemnego zera, PositiveInfinity, NegativeInfinity, oraz wartość niebędącą liczbą (NaN). Ma ona reprezentować wartości, które są bardzo duże (takie jak odległości między planetami lub galaktykami) lub bardzo małe (takie jak masa molekularna substancji w kilogramach) i które często są nieprecyzyjne (takie jak odległość od ziemi do innego układu słonecznego). Typ Double jest zgodny z normą IEC 60559:1989 (IEEE 754) dla arytmetyki binarnej zmiennoprzecinkowych.

Reprezentacja zmiennoprzecinkowa i precyzja

Typ danych Double przechowuje wartości zmiennoprzecinkowe o podwójnej precyzji w formacie binarnym 64-bitowym, jak pokazano w poniższej tabeli:

Część	Bity
Część znacząca lub mantysa	0-51
Wykładnik	52-62
Znak (0 = dodatni, 1 = ujemny)	63

Tak samo jak ułamki dziesiętne nie mogą dokładnie reprezentować niektórych wartości ułamkowych (takich jak 1/3 lub Math.PI), ułamki binarne nie mogą reprezentować niektórych wartości ułamkowych. Na przykład 1/10, który jest reprezentowany dokładnie przez .1 jako ułamek dziesiętny, jest reprezentowany przez .001100110011 jako ułamek binarny, ze wzorcem "0011" powtarzającym się do nieskończoności. W tym przypadku wartość zmiennoprzecinkowa zapewnia niedokładną reprezentację liczby, którą reprezentuje. Wykonywanie dodatkowych operacji matematycznych na oryginalnej wartości zmiennoprzecinkowej często zwiększa jej brak precyzji. Jeśli na przykład porównamy wynik mnożenia wartości .1 przez 10 z wynikiem dodania wartości .1 do .1 dziewięć razy, zobaczymy, że dodawanie, ponieważ obejmowało osiem dodatkowych operacji, spowodowało mniej precyzyjny wynik. Należy pamiętać, że ta różnica jest widoczna tylko wtedy, gdy wyświetlamy dwie Double wartości przy użyciu ciągu "R" standardowego ciągu formatu liczbowego, co w razie potrzeby wyświetla wszystkie 17 cyfr dokładności obsługiwanej przez typ 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 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

Ponieważ niektóre liczby nie mogą być dokładnie reprezentowane jako wartości binarne ułamkowe, liczby zmiennoprzecinkowe mogą jedynie przybliżać liczby rzeczywiste.

Wszystkie liczby zmiennoprzecinkowe mają również ograniczoną liczbę cyfr znaczących, co określa również, jak dokładnie wartość zmiennoprzecinkowa przybliża liczbę rzeczywistą. Wartość Double ma maksymalnie 15 cyfr dziesiętnych dokładności, chociaż maksymalnie 17 cyfr jest utrzymywanych wewnętrznie. Oznacza to, że niektóre operacje zmiennoprzecinkowe mogą nie mieć precyzji zmiany wartości zmiennoprzecinkowej. Poniższy przykład stanowi ilustrację. Definiuje bardzo dużą wartość zmiennoprzecinkową, a następnie dodaje do niej iloczyn Double.Epsilon i jednego biliarda. Jednak produkt jest zbyt mały, aby zmodyfikować oryginalną wartość zmiennoprzecinkową. Jego najmniej znacząca cyfra to liczba tysięcy, natomiast najważniejszą cyfrą w produkcie jest 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 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

Ograniczona precyzja liczby zmiennoprzecinkowej ma kilka konsekwencji:

• Dwie liczby zmiennoprzecinkowe, które wydają się równe dla określonej precyzji, mogą nie porównywać się jako równe, ponieważ ich najmniej znaczące cyfry są różne. W poniższym przykładzie seria liczb jest sumowana, a ich suma jest porównywana z oczekiwaną sumą. Chociaż dwie wartości wydają się być takie same, wywołanie metody Equals wskazuje, że nie są.

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

  Jeśli zmienisz elementy formatu w instrukcji Console.WriteLine(String, Object, Object) z {0} i {1} na {0:R} i {1:R}, aby wyświetlić wszystkie znaczące cyfry dwóch wartości Double, jasne jest, że dwie wartości są nierówne ze względu na utratę dokładności podczas operacji dodawania. W takim przypadku problem można rozwiązać, wywołując metodę Math.Round(Double, Int32), aby zaokrąglić wartości Double do żądanej dokładności przed wykonaniem porównania.

• Operacja matematyczna lub porównawcza używająca liczby zmiennoprzecinkowej może nie zwracać tego samego wyniku, jeśli jest używana liczba dziesiętna, ponieważ liczba zmiennoprzecinkowa binarna może nie być równa liczbie dziesiętnej. W poprzednim przykładzie pokazano to, wyświetlając wynik mnożenia wartości .1 przez 10 i dodając wartość 1 razy.

  Gdy dokładność operacji liczbowych z wartościami ułamkowymi jest ważna, można użyć Decimal, a nie typu Double. Gdy dokładność operacji liczbowych z wartościami całkowitymi poza zakresem typów Int128UInt128 jest ważna, należy użyć typu BigInteger.

• Wartość może nie zostać poprawnie zaokrąglona, jeśli zaangażowana jest liczba zmiennoprzecinkowa. Mówi się, że wartość okrąża, jeśli operacja konwertuje oryginalną liczbę zmiennoprzecinkową na inną postać, operacja odwrotna przekształca tę postać z powrotem na liczbę zmiennoprzecinkową, a końcowa liczba zmiennoprzecinkowa jest równa się oryginalnej liczbie zmiennoprzecinkowej. Podróż w obie strony może zakończyć się niepowodzeniem, ponieważ jedna lub więcej najmniej znaczących cyfr zostanie utracona lub zmieniona w konwersji.

  W poniższym przykładzie trzy Double wartości są konwertowane na ciągi i zapisywane w pliku. Jeśli uruchomisz ten przykład na platformie .NET Framework, mimo że wartości są identyczne, przywrócone wartości nie są równe oryginalnym wartościom. (Od tego czasu zostało to rozwiązane w .NET, gdzie wartości przechodzą pełne okrążenie poprawnie).

  StreamWriter sw = new(@"./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(@"./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($"{values[ctr]} {(values[ctr].Equals(restoredValues[ctr]) ? "=" : "<>")} {restoredValues[ctr]}");
  
  // For .NET Framework only, 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
  

  Jeśli używasz platformy .NET Framework, wartości można pomyślnie zaokrąglić przy użyciu standardowego ciągu formatu liczbowego "G17", aby zachować pełną precyzję Double wartości.

• Single wartości mają mniejszą precyzję niż Double wartości. Wartość Single, która jest konwertowana na pozornie równoważną Double często nie jest równa wartości Double ze względu na różnice w precyzji. W poniższym przykładzie wynik identycznych operacji dzielenia jest przypisywany do Double i wartości Single. Po rzutaniu wartości Single na Doubleporównanie dwóch wartości pokazuje, że są one nierówne.

  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($"{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 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
  

  Aby uniknąć tego problemu, użyj Double zamiast typu danych Single lub użyj metody Round, aby obie wartości miały taką samą precyzję.

Ponadto wynik operacji arytmetycznych i przypisania z wartościami Double może się nieznacznie różnić w zależności od platformy ze względu na utratę dokładności typu Double. Na przykład wynik przypisania wartości literału Double może się różnić w 32-bitowych i 64-bitowych wersjach platformy .NET. Poniższy przykład ilustruje tę różnicę, gdy wartość dosłowna -4.42330604244772E-305, oraz zmienna o wartości -4.42330604244772E-305, są przypisywane do zmiennej Double. Należy pamiętać, że wynik metody Parse(String) w tym przypadku nie cierpi na utratę precyzji.

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

Testowanie pod kątem równości

Aby być traktowane jako równe, dwie Double wartości muszą reprezentować identyczne wartości. Jednak ze względu na różnice w dokładności między wartościami lub z powodu utraty dokładności przez jedną lub obie wartości wartości zmiennoprzecinkowe, które powinny być identyczne, często okazuje się nierówne ze względu na różnice w ich najmniej znaczących cyfrach. W związku z tym wywołania metody Equals w celu określenia, czy dwie wartości są równe, czy wywołania metody CompareTo w celu określenia relacji między dwiema wartościami Double, często dają nieoczekiwane wyniki. Jest to widoczne w poniższym przykładzie, gdzie dwie pozornie równe wartości Double okazują się nierówne, ponieważ pierwsza ma 15 cyfr dziesiętnych, podczas gdy druga ma 17.

using System;

public class Example
{
   public static void Main()
   {
      double value1 = .333333333333333;
      double value2 = 1.0/3;
      Console.WriteLine($"{value1:R} = {value2:R}: {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

Obliczone wartości, które są zgodne z różnymi ścieżkami kodu i które są manipulowane na różne sposoby, często okazują się nierówne. W poniższym przykładzie jedna wartość Double jest podnoszona do kwadratu, a następnie oblicza się pierwiastek kwadratowy, aby przywrócić oryginalną wartość. Druga Double jest pomnożona przez 3,51 i podniesiona do kwadratu, zanim pierwiastek kwadratowy z wyniku zostanie podzielony przez 3,51, aby przywrócić oryginalną wartość. Chociaż dwie wartości wydają się być identyczne, wywołanie metody Equals(Double) wskazuje, że nie są równe. Użycie standardowego ciągu formatu "R" w celu zwrócenia ciągu wynikowego, który wyświetla wszystkie cyfry znaczące każdej wartości typu Double, pokazuje, że druga wartość jest o 0.0000000000001 mniejsza od pierwszej.

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($"{value1} = {value2}: {value1.Equals(value2)}{Environment.NewLine}");
        Console.WriteLine($"{value1:R} = {value2:R}");
    }
}
// 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

W przypadkach, gdy utrata dokładności może mieć wpływ na wynik porównania, można przyjąć dowolną z następujących alternatyw wywołania metody Equals lub CompareTo:

• Wywołaj metodę Math.Round, aby upewnić się, że obie wartości mają taką samą precyzję. Poniższy przykład modyfikuje poprzedni przykład, aby użyć tego podejścia, tak aby dwie wartości ułamkowe były równoważne.

  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($"{value1:R} = {value2:R}: {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
  

  Problem dokładności nadal dotyczy zaokrąglania wartości punktu środkowego. Aby uzyskać więcej informacji, zobacz metodę Math.Round(Double, Int32, MidpointRounding).

• Przetestuj przybliżoną równość zamiast ścisłej równości. Wymaga to zdefiniowania bezwzględnej kwoty, w której dwie wartości mogą się różnić, ale nadal są równe, lub że definiujesz względną kwotę, za pomocą której mniejsza wartość może odbiegać od większej wartości.

  Ostrzeżenie

  Double.Epsilon jest czasami używana jako bezwzględna miara odległości między dwiema Double wartościami podczas testowania równości. Jednak Double.Epsilon mierzy najmniejszą możliwą wartość, którą można dodać lub odjąć od Double, której wartość jest równa zero. W przypadku większości wartości Double dodatnich i ujemnych wartość Double.Epsilon jest zbyt mała, aby można było wykryć. W związku z tym, z wyjątkiem wartości, które są zerowe, nie zalecamy używania jej w testach pod kątem równości.

  W poniższym przykładzie użyto drugiego podejścia do zdefiniowania metody IsApproximatelyEqual, która testuje względną różnicę między dwiema wartościami. Przeciwstawia także wyniki wywołań metody IsApproximatelyEqual i metody Equals(Double).

  using System;
  
  public class Example3
  {
      public static void Main()
      {
          double one1 = .1 * 10;
          double one2 = 0;
          for (int ctr = 1; ctr <= 10; ctr++)
              one2 += .1;
  
          Console.WriteLine($"{one1:R} = {one2:R}: {one1.Equals(one2)}");
          Console.WriteLine($"{one1:R} is approximately equal to {one2:R}: {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
  

Wartości i wyjątki zmiennoprzecinkowe

W przeciwieństwie do operacji z typami całkowitymi, które zgłaszają wyjątki w przypadkach przepełnienia lub niedozwolonych operacji, takich jak dzielenie według zera, operacje z wartościami zmiennoprzecinkowymi nie zgłaszają wyjątków. Zamiast tego, w wyjątkowych sytuacjach, wynikiem operacji zmiennoprzecinkowych jest zero, nieskończoność dodatnia, nieskończoność ujemna, a nie liczba (NaN):

• Jeśli wynik operacji zmiennoprzecinkowych jest za mały dla formatu docelowego, wynik wynosi zero. Taka sytuacja może wystąpić, gdy pomnożone są dwie bardzo małe liczby, jak pokazano w poniższym przykładzie.

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

• Jeśli wielkość wyniku operacji zmiennoprzecinkowych przekracza zakres formatu docelowego, wynik operacji jest PositiveInfinity lub NegativeInfinity, odpowiednio dla znaku wyniku. Wynikiem operacji, która przepełnia Double.MaxValue, jest PositiveInfinity, a wynikiem operacji, która przepełnia Double.MinValue, jest NegativeInfinity, jak pokazano w następującym przykładzie.

  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 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 również wynika z podziału o zero z dodatnią dywidendą, a NegativeInfinity wynika z podziału o zero z ujemną dywidendą.

• Jeśli operacja zmiennoprzecinkowa jest nieprawidłowa, wynikiem operacji jest NaN. Na przykład NaN wynika z następujących operacji:

  • Podział o zero z dywidendą zero. Należy pamiętać, że inne przypadki dzielenia według zera powodują PositiveInfinity lub NegativeInfinity.

  • Każda operacja zmiennoprzecinkowa z nieprawidłowym wejściem. Na przykład wywołanie metody Math.Sqrt z wartością ujemną zwraca wartość NaN, podobnie jak wywołanie metody Math.Acos z wartością większą niż jedną lub mniejszą niż ujemna.

  • Każda operacja z argumentem, którego wartość jest Double.NaN.

Konwersje typu

Struktura Double nie definiuje żadnych jawnych ani niejawnych operatorów konwersji; Zamiast tego konwersje są implementowane przez kompilator.

Konwersja wartości dowolnego typu liczbowego pierwotnego na Double jest konwersją rozszerzającą i dlatego nie wymaga jawnego operatora rzutowania ani wywołania metody konwersji, chyba że kompilator jawnie tego wymaga. Na przykład kompilator języka C# wymaga operatora rzutowania konwersji z Decimal do Double, podczas gdy kompilator języka Visual Basic nie. Poniższy przykład konwertuje minimalną lub maksymalną wartość innych pierwotnych typów liczbowych na Double.

dynamic[] values = { Byte.MinValue, Byte.MaxValue, Decimal.MinValue,
                   Decimal.MaxValue, Int16.MinValue, Int16.MaxValue,
                   Int32.MinValue, Int32.MaxValue, Int64.MinValue,
                   Int64.MaxValue, SByte.MinValue, SByte.MaxValue,
                   Single.MinValue, Single.MaxValue, UInt16.MinValue,
                   UInt16.MaxValue, UInt32.MinValue, UInt32.MaxValue,
                   UInt64.MinValue, UInt64.MaxValue };
double dblValue;
foreach (dynamic value in values)
{
    if (value.GetType() == typeof(decimal))
        dblValue = (double)value;
    else
        dblValue = value;
    Console.WriteLine($"{value} ({value.GetType().Name}) --> " +
        $"{dblValue:R} ({dblValue.GetType().Name})");
}

// The example displays the following output:
//    0 (Byte) --> 0 (Double)
//    255 (Byte) --> 255 (Double)
//    -79228162514264337593543950335 (Decimal) --> -7.9228162514264338E+28 (Double)
//    79228162514264337593543950335 (Decimal) --> 7.9228162514264338E+28 (Double)
//    -32768 (Int16) --> -32768 (Double)
//    32767 (Int16) --> 32767 (Double)
//    -2147483648 (Int32) --> -2147483648 (Double)
//    2147483647 (Int32) --> 2147483647 (Double)
//    -9223372036854775808 (Int64) --> -9.2233720368547758E+18 (Double)
//    9223372036854775807 (Int64) --> 9.2233720368547758E+18 (Double)
//    -128 (SByte) --> -128 (Double)
//    127 (SByte) --> 127 (Double)
//    -3.402823E+38 (Single) --> -3.4028234663852886E+38 (Double)
//    3.402823E+38 (Single) --> 3.4028234663852886E+38 (Double)
//    0 (UInt16) --> 0 (Double)
//    65535 (UInt16) --> 65535 (Double)
//    0 (UInt32) --> 0 (Double)
//    4294967295 (UInt32) --> 4294967295 (Double)
//    0 (UInt64) --> 0 (Double)
//    18446744073709551615 (UInt64) --> 1.8446744073709552E+19 (Double)

open System

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

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

Module Example5
    Public Sub 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)

Ponadto wartości SingleSingle.NaN, Single.PositiveInfinityi Single.NegativeInfinity są konwertowane na odpowiednio Double.NaN, Double.PositiveInfinityi Double.NegativeInfinity.

Należy pamiętać, że konwersja wartości niektórych typów liczbowych na wartość Double może obejmować utratę dokładności. Jak pokazano w przykładzie, utrata dokładności jest możliwa podczas konwertowania wartości Decimal, Int64i UInt64 na wartości Double.

Konwersja wartości Double na wartość dowolnego innego typu danych liczbowych pierwotnych jest konwersją zawężającą i wymaga operatora rzutowania (w języku C#), metody konwersji (w Visual Basic) lub wywołania metody Convert. Wartości, które znajdują się poza zakresem docelowego typu danych, które są zdefiniowane przez właściwości MinValue i MaxValue typu docelowego, zachowują się tak, jak pokazano w poniższej tabeli.

Typ docelowy	Wynik
Dowolny typ całkowity	Wyjątek OverflowException, jeśli konwersja występuje w zaznaczonym kontekście. Jeśli konwersja występuje w niekontrolowanym kontekście (domyślnie w języku C#), operacja konwersji powiedzie się, ale wartość ulega przepełnieniu.
Decimal	Wyjątek OverflowException.
Single	Single.NegativeInfinity dla wartości ujemnych. Single.PositiveInfinity dla wartości dodatnich.

Ponadto Double.NaN, Double.PositiveInfinityi Double.NegativeInfinity zgłaszają OverflowException podczas konwersji na liczby całkowite w kontrolowanym kontekście, ale te wartości przepełniają się po przekonwertowaniu na liczby całkowite w niekontrolowanym kontekście. W przypadku konwersji na Decimalzawsze rzucają OverflowException. W przypadku konwersji na Singlekonwertują odpowiednio na Single.NaN, Single.PositiveInfinityi Single.NegativeInfinity.

Utrata dokładności może wynikać z konwertowania wartości Double na inny typ liczbowy. W przypadku konwersji na dowolne typy całkowite, jak pokazano na przykładzie danych wyjściowych, składnik ułamkowy jest tracony, gdy wartość Double jest zaokrąglana (jak w Visual Basic) lub obcinana (jak w przypadku C#). W przypadku konwersji na wartości Decimal i Single wartość Double może nie mieć dokładnej reprezentacji w docelowym typie danych.

W poniższym przykładzie liczba wartości Double jest konwertowana na kilka innych typów liczbowych. Konwersje są wykonywane w sprawdzonym kontekście w Visual Basic (wartość domyślna), w języku C# (ze względu na słowo kluczowe checked) i w języku F# (ze względu na moduł Checked). Dane wyjściowe z przykładu pokazują wynik konwersji w kontekście zarówno sprawdzonym, jak i niesprawdzonym. Konwersje można wykonać w nieznakowanym kontekście: w Visual Basic, kompilując z przełącznikiem kompilatora /removeintchecks+; w C#, komentując instrukcję checked; oraz w F#, komentując instrukcję 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 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)

Aby uzyskać więcej informacji na temat konwersji typów liczbowych, zobacz konwersję typów na platformie .NET i tabele konwersji typów .

Funkcjonalność zmiennoprzecinkowa

Struktura Double i powiązane typy zapewniają metody wykonywania operacji w następujących obszarach:

• Porównanie wartości. Można wywołać metodę Equals, aby określić, czy dwie Double wartości są równe, czy też metoda CompareTo w celu określenia relacji między dwiema wartościami.

  Struktura Double obsługuje również kompletny zestaw operatorów porównania. Można na przykład przetestować równość lub nierówności albo określić, czy jedna wartość jest większa niż lub równa innej. Jeśli jeden z operandów jest typem liczbowym innym niż Double, jest konwertowany na Double przed wykonaniem porównania.

  Ostrzeżenie

  Ze względu na różnice w precyzji, dwie Double wartości, które powinny być równe, mogą okazać się nierówne, co wpływa na wynik porównania. Aby uzyskać więcej informacji na temat porównywania dwóch wartości , zobacz sekcję Double.

  Można również wywołać metody IsNaN, IsInfinity, IsPositiveInfinityi IsNegativeInfinity, aby przetestować te wartości specjalne.

• operacje matematyczne. Typowe operacje arytmetyczne, takie jak dodawanie, odejmowanie, mnożenie i dzielenie, są implementowane przez kompilatory języka i instrukcje języka wspólnego języka pośredniego (CIL), a nie przez metody Double. Jeśli jeden z operandów w operacji matematycznej jest typem liczbowym innym niż Double, jest konwertowany na Double przed wykonaniem operacji. Wynik operacji jest również wartością Double.

  Inne operacje matematyczne mogą być wykonywane przez wywołanie metod static (Shared w języku Visual Basic) w klasie System.Math. Zawiera ona dodatkowe metody powszechnie stosowane do arytmetyki (takich jak Math.Abs, Math.Signi Math.Sqrt), geometria (na przykład Math.Cos i Math.Sin) oraz rachunku (na przykład Math.Log).

  Można również manipulować poszczególnymi bitami w wartości Double. Metoda BitConverter.DoubleToInt64Bits zachowuje wzorzec bitowy wartości Double w 64-bitowej liczbie całkowitej. Metoda BitConverter.GetBytes(Double) zwraca wzorzec bitowy w tablicy bajtów.

• Zaokrąglanie. Zaokrąglanie jest często używane jako technika zmniejszania wpływu różnic między wartościami spowodowanymi problemami z reprezentacją zmiennoprzecinkową i precyzją. Wartość Double można zaokrąglić, wywołując metodę Math.Round.

• formatowanie. Wartość Double można przekonwertować na jego reprezentację ciągu, wywołując metodę ToString lub używając funkcji formatowania złożonego. Aby uzyskać informacje o tym, jak ciągi formatujące kontrolują sposób reprezentacji wartości zmiennoprzecinkowych, zobacz Standard Numeric Format Strings i Custom Numeric Format Strings.

• analizowanie ciągów. Reprezentację ciągu wartości zmiennoprzecinkowej można przekonwertować na wartość Double, wywołując metodę Parse lub TryParse. Jeśli operacja analizy zakończy się niepowodzeniem, metoda Parse zgłasza wyjątek, natomiast metoda TryParse zwraca false.

• Typ konwersji. Struktura Double udostępnia jawną implementację interfejsu dla interfejsu IConvertible, który obsługuje konwersję między dowolnymi dwoma standardowymi typami danych platformy .NET. Kompilatory języka obsługują również niejawną konwersję wartości wszystkich innych standardowych typów liczbowych na wartości Double. Konwersja wartości dowolnego standardowego typu liczbowego na Double jest konwersją rozszerzającą i nie wymaga od użytkownika operatora rzutowania ani metody konwersji,

  Jednak konwersja wartości Int64 i Single może obejmować utratę dokładności. W poniższej tabeli wymieniono różnice w dokładności dla każdego z tych typów:

  Typ	Maksymalna precyzja	Precyzja wewnętrzna
  Double	15	17
  Int64	19 cyfr dziesiętnych	19 cyfr dziesiętnych
  Single	7 cyfr dziesiętnych	9 cyfr dziesiętnych

  Problem dokładności najczęściej dotyczy wartości Single, które są konwertowane na wartości Double. W poniższym przykładzie dwie wartości generowane przez identyczne operacje dzielenia są nierówne, ponieważ jedna z wartości jest wartością zmiennoprzecinkową o pojedynczej precyzji przekonwertowaną na Double.

  using System;
  
  public class Example13
  {
      public static void Main()
      {
          Double value = .1;
          Double result1 = value * 10;
          Double result2 = 0;
          for (int ctr = 1; ctr <= 10; ctr++)
              result2 += value;
  
          Console.WriteLine($".1 * 10:           {result1:R}");
          Console.WriteLine($".1 Added 10 times: {result2:R}");
      }
  }
  // The example displays the following output:
  //       .1 * 10:           1
  //       .1 Added 10 times: 0.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
  

Przykłady

Poniższy przykład kodu ilustruje użycie 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