System.Double yapısı

Bu makale, bu API'nin başvuru belgelerine ek açıklamalar sağlar.

Double değer türü, negatif 1,79769313486232e308 ile pozitif 1,79769313486232e308 arasında değişen değerlerin yanı sıra pozitif veya negatif sıfır, PositiveInfinity, NegativeInfinity ve sayı değil (NaN) ile çift hassasiyetli bir 64 bit sayıyı temsil eder. Son derece büyük (gezegenler veya galaksiler arasındaki mesafeler gibi) veya son derece küçük (kilogram cinsinden bir maddenin moleküler kütlesi gibi) ve genellikle belirsiz olan (örneğin, dünyadan başka bir güneş sistemine olan uzaklık) değerleri temsil etmeye yöneliktir. Double türü, ikili kayan nokta aritmetiği için IEC 60559:1989 (IEEE 754) standardına uygundur.

Kayan nokta gösterimi ve hassasiyet

Double veri türü, aşağıdaki tabloda gösterildiği gibi çift duyarlıklı kayan nokta değerlerini 64 bit ikili biçimde depolar:

Bölüm	Bitler
İşaret veya mantis	0-51
Üs	52-62
İşaret (0 = Pozitif, 1 = Negatif)	63

Ondalık kesirlerin bazı kesirli değerleri (1/3 veya Math.PIgibi) tam olarak temsil edemediği gibi, ikili kesirler de bazı kesirli değerleri temsil edemez. Örneğin, ondalık kesir olarak tam olarak .1 ile temsil edilen 1/10, .001100110011 ile ikili kesir olarak temsil edilir ve "0011" deseni sonsuza kadar yineleniyor. Bu durumda kayan nokta değeri, temsil ettiği sayının kesin olmayan bir gösterimini sağlar. Özgün kayan nokta değeri üzerinde ek matematiksel işlemler gerçekleştirmek genellikle duyarlık eksikliğini artırma eğilimindedir. Örneğin, .1 değerinin 10 ile çarpılması ve .1 değerinin dokuz kez eklenmesinin sonucunu karşılaştırırsak, sekiz işlem daha içerdiğinden bu toplamanın daha az kesin sonuç ürettiğini görürüz. Bu farklılığın yalnızca "R" Doublekullanarak iki değerini görüntülediğimizde görünür olduğunu ve eğer gerekirse Double türü tarafından desteklenen 17 basamaklı duyarlığın tamamını görüntülediğini unutmayın.

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

Bazı sayılar tam olarak kesirli ikili değerler olarak temsil edilemediği için kayan noktalı sayılar yalnızca gerçek sayılara yakın olabilir.

Tüm kayan noktalı sayılar da sınırlı sayıda anlamlı basamağı vardır ve bu da kayan nokta değerinin gerçek bir sayıya ne kadar doğru yakın olduğunu belirler. Bir Double değeri, dahili olarak en fazla 17 basamak korunmasına rağmen en fazla 15 ondalık basamak hassasiyeti sağlar. Bu, bazı kayan nokta işlemlerinin kayan nokta değerini değiştirme duyarlığından yoksun olabileceği anlamına gelir. Aşağıdaki örnek, bir gösterim sağlar. Çok büyük bir kayan nokta değeri tanımlar ve ardından bu değere Double.Epsilon ile bir katrilyonun çarpımını ekler. Ancak ürün, özgün kayan nokta değerini değiştiremeyecek kadar küçük. En az önemli basama binde bir, üründeki en önemli basamak ise 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

Kayan noktalı bir sayının sınırlı duyarlığı çeşitli sonuçlara neden olur:

• Belirli bir kesinlik için eşit görünen iki kayan noktalı sayı, en az önemli basamakları farklı olduğundan eşit olarak değerlendirilmeyebilir. Aşağıdaki örnekte, bir dizi sayı bir araya eklenir ve bunların toplamı beklenen toplamlarıyla karşılaştırılır. İki değer aynı gibi görünse de, Equals yöntemine yapılan bir çağrı bunların olmadığını gösterir.

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

  Console.WriteLine(String, Object, Object) ifadesindeki biçim öğelerini {0} ve {1}'den {0:R} ve {1:R}'e değiştirirseniz ve iki Double değerinin tüm önemli basamaklarını görüntülerseniz, toplama işlemleri sırasında yaşanan duyarlık kaybı nedeniyle iki değerin eşit olmadığını açıkça görürsünüz. Bu durumda sorun, karşılaştırmayı gerçekleştirmeden önce Math.Round(Double, Int32) değerlerini istenen duyarlıkta yuvarlamak için Double yöntemi çağrılarak çözülebilir.

• Kayan noktalı sayı kullanan bir matematik veya karşılaştırma işlemi, ondalık sayı kullanıldığında aynı sonucu vermeyebilir çünkü ikili kayan noktalı sayı ondalık sayıya eşit olmayabilir. Önceki bir örnek, .1 ile 10 çarpımının sonucunu görüntüleyip 0,1 kez ekleyerek bunu göstermiş.

  Kesirli değerler içeren sayısal işlemlerde doğruluk önemli olduğunda, Decimal türü yerine Double kullanabilirsiniz. Int128 UInt128 türlerinin aralığını aşan tamsayı değerlerine sahip sayısal işlemlerde doğruluk önemliyse, BigInteger türünü kullanın.

• Kayan noktalı bir sayı söz konusu olduğunda değer gidiş dönüş olmayabilir. Bir işlem özgün kayan nokta numarasını başka bir forma dönüştürürse, ters işlem dönüştürülen formu kayan noktalı sayıya geri dönüştürürse ve son kayan nokta sayısı özgün kayan nokta numarasına eşitse, değer gidiş dönüş olarak söylenir. Dönüştürmede bir veya daha fazla en az anlamlı basamak kaybolduğundan veya değiştirildiğinden gidiş dönüş başarısız olabilir.

  Aşağıdaki örnekte, üç Double değeri dizelere dönüştürülür ve bir dosyaya kaydedilir. Bu örneği .NET Framework'te çalıştırırsanız, değerler aynı gibi görünse de, geri yüklenen değerler özgün değerlere eşit değildir. Bu sorun, o zamandan beri değerlerin doğru gidiş-dönüş yaptığı .NET'te çözülmüştür.

  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
  

  .NET Framework'ü hedef alıyorsanız, değerlerinin tam duyarlılığını korumak için "G17" Double kullanılarak değerler başarıyla geri yüklenebilir.

• Single değerlerin duyarlığı Double değerlerden daha azdır. Duyarlık farklılıkları nedeniyle genellikle Single'e dönüştürülen bir Double değeri, Double değerine eşit değildir. Aşağıdaki örnekte, aynı bölme işlemlerinin sonucu bir Double ve Single değerine atanır. Single değeri bir Double'a atandıktan sonra, iki değerin karşılaştırması bunların eşit olmadığını gösterir.

  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
  

  Bu sorunu önlemek için, Double veri türünün yerine Single kullanın veya her iki değerin de aynı duyarlıkta sahip olması için Round yöntemini kullanın.

Ayrıca, Double değerleri olan aritmetik ve atama işlemlerinin sonucu, Double türünün duyarlık kaybı nedeniyle platforma göre biraz farklılık gösterebilir. Örneğin, sabit Double değeri atamanın sonucu .NET'in 32 bit ve 64 bit sürümlerinde farklılık gösterebilir. Aşağıdaki örnek, -4,42330604244772E-305 sabit değeri ve değeri -4,42330604244772E-305 olan bir değişkenin Double değişkenine atandığında ortaya çıkan farkı göstermektedir. Bu durumda Parse(String) yönteminin sonucunun duyarlık kaybı yaşamadığını unutmayın.

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

Eşitlik testi

Eşit kabul edilmesi için iki Double değerin aynı değerleri temsil etmesi gerekir. Ancak, değerler arasındaki duyarlık farklılıkları nedeniyle veya bir veya her iki değere göre duyarlık kaybı nedeniyle, özdeş olması beklenen kayan nokta değerleri genellikle en az önemli basamaklarındaki farklılıklar nedeniyle eşit değildir. Sonuç olarak, iki değerin eşit olup olmadığını belirlemek için Equals yöntemine çağrılar veya iki CompareTo değer arasındaki ilişkiyi belirlemek için Double yöntemine çağrılar, genellikle beklenmeyen sonuçlar verir. Bu, aşağıdaki örnekte açıktır; iki görünüşte eşit Double değeri, birinci değerin 15 basamak duyarlığı, ikincinin ise 17 basamağa sahip olması nedeniyle eşit olmaz.

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

Farklı kod yollarını izleyen ve farklı şekillerde işlenen hesaplanan değerlerin genellikle eşit olmadığını kanıtlar. Aşağıdaki örnekte, bir Double değerinin karesi alınır ve ardından orijinal değeri geri yüklemek için karekök hesaplanır. İkinci bir Double, 3,51 ile çarpılır ve karesi alınır, ardından sonucun karekökü 3,51'e bölünerek özgün değer geri yüklenir. İki değer aynı gibi görünse de, Equals(Double) yöntemine yapılan bir çağrı bunların eşit olmadığını gösterir. Her Double değerinin tüm önemli basamaklarını görüntüleyen bir sonuç dizesi döndürmek için "R" standart biçim dizesini kullanmak, ikinci değerin birinciden .0000000000001 daha küçük olduğunu gösterir.

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

Bir duyarlık kaybının karşılaştırmanın sonucunu etkileyeceği durumlarda, Equals veya CompareTo yöntemini çağırmak için aşağıdaki alternatiflerden herhangi birini benimseyebilirsiniz:

• her iki değerin de aynı duyarlıkta sahip olduğundan emin olmak için Math.Round yöntemini çağırın. Aşağıdaki örnek, önceki bir örneği bu yaklaşımı kullanacak şekilde değiştirerek iki kesirli değerin eşdeğer olmasını sağlar.

  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
  

  Kesinlik sorunu orta nokta değerlerini yuvarlama için de geçerlidir. Daha fazla bilgi için bkz. Math.Round(Double, Int32, MidpointRounding) yöntemi.

• Eşitlik yerine yaklaşık eşitlik testi. Bu, iki değerin farklı ancak yine de eşit olabileceği mutlak bir tutar tanımlamanızı veya daha küçük değerin daha büyük değerden ayrışabileceği göreli bir miktar tanımlamanızı gerektirir.

  Uyarı

  Double.Epsilon bazen eşitlik testi sırasında iki Double değeri arasındaki uzaklığın mutlak bir ölçüsü olarak kullanılır. Ancak Double.Epsilon değeri sıfır olan bir Double eklenebilecek veya çıkarılabilen en küçük olası değeri ölçer. Çoğu pozitif ve negatif Double değeri için Double.Epsilon değeri algılanamaz kadar küçüktür. Bu nedenle, sıfır olan değerler dışında, eşitlik için testlerde kullanılmasını önermeyiz.

  Aşağıdaki örnek, iki değer arasındaki göreli farkı test eden bir IsApproximatelyEqual yöntemi tanımlamak için ikinci yaklaşımı kullanır. Ayrıca IsApproximatelyEqual yöntemine ve Equals(Double) yöntemine yapılan çağrıların sonucunu karşılaştırır.

  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
  

Kayan nokta değerleri ve özel durumları

Tamsayı türlerinde, taşma veya sıfıra bölme gibi hatalı işlemlerde istisna fırlatan işlemlerden farklı olarak, kayan nokta değerleriyle yapılan işlemler istisna fırlatmaz. Bunun yerine, olağanüstü durumlarda kayan nokta işleminin sonucu sıfır, pozitif sonsuz, negatif sonsuzdur veya sayı değildir (NaN):

• Kayan nokta işleminin sonucu hedef biçim için çok küçükse, sonuç sıfır olur. Aşağıdaki örnekte gösterildiği gibi, çok küçük iki sayı çarpıldığında bu durum oluşabilir.

  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
  

• Kayan nokta işleminin sonucunun büyüklüğü hedef biçimin aralığını aşarsa, sonucun işaretine uygun olarak işlemin sonucu PositiveInfinity veya NegativeInfinityolur. Double.MaxValue taşan bir işlemin sonucu PositiveInfinityve aşağıdaki örnekte gösterildiği gibi Double.MinValue taşan bir işlemin sonucu NegativeInfinity' dir.

  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, pozitif bir bölünenin sıfıra bölünmesi sonucu elde edilir ve NegativeInfinity, negatif bir bölünenin sıfıra bölünmesi sonucu elde edilir.

• Kayan nokta işlemi geçersizse, işlemin sonucu NaNolur. Örneğin, NaN aşağıdaki işlemlerden elde edilir:

  • Sıfıra, sıfırla bölme. Sıfıra bölmenin diğer durumlarının PositiveInfinity veya NegativeInfinityile sonuçlandığını unutmayın.

  • Geçersiz giriş içeren herhangi bir kayan nokta işlemi. Örneğin, Math.Sqrt yöntemini negatif bir değerle çağırmak, NaN yöntemini bir veya daha az negatif bir değerle çağırmak gibi Math.Acosdöndürür.

  • Değeri Double.NaNolan bağımsız değişkenle yapılan herhangi bir işlem.

Tür dönüştürmeleri

Double yapısı herhangi bir açık veya örtük dönüştürme işleci tanımlamaz; bunun yerine, dönüştürmeler derleyici tarafından uygulanır.

Herhangi bir ilkel sayısal türün değerinin Double'a dönüştürülmesi bu bir genişletme dönüştürmesidir, bu yüzden derleyici açıkça gerektirmediği sürece açık bir atama işleci veya dönüştürme yöntemi çağrısına gerek yoktur. Örneğin, C# derleyicisi DecimalDoubledönüştürmeleri için bir atama işleci gerektirir, ancak Visual Basic derleyicisi bunu yapmaz. Aşağıdaki örnek, diğer ilkel sayısal türlerin en düşük veya en yüksek değerini Doubledönüştürür.

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)

Ayrıca, Single değerleri sırasıyla Single.NaN, Single.PositiveInfinityve Single.NegativeInfinityDouble.NaN, Double.PositiveInfinityve Double.NegativeInfinitydönüştürülür.

Bazı sayısal türlerin değerinin Double bir değere dönüştürülmesinin doğruluk kaybına yol açabileceğini unutmayın. Örnekte gösterildiği gibi, Decimal, Int64ve UInt64 değerleri Double değerlere dönüştürülürken duyarlık kaybı mümkündür.

bir Double değerinin başka bir ilkel sayısal veri türündeki bir değere dönüştürülmesi bir daraltma dönüştürmesidir ve bir dönüştürme işleci (C#'de), dönüştürme yöntemi (Visual Basic'te) veya Convert yöntemine çağrı gerektirir. Hedef türün MinValue ve MaxValue özellikleri tarafından tanımlanan hedef veri türü aralığının dışında olan değerler, aşağıdaki tabloda gösterildiği gibi davranır.

Hedef türü	Sonuç
Herhangi bir tam sayı türü	Dönüştürme denetlenen bir bağlamda gerçekleşirse bir OverflowException istisnası. Dönüştürme denetimsiz bir bağlamda gerçekleşirse (C# dilinde varsayılan), dönüştürme işlemi başarılı olur ancak değer taşması meydana gelir.
Decimal	Bir OverflowException istisnası.
Single	Negatif değerler için Single.NegativeInfinity. Pozitif değerler için Single.PositiveInfinity.

Buna ek olarak, Double.NaN, Double.PositiveInfinityve Double.NegativeInfinity, denetlenmiş bağlamda tamsayı dönüştürmeleri için bir OverflowException istisnası fırlatır, ancak bu değerler kontrolsüz bir bağlamda tamsayılara dönüştürüldüğünde taşma meydana gelir. Decimaldönüştürmeleri için her zaman bir OverflowExceptionfırlatırlar. "Single'a dönüştürmeler için, sırasıyla, Single.NaN, Single.PositiveInfinityve Single.NegativeInfinity'e dönüştürülür."

Duyarlık kaybı, bir Double değerinin başka bir sayısal türe dönüştürülmesiyle sonuçlanabilir. Örnekte gösterildiği gibi, integral türlerinden herhangi birine dönüştürme durumunda, Double değeri yuvarlandığında (Visual Basic'te olduğu gibi) veya kesildiğinde (C# dilinde olduğu gibi) kesirli bileşen kaybolur. Decimal ve Single değerlerine dönüştürmeler için, Double değerin hedef veri türünde kesin bir gösterimi olmayabilir.

Aşağıdaki örnek, bir dizi Double değerini diğer birkaç sayısal türe dönüştürür. Dönüştürmeler Visual Basic'te (varsayılan), C# dilinde (denetimli anahtar sözcüğü nedeniyle) ve F# dilinde (Denetimli modülü nedeniyle) denetimli bir bağlamda gerçekleşir. Örnekten elde edilen çıktı, hem işaretli hem de işaretsiz bağlamlarda yapılan dönüştürmelerin sonucunu gösterir. Visual Basic'te /removeintchecks+ derleyici anahtarıyla derleyerek, C# dilinde checked ifadesini yorum satırına alarak ve F# dilinde open Checked ifadesini yorum satırına alarak denetlenmeyen bir bağlamda dönüşüm gerçekleştirebilirsiniz.

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)

Sayısal türlerin dönüştürülmesi hakkında daha fazla bilgi için bkz. .NET Tür Dönüştürme ve Tür Dönüştürme Tabloları.

Kayan nokta işlevselliği

Double yapısı ve ilgili türler aşağıdaki alanlarda işlem gerçekleştirmek için yöntemler sağlar:

• değerleri karşılaştırması. İki Equals değerin eşit olup olmadığını belirlemek için Double yöntemini veya iki değer arasındaki ilişkiyi belirlemek için CompareTo yöntemini çağırabilirsiniz.

  Double yapısı tam bir karşılaştırma işleçleri kümesini de destekler. Örneğin, eşitliği veya eşitsizliği test edebilir veya bir değerin başka bir değerden büyük mü yoksa başka bir değere eşit mi olduğunu belirleyebilirsiniz. İşlenenlerden biri Double dışında bir sayısal türse, karşılaştırma gerçekleştirilmeden önce Double türüne dönüştürülür.

  Uyarı

  Duyarlık farklılıkları nedeniyle, eşit olmasını beklediğiniz iki Double değeri eşit olmayabilir ve bu da karşılaştırmanın sonucunu etkiler. İki değerini karşılaştırma hakkında daha fazla bilgi için Double bölümüne bakın.

  Ayrıca, bu özel değerleri test etmek için IsNaN, IsInfinity, IsPositiveInfinityve IsNegativeInfinity yöntemlerini çağırabilirsiniz.

• Matematiksel işlemler. Toplama, çıkarma, çarpma ve bölme gibi yaygın aritmetik işlemler, Double yöntemleri yerine dil derleyicileri ve Ortak Ara Dil (CIL) yönergeleri tarafından uygulanır. Eğer matematiksel bir işlemde, işlenenlerden biri Doubledışında bir sayısal türe sahipse, bu işlemden önce bir Double'e dönüştürülür. İşlemin sonucu da Double değeridir.

  Diğer matematik işlemleri, static sınıfında Shared ( Visual Basic'teSystem.Math) yöntemleri çağrılarak gerçekleştirilebilir. Aritmetik (Math.Abs, Math.Signve Math.Sqrt), geometri (Math.Cos ve Math.Singibi) ve hesap (Math.Loggibi) için yaygın olarak kullanılan ek yöntemleri içerir.

  Ayrıca, Double bir değerdeki tek tek bitleri de işleyebilirsiniz. BitConverter.DoubleToInt64Bits yöntemi, Double değerin bit desenini 64 bitlik bir tamsayıda korur. BitConverter.GetBytes(Double) yöntemi bit desenini bayt dizisinde döndürür.

• Yuvarlama. Yuvarlama, genellikle, kayan nokta gösterimi ve kesinlik sorunlarının neden olduğu değerler arasındaki farkların etkisini azaltmak için bir teknik olarak kullanılır. Double yöntemini çağırarak Math.Round değeri yuvarlayabilirsiniz.

• biçimlendirme . Double yöntemini çağırarak veya bileşik biçimlendirme özelliğini kullanarak bir ToString değerini dize gösterimine dönüştürebilirsiniz. Biçim dizelerinin kayan nokta değerlerinin dize gösterimini nasıl denetlediğini öğrenmek için bkz. Standart Sayısal Biçim Dizeleri ve Özel Sayısal Biçim Dizeleri.

• Dizeleri ayrıştırma. Kayan nokta değerinin dize gösterimini, Double veya Parse yöntemini çağırarak TryParse bir değere dönüştürebilirsiniz. Ayrıştırma işlemi başarısız olursa, Parse yöntemi bir özel durum oluştururken, TryParse yöntemi falsedöndürür.

• Tür dönüştürme. Double yapısı, iki standart .NET veri türü arasında dönüştürmeyi destekleyen IConvertible arabirimi için açık bir arabirim uygulaması sağlar. Dil derleyicileri, diğer tüm standart sayısal türlerdeki değerlerin örtük olarak Double değerlere dönüştürülmesini de destekler. Herhangi bir standart sayısal türün değerinin Double'a dönüştürülmesi bir genişletme dönüştürmesidir ve bir atama işlecinin veya dönüştürme yönteminin kullanımını gerektirmez.

  Ancak, Int64 ve Single değerlerinin dönüştürülmesi duyarlık kaybı içerebilir. Aşağıdaki tabloda, bu türlerin her biri için duyarlık farklılıkları listelenmiştir:

  Türü	En yüksek duyarlık	İçsel doğruluk
  Double	15	17
  Int64	19 ondalık basamak	19 ondalık basamak
  Single	7 ondalık basamak	9 ondalık basamak

  Hassasiyet sorunu, en sık Single değerleri Double değerlere dönüştürüldüğünde etkiler. Aşağıdaki örnekte, aynı bölme işlemleri tarafından üretilen iki değer eşit değildir çünkü değerlerden biri, tek duyarlıklı kayan nokta değeri olup Double'e dönüştürülmüştür.

  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
  

Örnekler

Aşağıdaki kod örneğinde Doublekullanımı gösterilmektedir:

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