System.Double – struktura

Tento článek obsahuje doplňující poznámky k referenční dokumentaci pro toto rozhraní API.

Typ Double hodnoty představuje 64bitové číslo s dvojitou přesností s hodnotami v rozsahu od záporných 1,79769313486232e308 na kladné 1,79769313486232e308, stejně jako kladné nebo záporné nuly, PositiveInfinity, a NegativeInfinityne číslo (NaN). Má představovat hodnoty, které jsou extrémně velké (například vzdálenosti mezi planetami nebo galaxiemi) nebo extrémně malé (například molekulární hmotnost látky v kg) a které jsou často nepřesné (například vzdálenost od země k jinému slunečnímu systému). Typ Double odpovídá standardu IEC 60559:1989 (IEEE 754) pro binární aritmetické aritmetické hodnoty s plovoucí desetinou čárkou.

Znázornění s pohyblivou desetinnou čárkou a přesnost

Datový Double typ ukládá hodnoty s plovoucí desetinnou čárkou s dvojitou přesností v 64bitovém binárním formátu, jak je znázorněno v následující tabulce:

Část	Bity
Significand or mantissa	0-51
Mocnina	52-62
Znaménko (0 = kladné, 1 = záporné)	63

Stejně jako desetinné zlomky nemohou přesně reprezentovat některé desetinné hodnoty (například 1/3 nebo Math.PI), binární zlomky nemohou představovat některé desetinné hodnoty. Například 1/10, který je reprezentován přesně 0,1 jako desetinná desetinná desetinná čárka, je reprezentován .001100110011 jako binární zlomek se vzorem "0011" opakuje na nekonečno. V tomto případě poskytuje hodnota s plovoucí desetinou čárkou nepřesnou reprezentaci čísla, které představuje. Provádění dalších matematických operací s původní hodnotou s plovoucí desetinnou čárkou často zvyšuje nedostatek přesnosti. Pokud například porovnáme výsledek násobení 0,1 o 10 a přičtením 0,1 do 0,1 devětkrát, vidíme, že sčítání, protože zahrnovalo osm dalších operací, vytvořilo méně přesný výsledek. Všimněte si, že tento rozdíl je zjevný pouze v případě, že tyto dvě Double hodnoty zobrazíme pomocí standardního řetězce číselného formátu "R", který v případě potřeby zobrazí všech 17 číslic s přesností podporovanou Double typem.

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

Protože některá čísla nemohou být reprezentována přesně jako desetinné binární hodnoty, mohou čísla s plovoucí desetinnou čárkou pouze přibližná reálná čísla.

Všechna čísla s plovoucí desetinou čárkou mají také omezený počet významných číslic, což také určuje, jak přesně se hodnota s plovoucí desetinou čárkou blíží skutečnému číslu. Hodnota Double má až 15 desetinných míst přesnosti, i když se interně udržuje maximálně 17 číslic. To znamená, že některé operace s plovoucí desetinnou čárkou nemusí mít přesnost, aby se změnila hodnota s plovoucí desetinnou čárkou. V následujícím příkladu je uvedena ukázka. Definuje velmi velkou hodnotu s plovoucí desetinou čárkou a pak k ní přidá součin Double.Epsilon a jednu čtyřúhelník. Produkt je však příliš malý na úpravu původní hodnoty s plovoucí desetinou čárkou. Nejméně významná číslice je tisíce, zatímco nejvýznamnější číslice v produktu je 10^–309.

using System;

public class Example14
{
    public static void Main()
    {
        Double value = 123456789012.34567;
        Double additional = Double.Epsilon * 1e15;
        Console.WriteLine("{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

Omezená přesnost čísla s plovoucí desetinnou čárkou má několik důsledků:

• Dvě čísla s plovoucí desetinnou čárkou, která se zobrazují stejně pro určitou přesnost, nemusí porovnat stejnou hodnotu, protože jejich nejméně významné číslice se liší. V následujícím příkladu se sečtou řady čísel a jejich celkový součet se porovná s očekávaným součtem. I když se tyto dvě hodnoty jeví jako stejné, volání Equals metody indikuje, že nejsou.

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

  Pokud změníte položky formátu v Console.WriteLine(String, Object, Object) příkazu z {0} a {1} na {0:R} a {1:R} pro zobrazení všech významných číslic dvou Double hodnot, je jasné, že tyto dvě hodnoty jsou nerovné kvůli ztrátě přesnosti během operací sčítání. V tomto případě lze problém vyřešit voláním Math.Round(Double, Int32) metody, která před porovnáním zaokrouhlí Double hodnoty na požadovanou přesnost.

• Matematická nebo porovnávací operace, která používá číslo s plovoucí desetinnou čárkou, nemusí přinést stejný výsledek, pokud se použije desetinné číslo, protože binární číslo s plovoucí desetinnou čárkou se nemusí shodovat s desetinným číslem. Předchozí příklad znázorňuje výsledek vynásobení 0,1 o 10 a přičtení násobení násobkem 1 krát.

  Pokud je přesnost v numerických operacích s desetinnými hodnotami důležitá, můžete místo typu Double použítDecimal. Pokud je přesnost v numerických operacích s celočíselnými hodnotami nad rámec rozsahu Int64 typů UInt64 důležitá, použijte typ BigInteger .

• Hodnota nemusí být zaokrouhlována, pokud je zahrnuté číslo s plovoucí desetinou čárkou. Hodnota se říká, že zaokrouhlit, pokud operace převede původní číslo s plovoucí desetinou čárkou na jiný formulář, inverzní operace transformuje převedený formulář zpět na číslo s plovoucí desetinou čárkou a konečné číslo s plovoucí desetinou čárkou se nerovná původnímu číslu s plovoucí desetinou čárkou. Odezva může selhat, protože při převodu dojde ke ztrátě nebo změně nejméně významných číslic. V následujícím příkladu jsou tři Double hodnoty převedeny na řetězce a uloženy v souboru. Jak ale ukazuje výstup, i když se zdá, že hodnoty jsou identické, obnovené hodnoty se nerovnají původním hodnotám.

  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
  

  V tomto případě lze hodnoty úspěšně zaokrouhlit pomocí standardního řetězce číselného Double formátu "G17", aby se zachovala úplná přesnost hodnot, jak ukazuje následující příklad.

  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
  

  Důležité

  Při použití s Double hodnotou se specifikátor formátu "R" v některých případech nepodaří úspěšně zaokrouhlit původní hodnotu. K zajištění Double úspěšné odezvy hodnot použijte specifikátor formátu "G17".

• Single hodnoty mají menší přesnost než Double hodnoty. Hodnota Single , která je převedena na zdánlivě ekvivalentní Double často nerovná Double hodnotu kvůli rozdílům v přesnosti. V následujícím příkladu je výsledek identických operací dělení přiřazen k Double a hodnotě Single . Single Po přetypování hodnoty na hodnotu Double, porovnání dvou hodnot ukazuje, že jsou nerovné.

  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
  

  Chcete-li se tomuto problému vyhnout, použijte buď Double místo datového Single typu, nebo použijte metodu Round , aby obě hodnoty měly stejnou přesnost.

Kromě toho se výsledek aritmetických operací a operací přiřazení s Double hodnotami může mírně lišit podle platformy kvůli ztrátě přesnosti Double typu. Například výsledek přiřazení hodnoty literálu Double se může lišit v 32bitové a 64bitové verzi rozhraní .NET. Následující příklad ukazuje tento rozdíl, když literálová hodnota -4,42330604244772E-305 a proměnná, jejíž hodnota je -4,42330604244772E-305 jsou přiřazeny proměnné Double . Všimněte si, že výsledek Parse(String) metody v tomto případě netrpí ztrátou přesnosti.

double value = -4.42330604244772E-305;

double fromLiteral = -4.42330604244772E-305;
double fromVariable = value;
double fromParse = Double.Parse("-4.42330604244772E-305");

Console.WriteLine("Double value from literal: {0,29:R}", fromLiteral);
Console.WriteLine("Double value from variable: {0,28:R}", fromVariable);
Console.WriteLine("Double value from Parse method: {0,24:R}", fromParse);
// 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

Testování rovnosti

Aby byly považovány za stejné, musí dvě Double hodnoty představovat identické hodnoty. Vzhledem k rozdílům v přesnosti mezi hodnotami nebo kvůli ztrátě přesnosti o jednu nebo obě hodnoty se však hodnoty s plovoucí desetinnou čárkou, u které se očekává, že budou identické, budou často nerovné kvůli rozdílům v nejméně významných číslicích. Výsledkem je, že volání Equals metody k určení, zda jsou dvě hodnoty stejné, nebo volání CompareTo metody určit vztah mezi dvěma Double hodnotami, často přinést neočekávané výsledky. To je zřejmé v následujícím příkladu, kdy se dvě zdánlivě stejné Double hodnoty ukázaly jako nerovné, protože první má 15 číslic přesnosti, zatímco druhý má 17.

using System;

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

Počítané hodnoty, které se řídí různými cestami kódu a které jsou manipulovány různými způsoby, se často ukazují jako nerovné. V následujícím příkladu je jedna Double hodnota kvadradrace a poté se vypočítá druhá odmocnina pro obnovení původní hodnoty. Sekunda Double se vynásobí hodnotou 3,51 a druhou druhou odmocninou výsledku se vydělí hodnotou 3,51, aby se obnovila původní hodnota. I když se tyto dvě hodnoty jeví jako identické, volání Equals(Double) metody indikuje, že se nerovnají. Pomocí standardního formátového řetězce "R" vrátíte výsledný řetězec, který zobrazí všechny významné číslice každé dvojité hodnoty, že druhá hodnota je .0000000000001 menší než první.

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

V případech, kdy ztráta přesnosti pravděpodobně ovlivní výsledek porovnání, můžete přijmout některou z následujících alternativ volání Equals nebo CompareTo metody:

• Zavolejte metodu Math.Round , aby se zajistilo, že obě hodnoty mají stejnou přesnost. Následující příklad upraví předchozí příklad tak, aby tento přístup používal tak, aby dvě desetinné hodnoty byly ekvivalentní.

  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
  

  Problém přesnosti se stále týká zaokrouhlování středních hodnot. Další informace najdete v Math.Round(Double, Int32, MidpointRounding) metodě.

• Otestujte přibližnou rovnost místo rovnosti. To vyžaduje, abyste definovali buď absolutní hodnotu, o kterou se tyto dvě hodnoty mohou lišit, ale stále se rovnají, nebo definujete relativní množství, o které se menší hodnota může od větší hodnoty lišit.

  Upozorňující

  Double.Epsilon při testování rovnosti se někdy používá jako absolutní míra vzdálenosti mezi dvěma Double hodnotami. Double.Epsilon Měří však nejmenší možnou hodnotu, ke které lze přidat nebo odečíst, jejíž Double hodnota je nula. U většiny kladných a záporných DoubleDouble.Epsilon hodnot je hodnota příliš malá, aby se zjistila. Proto s výjimkou hodnot, které jsou nula, nedoporučujeme jeho použití v testech rovnosti.

  Následující příklad používá druhý přístup k definování IsApproximatelyEqual metody, která testuje relativní rozdíl mezi dvěma hodnotami. Také kontrastuje výsledek volání metody IsApproximatelyEqual a Equals(Double) metody.

  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
  

Hodnoty s plovoucí desetinnou čárkou a výjimky

Na rozdíl od operací s integrálními typy, které v případě přetečení nebo nelegálních operací, jako je dělení nulou, operace s hodnotami s plovoucí desetinou čárkou nevyvolávají výjimky. Ve výjimečných situacích je výsledkem operace s plovoucí desetinnou čárkou nula, kladné nekonečno, záporné nekonečno nebo ne číslo (NaN):

• Pokud je výsledek operace s plovoucí desetinou čárkou příliš malý pro cílový formát, je výsledek nula. K tomu může dojít, když se vynásobí dvě velmi malá čísla, jak ukazuje následující příklad.

  using System;
  
  public class Example6
  {
      public static void Main()
      {
          Double value1 = 1.1632875981534209e-225;
          Double value2 = 9.1642346778e-175;
          Double result = value1 * value2;
          Console.WriteLine("{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
  

• Pokud velikost výsledku operace s plovoucí desetinou čárkou překročí rozsah cílového formátu, výsledek operace je PositiveInfinity nebo NegativeInfinity, podle znaménka výsledku. Výsledek operace, která přeteče Double.MaxValue , je PositiveInfinitya výsledek operace, která přeteče Double.MinValue je NegativeInfinity, jak ukazuje následující příklad.

  using System;
  
  public class Example7
  {
      public static void Main()
      {
          Double value1 = 4.565e153;
          Double value2 = 6.9375e172;
          Double result = value1 * value2;
          Console.WriteLine("PositiveInfinity: {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 výsledkem je také dělení nulou s kladným dividendem a NegativeInfinity výsledkem dělení nulou se zápornou dividendou.

• Pokud je operace s plovoucí deseti čárkou neplatná, výsledkem operace je NaN. Například NaN výsledky z následujících operací:

  • Dělení nulou s dělenou nulou. Všimněte si, že jiné případy dělení nulou mají za následek buď PositiveInfinity nebo NegativeInfinity.

  • Jakákoli operace s plovoucí desetinou čárkou s neplatným vstupem. Například volání Math.Sqrt metody se zápornou hodnotou vrátí NaN, stejně jako volání Math.Acos metody s hodnotou, která je větší než jedna nebo menší než záporná.

  • Jakákoli operace s argumentem, jehož hodnota je Double.NaN.

Převody typů

Struktura Double nedefinuje žádné explicitní ani implicitní operátory převodu. Místo toho kompilátor implementuje převody.

Převod hodnoty jakéhokoli primitivního číselného typu na určitou Double hodnotu je rozšiřující převod, a proto nevyžaduje explicitní operátor přetypování nebo volání metody převodu, pokud jej kompilátor explicitně nevyžaduje. Například kompilátor jazyka C# vyžaduje operátor přetypování pro převody z Decimal do Double, zatímco kompilátor jazyka Visual Basic ne. Následující příklad převede minimální nebo maximální hodnotu jiných primitivních číselných typů na Double.

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)

Kromě toho hodnoty SingleSingle.NaN, Single.PositiveInfinitya Single.NegativeInfinity převést na Double.NaN, Double.PositiveInfinitya Double.NegativeInfinity, v uvedeném pořadí.

Všimněte si, že převod hodnoty některých číselných typů na Double hodnotu může zahrnovat ztrátu přesnosti. Jak ukazuje příklad, ztráta přesnosti je možná při převodu DecimalInt64, a UInt64 hodnoty na Double hodnoty.

Převod hodnoty na hodnotu jakéhokoli jiného primitivního číselného datového Double typu je zužující převod a vyžaduje operátor přetypování (v jazyce C#), metodu převodu (v jazyce Visual Basic) nebo volání Convert metody. Hodnoty mimo rozsah cílového datového typu definovaného cílovým typem MinValue a MaxValue vlastnostmi se chovají, jak je znázorněno v následující tabulce.

Typ cíle	Výsledek
Libovolný celočíselný typ	Výjimka OverflowException , pokud dojde k převodu v kontrolovaném kontextu. Pokud k převodu dojde v nezaškrtnutém kontextu (výchozí hodnota v jazyce C#), operace převodu bude úspěšná, ale hodnota se přeteče.
Decimal	Výjimka OverflowException .
Single	Single.NegativeInfinity pro záporné hodnoty. Single.PositiveInfinity pro kladné hodnoty.

Kromě toho , Double.NaNDouble.PositiveInfinitya vyvolat Double.NegativeInfinityOverflowException pro převody na celá čísla v zaškrtnutém kontextu, ale tyto hodnoty přetékají při převodu na celá čísla v nezaškrtnutém kontextu. Pro převody na Decimal, vždy vyvolat OverflowException. Pro převody na Single, převedou na Single.NaN, Single.PositiveInfinitya Single.NegativeInfinity, v uvedeném pořadí.

Ztráta přesnosti může mít za následek převod hodnoty Double na jiný číselný typ. V případě převodu na některý z integrálních typů, jak ukazuje výstup z příkladu, zlomková komponenta se ztratí, když Double je hodnota zaokrouhlená (jako v jazyce Visual Basic) nebo zkrácena (jako v jazyce C#). Pro převody na Decimal a Single hodnoty Double nemusí mít hodnota přesné vyjádření v cílovém datovém typu.

Následující příklad převede počet Double hodnot na několik dalších číselných typů. Převody probíhají v kontrolovaném kontextu v jazyce Visual Basic (výchozí), v jazyce C# (kvůli kontrolovanému klíčovému slovu) a v jazyce F# (z důvodu kontrolovaného modulu). Výstup z příkladu ukazuje výsledek pro převody v nezaškrtnutém kontextu. Převody můžete provádět v nezaškrtnutém kontextu v jazyce Visual Basic kompilováním přepínače kompilátoru /removeintchecks+ , v jazyce C# zakomentováním checked příkazu a v jazyce F# zakomentováním open Checked příkazu.

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)

Další informace o převodu číselných typů naleznete v tématu Převod typů v .NET a Převod typů tabulky.

Funkce s plovoucí desetinnou čárkou

Struktura Double a související typy poskytují metody pro provádění operací v následujících oblastech:

• Porovnání hodnot Můžete volat metodu Equals , abyste zjistili, zda jsou dvě Double hodnoty stejné, nebo CompareTo metoda určující vztah mezi dvěma hodnotami.

  Struktura Double také podporuje úplnou sadu relačních operátorů. Můžete například otestovat rovnost nebo nerovnost nebo určit, jestli je jedna hodnota větší nebo rovna jiné. Pokud je jeden z operandů číselný typ jiný než a Double, je převeden na před Double provedením porovnání.

  Upozorňující

  Vzhledem k rozdílům v přesnosti můžou být dvě Double hodnoty, u kterých očekáváte, že budou stejné, budou nerovné, což má vliv na výsledek porovnání. Další informace o porovnávání dvou Double hodnot najdete v části Testování rovnosti.

  Můžete také volat IsNaN, IsInfinity, IsPositiveInfinitya IsNegativeInfinity metody testovat pro tyto speciální hodnoty.

• Matematické operace. Běžné aritmetické operace, jako jsou sčítání, odčítání, násobení a dělení, jsou implementovány kompilátory jazyka a instrukcemi CIL (Common Intermediate Language), nikoli metodami Double . Je-li jeden z operandů v matematické operaci číselný typ jiný než , Doubleje převeden na před Double provedením operace. Výsledkem operace je také Double hodnota.

  Jiné matematické operace lze provádět voláním static metod (Shared v jazyce Visual Basic) ve System.Math třídě. Zahrnuje další metody běžně používané pro aritmetické (například , a ), geometrii (například Math.Cos aMath.Sin) a kalkulu (například Math.Log).Math.SqrtMath.SignMath.Abs

  Můžete také manipulovat s jednotlivými bity v hodnotě Double . Metoda BitConverter.DoubleToInt64Bits zachovává Double bitový vzor hodnoty v 64bitovém celočíselném čísle. Metoda BitConverter.GetBytes(Double) vrátí svůj bitový vzor v bajtovém poli.

• Zaokrouhlování. Zaokrouhlování se často používá jako technika pro snížení dopadu rozdílů mezi hodnotami způsobenými problémy reprezentace s plovoucí desetinnou čárkou a přesností. Hodnotu můžete zaokrouhlit Double voláním Math.Round metody.

• Formátování. Hodnotu můžete převést na řetězcovou Double reprezentaci voláním ToString metody nebo pomocí funkce složeného formátování. Informace o tom, jak formátovací řetězce řídí řetězcové znázornění hodnot s plovoucí desetinnou čárkou, naleznete v tématech Standardní řetězce číselného formátu a Vlastní řetězce číselného formátu.

• Analýza řetězců Řetězcové vyjádření hodnoty Double s plovoucí desetinnou čárkou můžete převést na hodnotu voláním Parse metody nebo TryParse metody. Pokud operace analýzy selže, Parse vyvolá metoda výjimku, zatímco TryParse metoda vrátí false.

• Převod typu. Struktura Double poskytuje explicitní implementaci rozhraní pro IConvertible rozhraní, která podporuje převod mezi všemi dvěma standardními datovými typy .NET. Kompilátory jazyka také podporují implicitní převod hodnot všech ostatních standardních číselných typů na Double hodnoty. Převod hodnoty libovolného standardního číselného typu na typ Double je rozšiřující převod a nevyžaduje uživatele operátoru přetypování nebo metody převodu,

  Převod Int64 hodnot ale Single může zahrnovat ztrátu přesnosti. Následující tabulka uvádí rozdíly v přesnosti pro každý z těchto typů:

  Typ	Maximální přesnost	Vnitřní přesnost
  Double	15	17
  Int64	19 desítkových číslic	19 desítkových číslic
  Single	7 desítkových číslic	9 desítkových číslic

  Problém přesnosti nejčastěji ovlivňuje Single hodnoty, které jsou převedeny na Double hodnoty. V následujícím příkladu jsou dvě hodnoty vytvořené identickými operacemi dělení nerovné, protože jedna z hodnot je hodnota s plovoucí desetinnou čárkou s jednoduchou přesností převedená na Doublehodnotu .

  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
  

Příklady

Následující příklad kódu ilustruje použití Double:

// The Temperature class stores the temperature as a Double
// and delegates most of the functionality to the Double
// implementation.
public class Temperature : IComparable, IFormattable
{
    // IComparable.CompareTo implementation.
    public int CompareTo(object obj) {
        if (obj == null) return 1;

        Temperature temp = obj as Temperature;
        if (obj != null)
            return m_value.CompareTo(temp.m_value);
        else
            throw new ArgumentException("object is not a Temperature");	
    }

    // IFormattable.ToString implementation.
    public string ToString(string format, IFormatProvider provider) {
        if( format != null ) {
            if( format.Equals("F") ) {
                return String.Format("{0}'F", this.Value.ToString());
            }
            if( format.Equals("C") ) {
                return String.Format("{0}'C", this.Celsius.ToString());
            }
        }

        return m_value.ToString(format, provider);
    }

    // Parses the temperature from a string in the form
    // [ws][sign]digits['F|'C][ws]
    public static Temperature Parse(string s, NumberStyles styles, IFormatProvider provider) {
        Temperature temp = new Temperature();

        if( s.TrimEnd(null).EndsWith("'F") ) {
            temp.Value = Double.Parse( s.Remove(s.LastIndexOf('\''), 2), styles, provider);
        }
        else if( s.TrimEnd(null).EndsWith("'C") ) {
            temp.Celsius = Double.Parse( s.Remove(s.LastIndexOf('\''), 2), styles, provider);
        }
        else {
            temp.Value = Double.Parse(s, styles, provider);
        }

        return temp;
    }

    // The value holder
    protected double m_value;

    public double Value {
        get {
            return m_value;
        }
        set {
            m_value = value;
        }
    }

    public double Celsius {
        get {
            return (m_value-32.0)/1.8;
        }
        set {
            m_value = 1.8*value+32.0;
        }
    }
}

// The Temperature class stores the temperature as a Double
// and delegates most of the functionality to the Double
// implementation.
type Temperature() =
    member val Value = 0. with get, set

    member this.Celsius
        with get () = (this.Value - 32.) / 1.8
        and set (value) =
            this.Value <- 1.8 * value + 32.

    // Parses the temperature from a string in the form
    // [ws][sign]digits['F|'C][ws]
    static member Parse(s: string, styles: NumberStyles, provider: IFormatProvider) =
        let temp = Temperature()

        if s.TrimEnd(null).EndsWith "'F" then
            temp.Value <- Double.Parse(s.Remove(s.LastIndexOf '\'', 2), styles, provider)
        elif s.TrimEnd(null).EndsWith "'C" then
            temp.Celsius <- Double.Parse(s.Remove(s.LastIndexOf '\'', 2), styles, provider)
        else
            temp.Value <- Double.Parse(s, styles, provider)
        temp

    interface IComparable with
        // IComparable.CompareTo implementation.
        member this.CompareTo(obj: obj) =
            match obj with 
            | null -> 1
            | :? Temperature as temp ->
                this.Value.CompareTo temp.Value
            | _ ->
                invalidArg "obj" "object is not a Temperature"

    interface IFormattable with
        // IFormattable.ToString implementation.
        member this.ToString(format: string, provider: IFormatProvider) =
            match format with
            | "F" ->
                $"{this.Value}'F"
            | "C" ->
                $"{this.Celsius}'C"
            | _ ->
                this.Value.ToString(format, provider)

' Temperature class stores the value as Double
' and delegates most of the functionality 
' to the Double implementation.
Public Class Temperature
    Implements IComparable, IFormattable

    Public Overloads Function CompareTo(ByVal obj As Object) As Integer _
        Implements IComparable.CompareTo

        If TypeOf obj Is Temperature Then
            Dim temp As Temperature = CType(obj, Temperature)

            Return m_value.CompareTo(temp.m_value)
        End If

        Throw New ArgumentException("object is not a Temperature")
    End Function

    Public Overloads Function ToString(ByVal format As String, ByVal provider As IFormatProvider) As String _
        Implements IFormattable.ToString

        If Not (format Is Nothing) Then
            If format.Equals("F") Then
                Return [String].Format("{0}'F", Me.Value.ToString())
            End If
            If format.Equals("C") Then
                Return [String].Format("{0}'C", Me.Celsius.ToString())
            End If
        End If

        Return m_value.ToString(format, provider)
    End Function

    ' Parses the temperature from a string in form
    ' [ws][sign]digits['F|'C][ws]
    Public Shared Function Parse(ByVal s As String, ByVal styles As NumberStyles, ByVal provider As IFormatProvider) As Temperature
        Dim temp As New Temperature()

        If s.TrimEnd().EndsWith("'F") Then
            temp.Value = Double.Parse(s.Remove(s.LastIndexOf("'"c), 2), styles, provider)
        Else
            If s.TrimEnd().EndsWith("'C") Then
                temp.Celsius = Double.Parse(s.Remove(s.LastIndexOf("'"c), 2), styles, provider)
            Else
                temp.Value = Double.Parse(s, styles, provider)
            End If
        End If
        Return temp
    End Function

    ' The value holder
    Protected m_value As Double

    Public Property Value() As Double
        Get
            Return m_value
        End Get
        Set(ByVal Value As Double)
            m_value = Value
        End Set
    End Property

    Public Property Celsius() As Double
        Get
            Return (m_value - 32) / 1.8
        End Get
        Set(ByVal Value As Double)
            m_value = Value * 1.8 + 32
        End Set
    End Property
End Class