System.Single, struktura

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

Typ Single wartości reprezentuje liczbę 32-bitową o pojedynczej precyzji z wartościami ujemnymi 3,402823e38 do dodatnich 3,402823e38, a także zerem dodatnim lub ujemnym, PositiveInfinity, a NegativeInfinitynie liczbą (NaN). Ma ona reprezentować wartości, które są bardzo duże (takie jak odległości między planetami lub galaktykami) lub bardzo małe (takie jak masa molekularna substancji w kilogramach) i które często są nieprecyzyjne (takie jak odległość od ziemi do innego układu słonecznego). Typ Single jest zgodny ze standardem IEC 60559:1989 (IEEE 754) dla arytmetyki binarnej zmiennoprzecinkowe.

System.Single Udostępnia metody porównywania wystąpień tego typu, aby przekonwertować wartość wystąpienia na jego reprezentację ciągu i przekonwertować reprezentację ciągu liczby na wystąpienie tego typu. Informacje o sposobie kontrolowania reprezentacji ciągów typów wartości można znaleźć w temacie Formatting Types (Typy formatowania), Standard Numeric Format Strings (Standardowe ciągi formatu liczbowego) i Custom Numeric Format Strings (Niestandardowe ciągi formatu liczbowego).

Reprezentacja liczb zmiennoprzecinkowych i precyzja

Typ Single danych przechowuje wartości zmiennoprzecinkowe o pojedynczej precyzji w formacie binarnym 32-bitowym, jak pokazano w poniższej tabeli:

Element	Bity
Significand lub mantissa	0-22
Wykładnik	23-30
Znak (0 = dodatni, 1 = ujemny)	31

Tak samo jak ułamki dziesiętne nie mogą dokładnie reprezentować niektórych wartości ułamkowych (takich jak 1/3 lub Math.PI), ułamki binarne nie mogą reprezentować niektórych wartości ułamkowych. Na przykład 2/10, który jest reprezentowany dokładnie przez .2 jako ułamek dziesiętny, jest reprezentowany przez .0011111001001100 jako ułamek binarny, ze wzorcem "1100" powtarzającym się do nieskończoności. W tym przypadku wartość zmiennoprzecinkowa zapewnia niemożliwą reprezentację reprezentowanej przez nią liczby. Wykonywanie dodatkowych operacji matematycznych na oryginalnej wartości zmiennoprzecinkowej często zwiększa jej brak precyzji. Jeśli na przykład porównasz wyniki mnożenia wartości .3 przez 10 i dodasz wartość .3 do 3 dziewięć razy, zobaczysz, że dodanie daje mniej precyzyjny wynik, ponieważ obejmuje osiem operacji więcej niż mnożenie. Należy pamiętać, że ta różnica jest widoczna tylko wtedy, gdy są wyświetlane dwie Single wartości przy użyciu standardowego ciągu formatu liczbowego "R", który w razie potrzeby wyświetla wszystkie 9 cyfr dokładności obsługiwanej przez Single typ.

using System;

public class Example12
{
    public static void Main()
    {
        Single value = .2f;
        Single result1 = value * 10f;
        Single result2 = 0f;
        for (int ctr = 1; ctr <= 10; ctr++)
            result2 += value;

        Console.WriteLine(".2 * 10:           {0:R}", result1);
        Console.WriteLine(".2 Added 10 times: {0:R}", result2);
    }
}
// The example displays the following output:
//       .2 * 10:           2
//       .2 Added 10 times: 2.00000024

let value = 0.2f
let result1 = value * 10f
let mutable result2 = 0f
for _ = 1 to 10 do
    result2 <- result2 + value

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

Module Example13
    Public Sub Main()
        Dim value As Single = 0.2
        Dim result1 As Single = value * 10
        Dim result2 As Single
        For ctr As Integer = 1 To 10
            result2 += value
        Next
        Console.WriteLine(".2 * 10:           {0:R}", result1)
        Console.WriteLine(".2 Added 10 times: {0:R}", result2)
    End Sub
End Module
' The example displays the following output:
'       .2 * 10:           2
'       .2 Added 10 times: 2.00000024

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

Wszystkie liczby zmiennoprzecinkowe mają ograniczoną liczbę cyfr znaczących, co określa również, jak dokładnie wartość zmiennoprzecinkowa przybliża liczbę rzeczywistą. Single Wartość ma maksymalnie 7 cyfr dziesiętnych precyzji, chociaż maksymalnie 9 cyfr jest utrzymywanych wewnętrznie. Oznacza to, że niektóre operacje zmiennoprzecinkowe mogą nie mieć precyzji zmiany wartości zmiennoprzecinkowej. W poniższym przykładzie zdefiniowano dużą wartość zmiennoprzecinkową o pojedynczej precyzji, a następnie dodano do niej produkt Single.Epsilon i jeden czworokąt. Jednak produkt jest zbyt mały, aby zmodyfikować oryginalną wartość zmiennoprzecinkową. Jego najmniej znacząca cyfra to liczba tysięcy, natomiast najważniejszą cyfrą w produkcie jest 10^–30.

using System;

public class Example13
{
    public static void Main()
    {
        Single value = 123.456f;
        Single additional = Single.Epsilon * 1e15f;
        Console.WriteLine($"{value} + {additional} = {value + additional}");
    }
}
// The example displays the following output:
//    123.456 + 1.401298E-30 = 123.456

open System

let value = 123.456f
let additional = Single.Epsilon * 1e15f
printfn $"{value} + {additional} = {value + additional}"
// The example displays the following output:
//    123.456 + 1.401298E-30 = 123.456

Module Example
   Public Sub Main()
      Dim value As Single = 123.456
      Dim additional As Single = Single.Epsilon * 1e15
      Console.WriteLine($"{value} + {additional} = {value + additional}")
   End Sub
End Module
' The example displays the following output:
'   123.456 + 1.401298E-30 = 123.456

Ograniczona precyzja liczby zmiennoprzecinkowych ma kilka konsekwencji:

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

  using System;
  
  public class Example9
  {
      public static void Main()
      {
          Single[] values = { 10.01f, 2.88f, 2.88f, 2.88f, 9.0f };
          Single result = 27.65f;
          Single total = 0f;
          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 (27.65) does not equal the total (27.65).   
  //
  // 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.6500015) does not equal the total (27.65).
  

  let values = [| 10.01f; 2.88f; 2.88f; 2.88f; 9f |]
  let result = 27.65f
  let mutable total = 0f
  for value in values do
      total <- total + value
  
  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 (27.65) does not equal the total (27.65).   
  //
  // 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.6500015) does not equal the total (27.65).
  

  Module Example10
      Public Sub Main()
          Dim values() As Single = {10.01, 2.88, 2.88, 2.88, 9.0}
          Dim result As Single = 27.65
          Dim total As Single
          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 (27.65) does not equal the total (27.65).   
  '
  ' If the index items in the Console.WriteLine statement are changed to {0:R},
  ' the example displays the following output:
  '       The sum of the values (27.639999999999997) does not equal the total (27.64).
  

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

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

  Gdy dokładność operacji liczbowych z wartościami ułamkowymi jest ważna, należy użyć Decimal typu zamiast Single typu. Gdy dokładność operacji liczbowych z wartościami całkowitymi poza zakresem Int64 typów lub UInt64 jest ważna, użyj BigInteger typu .

• Wartość może nie być zaokrąglona, jeśli jest zaangażowana liczba zmiennoprzecinkowa. Mówi się, że wartość zaokrąglona, jeśli operacja konwertuje oryginalną liczbę zmiennoprzecinkową na inną formę, operacja odwrotna przekształca przekonwertowany formularz z powrotem na liczbę zmiennoprzecinkową, a końcowa liczba zmiennoprzecinkowa jest równa oryginalnej liczbie zmiennoprzecinkowej. Runda może zakończyć się niepowodzeniem, ponieważ co najmniej jedna cyfra znacząca zostanie utracona lub zmieniona w konwersji. W poniższym przykładzie trzy Single wartości są konwertowane na ciągi i zapisywane w pliku. Jak pokazują dane wyjściowe, chociaż wartości wydają się być identyczne, przywrócone wartości nie są równe oryginalnym wartościom.

  using System;
  using System.IO;
  
  public class Example10
  {
      public static void Main()
      {
          StreamWriter sw = new StreamWriter(@".\Singles.dat");
          Single[] values = { 3.2f / 1.11f, 1.0f / 3f, (float)Math.PI };
          for (int ctr = 0; ctr < values.Length; ctr++)
          {
              sw.Write(values[ctr].ToString());
              if (ctr != values.Length - 1)
                  sw.Write("|");
          }
          sw.Close();
  
          Single[] restoredValues = new Single[values.Length];
          StreamReader sr = new StreamReader(@".\Singles.dat");
          string temp = sr.ReadToEnd();
          string[] tempStrings = temp.Split('|');
          for (int ctr = 0; ctr < tempStrings.Length; ctr++)
              restoredValues[ctr] = Single.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.882883 <> 2.882883
  //       0.3333333 <> 0.3333333
  //       3.141593 <> 3.141593
  

  open System
  open System.IO
  
  let values = [| 3.2f / 1.11f; 1f / 3f; MathF.PI |]
  
  do
      use sw = new StreamWriter(@".\Singles.dat")
      for i = 0 to values.Length - 1 do
          sw.Write(string values[i])
          if i <> values.Length - 1 then
              sw.Write "|"
  
  let restoredValues =
      use sr = new StreamReader(@".\Singles.dat")
      sr.ReadToEnd().Split '|'
      |> Array.map Single.Parse
  
  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.882883 <> 2.882883
  //       0.3333333 <> 0.3333333
  //       3.141593 <> 3.141593
  

  Imports System.IO
  
  Module Example11
      Public Sub Main()
          Dim sw As New StreamWriter(".\Singles.dat")
          Dim values() As Single = {3.2 / 1.11, 1.0 / 3, CSng(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 Single
          Dim sr As New StreamReader(".\Singles.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) = Single.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.882883 <> 2.882883
  '        0.3333333 <> 0.3333333
  '        3.141593 <> 3.141593
  

  W takim przypadku wartości można pomyślnie zaokrąglić przy użyciu standardowego ciągu formatu liczbowego "G9", aby zachować pełną precyzję Single wartości, jak pokazano w poniższym przykładzie.

  using System;
  using System.IO;
  
  public class Example11
  {
      public static void Main()
      {
          StreamWriter sw = new StreamWriter(@".\Singles.dat");
          Single[] values = { 3.2f / 1.11f, 1.0f / 3f, (float)Math.PI };
          for (int ctr = 0; ctr < values.Length; ctr++)
              sw.Write("{0:G9}{1}", values[ctr], ctr < values.Length - 1 ? "|" : "");
  
          sw.Close();
  
          Single[] restoredValues = new Single[values.Length];
          StreamReader sr = new StreamReader(@".\Singles.dat");
          string temp = sr.ReadToEnd();
          string[] tempStrings = temp.Split('|');
          for (int ctr = 0; ctr < tempStrings.Length; ctr++)
              restoredValues[ctr] = Single.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.882883 = 2.882883
  //       0.3333333 = 0.3333333
  //       3.141593 = 3.141593
  

  open System
  open System.IO
  
  let values = [| 3.2f / 1.11f; 1f / 3f; MathF.PI |]
  
  do
      use sw = new StreamWriter(@".\Singles.dat")
      for i = 0 to values.Length - 1 do
          sw.Write $"""{values[i]:G9}{if i < values.Length - 1 then "|" else ""}"""
      
      
  let restoredValues =
      use sr = new StreamReader(@".\Singles.dat")
      sr.ReadToEnd().Split '|'
      |> Array.map Single.Parse
  
  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.882883 = 2.882883
  //       0.3333333 = 0.3333333
  //       3.141593 = 3.141593
  

  Imports System.IO
  
  Module Example12
      Public Sub Main()
          Dim sw As New StreamWriter(".\Singles.dat")
          Dim values() As Single = {3.2 / 1.11, 1.0 / 3, CSng(Math.PI)}
          For ctr As Integer = 0 To values.Length - 1
              sw.Write("{0:G9}{1}", values(ctr),
                    If(ctr < values.Length - 1, "|", ""))
          Next
          sw.Close()
  
          Dim restoredValues(values.Length - 1) As Single
          Dim sr As New StreamReader(".\Singles.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) = Single.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.882883 = 2.882883
  '       0.3333333 = 0.3333333
  '       3.141593 = 3.141593
  

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

  using System;
  
  public class Example9
  {
      public static void Main()
      {
          Double value1 = 1 / 3.0;
          Single sValue2 = 1 / 3.0f;
          Double value2 = (Double)sValue2;
          Console.WriteLine("{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
  

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

Testowanie pod kątem równości

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

using System;

public class Example
{
   public static void Main()
   {
      float value1 = .3333333f;
      float value2 = 1.0f/3;
      Console.WriteLine("{0:R} = {1:R}: {2}", value1, value2, value1.Equals(value2));
   }
}
// The example displays the following output:
//        0.3333333 = 0.333333343: False

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

Module Example1
    Public Sub Main()
        Dim value1 As Single = 0.3333333
        Dim value2 As Single = 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.3333333 = 0.333333343: False

Obliczone wartości, które są zgodne z różnymi ścieżkami kodu i które są manipulowane na różne sposoby, często okazują się nierówne. W poniższym przykładzie jedna Single wartość jest kwadratowa, a następnie pierwiastek kwadratowy jest obliczany w celu przywrócenia oryginalnej wartości. Sekunda Single jest mnożona przez 3,51 i kwadratowa, zanim pierwiastek kwadratowy wyniku jest podzielony przez 3,51, aby przywrócić oryginalną wartość. Chociaż dwie wartości wydają się być identyczne, wywołanie Equals(Single) metody wskazuje, że nie są równe. Używając standardowego ciągu formatu "G9", aby zwrócić ciąg wynikowy, który wyświetla wszystkie znaczące cyfry każdej Single wartości, pokazuje, że druga wartość to .0000000000001 mniejsza niż pierwsza.

using System;

public class Example1
{
    public static void Main()
    {
        float value1 = 10.201438f;
        value1 = (float)Math.Sqrt((float)Math.Pow(value1, 2));
        float value2 = (float)Math.Pow((float)value1 * 3.51f, 2);
        value2 = ((float)Math.Sqrt(value2)) / 3.51f;
        Console.WriteLine("{0} = {1}: {2}\n",
                          value1, value2, value1.Equals(value2));
        Console.WriteLine("{0:G9} = {1:G9}", value1, value2);
    }
}
// The example displays the following output:
//       10.20144 = 10.20144: False
//       
//       10.201438 = 10.2014389

let value1 = 
    10.201438f ** 2f
    |> sqrt

let value2 =
   ((value1 * 3.51f) ** 2f |> sqrt) / 3.51f

printfn $"{value1} = {value2}: {value1.Equals value2}\n" 
printfn $"{value1:G9} = {value2:G9}"
// The example displays the following output:
//       10.20144 = 10.20144: False
//       
//       10.201438 = 10.2014389

Module Example2
    Public Sub Main()
        Dim value1 As Single = 10.201438
        value1 = CSng(Math.Sqrt(CSng(Math.Pow(value1, 2))))
        Dim value2 As Single = CSng(Math.Pow(value1 * CSng(3.51), 2))
        value2 = CSng(Math.Sqrt(value2) / CSng(3.51))
        Console.WriteLine("{0} = {1}: {2}",
                        value1, value2, value1.Equals(value2))
        Console.WriteLine()
        Console.WriteLine("{0:G9} = {1:G9}", value1, value2)
    End Sub
End Module
' The example displays the following output:
'       10.20144 = 10.20144: False
'       
'       10.201438 = 10.2014389

W przypadkach, gdy utrata dokładności może mieć wpływ na wynik porównania, można użyć następujących technik zamiast wywoływać metodę Equals or CompareTo :

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

  using System;
  
  public class Example2
  {
      public static void Main()
      {
          float value1 = .3333333f;
          float value2 = 1.0f / 3;
          int precision = 7;
          value1 = (float)Math.Round(value1, precision);
          value2 = (float)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 value1 = 0.3333333f
  let value2 = 1f / 3f
  let precision = 7
  let value1r = Math.Round(float value1, precision) |> float32
  let value2r = Math.Round(float value2, precision) |> float32
  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 Single = 0.3333333
          Dim value2 As Single = 1 / 3
          Dim precision As Integer = 7
          value1 = CSng(Math.Round(value1, precision))
          value2 = CSng(Math.Round(value2, precision))
          Console.WriteLine("{0:R} = {1:R}: {2}", value1, value2, value1.Equals(value2))
      End Sub
  End Module
  ' The example displays the following output:
  '       0.3333333 = 0.3333333: True
  

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

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

  Ostrzeżenie

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

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

  using System;
  
  public class Example3
  {
      public static void Main()
      {
          float one1 = .1f * 10;
          float one2 = 0f;
          for (int ctr = 1; ctr <= 10; ctr++)
              one2 += .1f;
  
          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, .000001f));
      }
  
      static bool IsApproximatelyEqual(float value1, float value2, float 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 = 1.00000012: False
  //       1 is approximately equal to 1.00000012: True
  

  open System
  
  let isApproximatelyEqual value1 value2 epsilon =
      // If they are equal anyway, just return True.
      if value1.Equals value2 then 
          true
      // Handle NaN, Infinity.
      elif Single.IsInfinity value1 || Single.IsNaN value1 then
          value1.Equals value2
      elif Single.IsInfinity value2 || Single.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.1f * 10f
  let mutable one2 = 0f
  for _ = 1 to 10 do
     one2 <- one2 + 0.1f
  
  printfn $"{one1:R} = {one2:R}: {one1.Equals one2}"
  printfn $"{one1:R} is approximately equal to {one2:R}: {isApproximatelyEqual one1 one2 0.000001f}" 
  // The example displays the following output:
  //       1 = 1.00000012: False
  //       1 is approximately equal to 1.00000012: True
  

  Module Example4
      Public Sub Main()
          Dim one1 As Single = 0.1 * 10
          Dim one2 As Single = 0
          For ctr As Integer = 1 To 10
              one2 += CSng(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.000001))
      End Sub
  
      Function IsApproximatelyEqual(value1 As Single, value2 As Single,
                                   epsilon As Single) As Boolean
          ' If they are equal anyway, just return True.
          If value1.Equals(value2) Then Return True
  
          ' Handle NaN, Infinity.
          If Single.IsInfinity(value1) Or Single.IsNaN(value1) Then
              Return value1.Equals(value2)
          ElseIf Single.IsInfinity(value2) Or Single.IsNaN(value2) Then
              Return value1.Equals(value2)
          End If
  
          ' Handle zero to avoid division by zero
          Dim divisor As Single = 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 = 1.00000012: False
  '       1 is approximately equal to 1.00000012: True
  

Wartości zmiennoprzecinkowe i wyjątki

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

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

  using System;
  
  public class Example6
  {
      public static void Main()
      {
          float value1 = 1.163287e-36f;
          float value2 = 9.164234e-25f;
          float result = value1 * value2;
          Console.WriteLine("{0} * {1} = {2}", value1, value2, result);
          Console.WriteLine("{0} = 0: {1}", result, result.Equals(0.0f));
      }
  }
  // The example displays the following output:
  //       1.163287E-36 * 9.164234E-25 = 0
  //       0 = 0: True
  

  let value1 = 1.163287e-36f
  let value2 = 9.164234e-25f
  let result = value1 * value2
  printfn $"{value1} * {value2} = {result}"
  printfn $"{result} = 0: {result.Equals(0f)}"
  // The example displays the following output:
  //       1.163287E-36 * 9.164234E-25 = 0
  //       0 = 0: True
  

  Module Example7
      Public Sub Main()
          Dim value1 As Single = 1.163287E-36
          Dim value2 As Single = 9.164234E-25
          Dim result As Single = value1 * value2
          Console.WriteLine("{0} * {1} = {2:R}", value1, value2, result)
          Console.WriteLine("{0} = 0: {1}", result, result.Equals(0))
      End Sub
  End Module
  ' The example displays the following output:
  '       1.163287E-36 * 9.164234E-25 = 0
  '       0 = 0: True
  

• Jeśli wielkość wyniku operacji zmiennoprzecinkowych przekracza zakres formatu docelowego, wynik operacji to PositiveInfinity lub NegativeInfinity, odpowiednio dla znaku wyniku. Wynikiem operacji, która przepełnia Single.MaxValue się, jest PositiveInfinity, a wynikiem operacji, która przepełnia Single.MinValue się, jest NegativeInfinity, jak pokazano w poniższym przykładzie.

  using System;
  
  public class Example7
  {
      public static void Main()
      {
          float value1 = 3.065e35f;
          float value2 = 6.9375e32f;
          float result = value1 * value2;
          Console.WriteLine("PositiveInfinity: {0}",
                             Single.IsPositiveInfinity(result));
          Console.WriteLine("NegativeInfinity: {0}\n",
                            Single.IsNegativeInfinity(result));
  
          value1 = -value1;
          result = value1 * value2;
          Console.WriteLine("PositiveInfinity: {0}",
                             Single.IsPositiveInfinity(result));
          Console.WriteLine("NegativeInfinity: {0}",
                            Single.IsNegativeInfinity(result));
      }
  }
  
  // The example displays the following output:
  //       PositiveInfinity: True
  //       NegativeInfinity: False
  //       
  //       PositiveInfinity: False
  //       NegativeInfinity: True
  

  open System
  
  let value1 = 3.065e35f
  let value2 = 6.9375e32f
  let result = value1 * value2
  printfn $"PositiveInfinity: {Single.IsPositiveInfinity result}" 
  printfn $"NegativeInfinity: {Single.IsNegativeInfinity result}\n"
  
  let value3 = -value1
  let result2 = value3 * value2
  printfn $"PositiveInfinity: {Single.IsPositiveInfinity result}" 
  printfn $"NegativeInfinity: {Single.IsNegativeInfinity result}" 
  
  // The example displays the following output:
  //       PositiveInfinity: True
  //       NegativeInfinity: False
  //       
  //       PositiveInfinity: False
  //       NegativeInfinity: True
  

  Module Example8
      Public Sub Main()
          Dim value1 As Single = 3.065E+35
          Dim value2 As Single = 6.9375E+32
          Dim result As Single = value1 * value2
          Console.WriteLine("PositiveInfinity: {0}",
                           Single.IsPositiveInfinity(result))
          Console.WriteLine("NegativeInfinity: {0}",
                          Single.IsNegativeInfinity(result))
          Console.WriteLine()
          value1 = -value1
          result = value1 * value2
          Console.WriteLine("PositiveInfinity: {0}",
                           Single.IsPositiveInfinity(result))
          Console.WriteLine("NegativeInfinity: {0}",
                          Single.IsNegativeInfinity(result))
      End Sub
  End Module
  ' The example displays the following output:
  '       PositiveInfinity: True
  '       NegativeInfinity: False
  '       
  '       PositiveInfinity: False
  '       NegativeInfinity: True
  

  PositiveInfinity wynika również z podziału o zero z dodatnią dywidendą i NegativeInfinity wynika z podziału o zero z ujemną dywidendą.

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

  • Podział o zero z dywidendą zero. Należy pamiętać, że inne przypadki dzielenia według zera powodują PositiveInfinity , albo NegativeInfinity.
  • Dowolna operacja zmiennoprzecinkowa z nieprawidłowym wejściem. Na przykład próba znalezienia pierwiastek kwadratowy wartości ujemnej zwraca wartość NaN.
  • Każda operacja z argumentem, którego wartość to Single.NaN.

Konwersje typu

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

W poniższej tabeli wymieniono możliwe konwersje wartości innych pierwotnych typów liczbowych na Single wartość. Wskazuje również, czy konwersja jest rozszerzana, czy zawężana i czy wynik Single może mieć mniejszą precyzję niż oryginalna wartość.

Konwersja z	Rozszerzanie/zawężanie	Możliwa utrata precyzji
Byte	Widening	Nie.
Decimal	Widening Należy pamiętać, że język C# wymaga operatora rzutowania.	Tak. Decimal obsługuje 29 cyfr dziesiętnych precyzji; Single obsługuje wartość 9.
Double	Zwężenie; Wartości poza zakresem są konwertowane na Double.NegativeInfinity lub Double.PositiveInfinity.	Tak. Double obsługuje 17 cyfr dziesiętnych precyzji; Single obsługuje wartość 9.
Int16	Widening	Nie.
Int32	Widening	Tak. Int32 obsługuje 10 cyfr dziesiętnych precyzji; Single obsługuje wartość 9.
Int64	Widening	Tak. Int64 obsługuje 19 cyfr dziesiętnych precyzji; Single obsługuje wartość 9.
SByte	Widening	Nie.
UInt16	Widening	Nie.
UInt32	Widening	Tak. UInt32 obsługuje 10 cyfr dziesiętnych precyzji; Single obsługuje wartość 9.
UInt64	Widening	Tak. Int64 obsługuje 20 cyfr dziesiętnych precyzji; Single obsługuje wartość 9.

Poniższy przykład konwertuje minimalną lub maksymalną wartość innych pierwotnych typów liczbowych Single na wartość.

using System;

public class Example4
{
    public static void Main()
    {
        dynamic[] values = { Byte.MinValue, Byte.MaxValue, Decimal.MinValue,
                           Decimal.MaxValue, Double.MinValue, Double.MaxValue,
                           Int16.MinValue, Int16.MaxValue, Int32.MinValue,
                           Int32.MaxValue, Int64.MinValue, Int64.MaxValue,
                           SByte.MinValue, SByte.MaxValue, UInt16.MinValue,
                           UInt16.MaxValue, UInt32.MinValue, UInt32.MaxValue,
                           UInt64.MinValue, UInt64.MaxValue };
        float sngValue;
        foreach (var value in values)
        {
            if (value.GetType() == typeof(Decimal) ||
                value.GetType() == typeof(Double))
                sngValue = (float)value;
            else
                sngValue = value;
            Console.WriteLine("{0} ({1}) --> {2:R} ({3})",
                              value, value.GetType().Name,
                              sngValue, sngValue.GetType().Name);
        }
    }
}
// The example displays the following output:
//       0 (Byte) --> 0 (Single)
//       255 (Byte) --> 255 (Single)
//       -79228162514264337593543950335 (Decimal) --> -7.92281625E+28 (Single)
//       79228162514264337593543950335 (Decimal) --> 7.92281625E+28 (Single)
//       -1.79769313486232E+308 (Double) --> -Infinity (Single)
//       1.79769313486232E+308 (Double) --> Infinity (Single)
//       -32768 (Int16) --> -32768 (Single)
//       32767 (Int16) --> 32767 (Single)
//       -2147483648 (Int32) --> -2.14748365E+09 (Single)
//       2147483647 (Int32) --> 2.14748365E+09 (Single)
//       -9223372036854775808 (Int64) --> -9.223372E+18 (Single)
//       9223372036854775807 (Int64) --> 9.223372E+18 (Single)
//       -128 (SByte) --> -128 (Single)
//       127 (SByte) --> 127 (Single)
//       0 (UInt16) --> 0 (Single)
//       65535 (UInt16) --> 65535 (Single)
//       0 (UInt32) --> 0 (Single)
//       4294967295 (UInt32) --> 4.2949673E+09 (Single)
//       0 (UInt64) --> 0 (Single)
//       18446744073709551615 (UInt64) --> 1.84467441E+19 (Single)

open System

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

for value in values do
    let sngValue = 
        match value with
        | :? byte as v -> float32 v
        | :? decimal as v -> float32 v
        | :? double as v -> float32 v
        | :? int16 as v -> float32 v
        | :? int as v -> float32 v
        | :? int64 as v -> float32 v
        | :? int8 as v -> float32 v
        | :? uint16 as v -> float32 v
        | :? uint as v -> float32 v
        | :? uint64 as v -> float32 v
        | _ -> raise (NotImplementedException "Unknown Type")
    printfn $"{value} ({value.GetType().Name}) --> {sngValue:R} ({sngValue.GetType().Name})"
// The example displays the following output:
//       0 (Byte) --> 0 (Single)
//       255 (Byte) --> 255 (Single)
//       -79228162514264337593543950335 (Decimal) --> -7.92281625E+28 (Single)
//       79228162514264337593543950335 (Decimal) --> 7.92281625E+28 (Single)
//       -1.79769313486232E+308 (Double) --> -Infinity (Single)
//       1.79769313486232E+308 (Double) --> Infinity (Single)
//       -32768 (Int16) --> -32768 (Single)
//       32767 (Int16) --> 32767 (Single)
//       -2147483648 (Int32) --> -2.14748365E+09 (Single)
//       2147483647 (Int32) --> 2.14748365E+09 (Single)
//       -9223372036854775808 (Int64) --> -9.223372E+18 (Single)
//       9223372036854775807 (Int64) --> 9.223372E+18 (Single)
//       -128 (SByte) --> -128 (Single)
//       127 (SByte) --> 127 (Single)
//       0 (UInt16) --> 0 (Single)
//       65535 (UInt16) --> 65535 (Single)
//       0 (UInt32) --> 0 (Single)
//       4294967295 (UInt32) --> 4.2949673E+09 (Single)
//       0 (UInt64) --> 0 (Single)
//       18446744073709551615 (UInt64) --> 1.84467441E+19 (Single)

Module Example5
    Public Sub Main()
        Dim values() As Object = {Byte.MinValue, Byte.MaxValue, Decimal.MinValue,
                                 Decimal.MaxValue, Double.MinValue, Double.MaxValue,
                                 Int16.MinValue, Int16.MaxValue, Int32.MinValue,
                                 Int32.MaxValue, Int64.MinValue, Int64.MaxValue,
                                 SByte.MinValue, SByte.MaxValue, UInt16.MinValue,
                                 UInt16.MaxValue, UInt32.MinValue, UInt32.MaxValue,
                                 UInt64.MinValue, UInt64.MaxValue}
        Dim sngValue As Single
        For Each value In values
            If value.GetType() = GetType(Double) Then
                sngValue = CSng(value)
            Else
                sngValue = value
            End If
            Console.WriteLine("{0} ({1}) --> {2:R} ({3})",
                           value, value.GetType().Name,
                           sngValue, sngValue.GetType().Name)
        Next
    End Sub
End Module
' The example displays the following output:
'       0 (Byte) --> 0 (Single)
'       255 (Byte) --> 255 (Single)
'       -79228162514264337593543950335 (Decimal) --> -7.92281625E+28 (Single)
'       79228162514264337593543950335 (Decimal) --> 7.92281625E+28 (Single)
'       -1.79769313486232E+308 (Double) --> -Infinity (Single)
'       1.79769313486232E+308 (Double) --> Infinity (Single)
'       -32768 (Int16) --> -32768 (Single)
'       32767 (Int16) --> 32767 (Single)
'       -2147483648 (Int32) --> -2.14748365E+09 (Single)
'       2147483647 (Int32) --> 2.14748365E+09 (Single)
'       -9223372036854775808 (Int64) --> -9.223372E+18 (Single)
'       9223372036854775807 (Int64) --> 9.223372E+18 (Single)
'       -128 (SByte) --> -128 (Single)
'       127 (SByte) --> 127 (Single)
'       0 (UInt16) --> 0 (Single)
'       65535 (UInt16) --> 65535 (Single)
'       0 (UInt32) --> 0 (Single)
'       4294967295 (UInt32) --> 4.2949673E+09 (Single)
'       0 (UInt64) --> 0 (Single)
'       18446744073709551615 (UInt64) --> 1.84467441E+19 (Single)

Ponadto Double wartości Double.NaN, Double.PositiveInfinityi Double.NegativeInfinity konwertują odpowiednio na Single.NaN, Single.PositiveInfinityi Single.NegativeInfinity.

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

Konwersja Single wartości na wartość Double jest konwersją rozszerzającą. Konwersja może spowodować utratę dokładności, jeśli Double typ nie ma dokładnej Single reprezentacji wartości.

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

Typ docelowy	Result
Dowolny typ całkowity	Wyjątek OverflowException , jeśli konwersja występuje w zaznaczonym kontekście. Jeśli konwersja występuje w nieznakowanym kontekście (wartość domyślna w języku C#), operacja konwersji powiedzie się, ale wartość przepełnia się.
Decimal	Wyjątek OverflowException ,

Ponadto Single.NaN, Single.PositiveInfinityi Single.NegativeInfinity zgłasza OverflowException konwersje na liczby całkowite w zaznaczonym kontekście, ale te wartości przepełniają się po przekonwertowaniu na liczby całkowite w nieznakowanym kontekście. W przypadku konwersji na Decimalelement zawsze zgłaszają wartość OverflowException. W przypadku konwersji na Double, konwertują odpowiednio na Double.NaN, Double.PositiveInfinityi Double.NegativeInfinity.

Należy pamiętać, że utrata dokładności może wynikać z konwersji Single wartości na inny typ liczbowy. W przypadku konwertowania wartości innych niż całkowite Single , jak wynika z danych wyjściowych z przykładu, składnik ułamek zostaje utracony, gdy Single wartość jest zaokrąglona (jak w Visual Basic) lub obcięta (jak w języku C# i F#). W przypadku konwersji na Decimal wartości Single wartość może nie mieć dokładnej reprezentacji w docelowym typie danych.

Poniższy przykład konwertuje liczbę Single wartości na kilka innych typów liczbowych. Konwersje występują w zaznaczonym kontekście w Visual Basic (wartość domyślna), w języku C# (ze względu na zaznaczone słowo kluczowe) i w języku F# (ze względu na instrukcję open Checked ). Dane wyjściowe z przykładu pokazują wynik konwersji w obu zaznaczonych kontekstach. Konwersje można wykonać w nieznakowanym kontekście w języku Visual Basic, kompilując /removeintchecks+ za pomocą przełącznika kompilatora w języku C#, komentując instrukcję i w języku F#, komentując checked instrukcję open Checked .

using System;

public class Example5
{
    public static void Main()
    {
        float[] values = { Single.MinValue, -67890.1234f, -12345.6789f,
                         12345.6789f, 67890.1234f, Single.MaxValue,
                         Single.NaN, Single.PositiveInfinity,
                         Single.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);
                }

                Double dblValue = value;
                Console.WriteLine("{0} ({1}) --> {2} ({3})",
                                  value, value.GetType().Name,
                                  dblValue, dblValue.GetType().Name);
                Console.WriteLine();
            }
        }
    }
}
// The example displays the following output for conversions performed
// in a checked context:
//       Unable to convert -3.402823E+38 to Int64.
//       Unable to convert -3.402823E+38 to UInt64.
//       Unable to convert -3.402823E+38 to Decimal.
//       -3.402823E+38 (Single) --> -3.40282346638529E+38 (Double)
//
//       -67890.13 (Single) --> -67890 (0xFFFFFFFFFFFEF6CE) (Int64)
//       Unable to convert -67890.13 to UInt64.
//       -67890.13 (Single) --> -67890.12 (Decimal)
//       -67890.13 (Single) --> -67890.125 (Double)
//
//       -12345.68 (Single) --> -12345 (0xFFFFFFFFFFFFCFC7) (Int64)
//       Unable to convert -12345.68 to UInt64.
//       -12345.68 (Single) --> -12345.68 (Decimal)
//       -12345.68 (Single) --> -12345.6787109375 (Double)
//
//       12345.68 (Single) --> 12345 (0x0000000000003039) (Int64)
//       12345.68 (Single) --> 12345 (0x0000000000003039) (UInt64)
//       12345.68 (Single) --> 12345.68 (Decimal)
//       12345.68 (Single) --> 12345.6787109375 (Double)
//
//       67890.13 (Single) --> 67890 (0x0000000000010932) (Int64)
//       67890.13 (Single) --> 67890 (0x0000000000010932) (UInt64)
//       67890.13 (Single) --> 67890.12 (Decimal)
//       67890.13 (Single) --> 67890.125 (Double)
//
//       Unable to convert 3.402823E+38 to Int64.
//       Unable to convert 3.402823E+38 to UInt64.
//       Unable to convert 3.402823E+38 to Decimal.
//       3.402823E+38 (Single) --> 3.40282346638529E+38 (Double)
//
//       Unable to convert NaN to Int64.
//       Unable to convert NaN to UInt64.
//       Unable to convert NaN to Decimal.
//       NaN (Single) --> NaN (Double)
//
//       Unable to convert Infinity to Int64.
//       Unable to convert Infinity to UInt64.
//       Unable to convert Infinity to Decimal.
//       Infinity (Single) --> Infinity (Double)
//
//       Unable to convert -Infinity to Int64.
//       Unable to convert -Infinity to UInt64.
//       Unable to convert -Infinity to Decimal.
//       -Infinity (Single) --> -Infinity (Double)
// The example displays the following output for conversions performed
// in an unchecked context:
//       -3.402823E+38 (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       -3.402823E+38 (Single) --> 9223372036854775808 (0x8000000000000000) (UInt64)
//       Unable to convert -3.402823E+38 to Decimal.
//       -3.402823E+38 (Single) --> -3.40282346638529E+38 (Double)
//
//       -67890.13 (Single) --> -67890 (0xFFFFFFFFFFFEF6CE) (Int64)
//       -67890.13 (Single) --> 18446744073709483726 (0xFFFFFFFFFFFEF6CE) (UInt64)
//       -67890.13 (Single) --> -67890.12 (Decimal)
//       -67890.13 (Single) --> -67890.125 (Double)
//
//       -12345.68 (Single) --> -12345 (0xFFFFFFFFFFFFCFC7) (Int64)
//       -12345.68 (Single) --> 18446744073709539271 (0xFFFFFFFFFFFFCFC7) (UInt64)
//       -12345.68 (Single) --> -12345.68 (Decimal)
//       -12345.68 (Single) --> -12345.6787109375 (Double)
//
//       12345.68 (Single) --> 12345 (0x0000000000003039) (Int64)
//       12345.68 (Single) --> 12345 (0x0000000000003039) (UInt64)
//       12345.68 (Single) --> 12345.68 (Decimal)
//       12345.68 (Single) --> 12345.6787109375 (Double)
//
//       67890.13 (Single) --> 67890 (0x0000000000010932) (Int64)
//       67890.13 (Single) --> 67890 (0x0000000000010932) (UInt64)
//       67890.13 (Single) --> 67890.12 (Decimal)
//       67890.13 (Single) --> 67890.125 (Double)
//
//       3.402823E+38 (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       3.402823E+38 (Single) --> 0 (0x0000000000000000) (UInt64)
//       Unable to convert 3.402823E+38 to Decimal.
//       3.402823E+38 (Single) --> 3.40282346638529E+38 (Double)
//
//       NaN (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       NaN (Single) --> 0 (0x0000000000000000) (UInt64)
//       Unable to convert NaN to Decimal.
//       NaN (Single) --> NaN (Double)
//
//       Infinity (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       Infinity (Single) --> 0 (0x0000000000000000) (UInt64)
//       Unable to convert Infinity to Decimal.
//       Infinity (Single) --> Infinity (Double)
//
//       -Infinity (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       -Infinity (Single) --> 9223372036854775808 (0x8000000000000000) (UInt64)
//       Unable to convert -Infinity to Decimal.
//       -Infinity (Single) --> -Infinity (Double)

open System
open Checked

let values = 
    [ Single.MinValue; -67890.1234f; -12345.6789f
      12345.6789f; 67890.1234f; Single.MaxValue
      Single.NaN; Single.PositiveInfinity
      Single.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."

    let dblValue = double value
    printfn $"{value} ({value.GetType().Name}) --> {dblValue} ({dblValue.GetType().Name})\n"
// The example displays the following output for conversions performed
// in a checked context:
//       Unable to convert -3.402823E+38 to Int64.
//       Unable to convert -3.402823E+38 to UInt64.
//       Unable to convert -3.402823E+38 to Decimal.
//       -3.402823E+38 (Single) --> -3.40282346638529E+38 (Double)
//
//       -67890.13 (Single) --> -67890 (0xFFFFFFFFFFFEF6CE) (Int64)
//       Unable to convert -67890.13 to UInt64.
//       -67890.13 (Single) --> -67890.12 (Decimal)
//       -67890.13 (Single) --> -67890.125 (Double)
//
//       -12345.68 (Single) --> -12345 (0xFFFFFFFFFFFFCFC7) (Int64)
//       Unable to convert -12345.68 to UInt64.
//       -12345.68 (Single) --> -12345.68 (Decimal)
//       -12345.68 (Single) --> -12345.6787109375 (Double)
//
//       12345.68 (Single) --> 12345 (0x0000000000003039) (Int64)
//       12345.68 (Single) --> 12345 (0x0000000000003039) (UInt64)
//       12345.68 (Single) --> 12345.68 (Decimal)
//       12345.68 (Single) --> 12345.6787109375 (Double)
//
//       67890.13 (Single) --> 67890 (0x0000000000010932) (Int64)
//       67890.13 (Single) --> 67890 (0x0000000000010932) (UInt64)
//       67890.13 (Single) --> 67890.12 (Decimal)
//       67890.13 (Single) --> 67890.125 (Double)
//
//       Unable to convert 3.402823E+38 to Int64.
//       Unable to convert 3.402823E+38 to UInt64.
//       Unable to convert 3.402823E+38 to Decimal.
//       3.402823E+38 (Single) --> 3.40282346638529E+38 (Double)
//
//       Unable to convert NaN to Int64.
//       Unable to convert NaN to UInt64.
//       Unable to convert NaN to Decimal.
//       NaN (Single) --> NaN (Double)
//
//       Unable to convert Infinity to Int64.
//       Unable to convert Infinity to UInt64.
//       Unable to convert Infinity to Decimal.
//       Infinity (Single) --> Infinity (Double)
//
//       Unable to convert -Infinity to Int64.
//       Unable to convert -Infinity to UInt64.
//       Unable to convert -Infinity to Decimal.
//       -Infinity (Single) --> -Infinity (Double)
// The example displays the following output for conversions performed
// in an unchecked context:
//       -3.402823E+38 (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       -3.402823E+38 (Single) --> 9223372036854775808 (0x8000000000000000) (UInt64)
//       Unable to convert -3.402823E+38 to Decimal.
//       -3.402823E+38 (Single) --> -3.40282346638529E+38 (Double)
//
//       -67890.13 (Single) --> -67890 (0xFFFFFFFFFFFEF6CE) (Int64)
//       -67890.13 (Single) --> 18446744073709483726 (0xFFFFFFFFFFFEF6CE) (UInt64)
//       -67890.13 (Single) --> -67890.12 (Decimal)
//       -67890.13 (Single) --> -67890.125 (Double)
//
//       -12345.68 (Single) --> -12345 (0xFFFFFFFFFFFFCFC7) (Int64)
//       -12345.68 (Single) --> 18446744073709539271 (0xFFFFFFFFFFFFCFC7) (UInt64)
//       -12345.68 (Single) --> -12345.68 (Decimal)
//       -12345.68 (Single) --> -12345.6787109375 (Double)
//
//       12345.68 (Single) --> 12345 (0x0000000000003039) (Int64)
//       12345.68 (Single) --> 12345 (0x0000000000003039) (UInt64)
//       12345.68 (Single) --> 12345.68 (Decimal)
//       12345.68 (Single) --> 12345.6787109375 (Double)
//
//       67890.13 (Single) --> 67890 (0x0000000000010932) (Int64)
//       67890.13 (Single) --> 67890 (0x0000000000010932) (UInt64)
//       67890.13 (Single) --> 67890.12 (Decimal)
//       67890.13 (Single) --> 67890.125 (Double)
//
//       3.402823E+38 (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       3.402823E+38 (Single) --> 0 (0x0000000000000000) (UInt64)
//       Unable to convert 3.402823E+38 to Decimal.
//       3.402823E+38 (Single) --> 3.40282346638529E+38 (Double)
//
//       NaN (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       NaN (Single) --> 0 (0x0000000000000000) (UInt64)
//       Unable to convert NaN to Decimal.
//       NaN (Single) --> NaN (Double)
//
//       Infinity (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       Infinity (Single) --> 0 (0x0000000000000000) (UInt64)
//       Unable to convert Infinity to Decimal.
//       Infinity (Single) --> Infinity (Double)
//
//       -Infinity (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       -Infinity (Single) --> 9223372036854775808 (0x8000000000000000) (UInt64)
//       Unable to convert -Infinity to Decimal.
//       -Infinity (Single) --> -Infinity (Double)

Module Example6
    Public Sub Main()
        Dim values() As Single = {Single.MinValue, -67890.1234, -12345.6789,
                                 12345.6789, 67890.1234, Single.MaxValue,
                                 Single.NaN, Single.PositiveInfinity,
                                 Single.NegativeInfinity}
        For Each value In values
            Try
                Dim lValue As Long = 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

            Dim dblValue As Double = value
            Console.WriteLine("{0} ({1}) --> {2} ({3})",
                           value, value.GetType().Name,
                           dblValue, dblValue.GetType().Name)
            Console.WriteLine()
        Next
    End Sub
End Module
' The example displays the following output for conversions performed
' in a checked context:
'       Unable to convert -3.402823E+38 to Int64.
'       Unable to convert -3.402823E+38 to UInt64.
'       Unable to convert -3.402823E+38 to Decimal.
'       -3.402823E+38 (Single) --> -3.40282346638529E+38 (Double)
'
'       -67890.13 (Single) --> -67890 (0xFFFFFFFFFFFEF6CE) (Int64)
'       Unable to convert -67890.13 to UInt64.
'       -67890.13 (Single) --> -67890.12 (Decimal)
'       -67890.13 (Single) --> -67890.125 (Double)
'
'       -12345.68 (Single) --> -12346 (0xFFFFFFFFFFFFCFC6) (Int64)
'       Unable to convert -12345.68 to UInt64.
'       -12345.68 (Single) --> -12345.68 (Decimal)
'       -12345.68 (Single) --> -12345.6787109375 (Double)
'
'       12345.68 (Single) --> 12346 (0x000000000000303A) (Int64)
'       12345.68 (Single) --> 12346 (0x000000000000303A) (UInt64)
'       12345.68 (Single) --> 12345.68 (Decimal)
'       12345.68 (Single) --> 12345.6787109375 (Double)
'
'       67890.13 (Single) --> 67890 (0x0000000000010932) (Int64)
'       67890.13 (Single) --> 67890 (0x0000000000010932) (UInt64)
'       67890.13 (Single) --> 67890.12 (Decimal)
'       67890.13 (Single) --> 67890.125 (Double)
'
'       Unable to convert 3.402823E+38 to Int64.
'       Unable to convert 3.402823E+38 to UInt64.
'       Unable to convert 3.402823E+38 to Decimal.
'       3.402823E+38 (Single) --> 3.40282346638529E+38 (Double)
'
'       Unable to convert NaN to Int64.
'       Unable to convert NaN to UInt64.
'       Unable to convert NaN to Decimal.
'       NaN (Single) --> NaN (Double)
'
'       Unable to convert Infinity to Int64.
'       Unable to convert Infinity to UInt64.
'       Unable to convert Infinity to Decimal.
'       Infinity (Single) --> Infinity (Double)
'
'       Unable to convert -Infinity to Int64.
'       Unable to convert -Infinity to UInt64.
'       Unable to convert -Infinity to Decimal.
'       -Infinity (Single) --> -Infinity (Double)
' The example displays the following output for conversions performed
' in an unchecked context:
'       -3.402823E+38 (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
'       -3.402823E+38 (Single) --> 9223372036854775808 (0x8000000000000000) (UInt64)
'       Unable to convert -3.402823E+38 to Decimal.
'       -3.402823E+38 (Single) --> -3.40282346638529E+38 (Double)
'
'       -67890.13 (Single) --> -67890 (0xFFFFFFFFFFFEF6CE) (Int64)
'       -67890.13 (Single) --> 18446744073709483726 (0xFFFFFFFFFFFEF6CE) (UInt64)
'       -67890.13 (Single) --> -67890.12 (Decimal)
'       -67890.13 (Single) --> -67890.125 (Double)
'
'       -12345.68 (Single) --> -12346 (0xFFFFFFFFFFFFCFC6) (Int64)
'       -12345.68 (Single) --> 18446744073709539270 (0xFFFFFFFFFFFFCFC6) (UInt64)
'       -12345.68 (Single) --> -12345.68 (Decimal)
'       -12345.68 (Single) --> -12345.6787109375 (Double)
'
'       12345.68 (Single) --> 12346 (0x000000000000303A) (Int64)
'       12345.68 (Single) --> 12346 (0x000000000000303A) (UInt64)
'       12345.68 (Single) --> 12345.68 (Decimal)
'       12345.68 (Single) --> 12345.6787109375 (Double)
'
'       67890.13 (Single) --> 67890 (0x0000000000010932) (Int64)
'       67890.13 (Single) --> 67890 (0x0000000000010932) (UInt64)
'       67890.13 (Single) --> 67890.12 (Decimal)
'       67890.13 (Single) --> 67890.125 (Double)
'
'       3.402823E+38 (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
'       3.402823E+38 (Single) --> 0 (0x0000000000000000) (UInt64)
'       Unable to convert 3.402823E+38 to Decimal.
'       3.402823E+38 (Single) --> 3.40282346638529E+38 (Double)
'
'       NaN (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
'       NaN (Single) --> 0 (0x0000000000000000) (UInt64)
'       Unable to convert NaN to Decimal.
'       NaN (Single) --> NaN (Double)
'
'       Infinity (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
'       Infinity (Single) --> 0 (0x0000000000000000) (UInt64)
'       Unable to convert Infinity to Decimal.
'       Infinity (Single) --> Infinity (Double)
'
'       -Infinity (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
'       -Infinity (Single) --> 9223372036854775808 (0x8000000000000000) (UInt64)
'       Unable to convert -Infinity to Decimal.
'       -Infinity (Single) --> -Infinity (Double)

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

Funkcje zmiennoprzecinkowe

Struktura Single i powiązane typy udostępniają metody wykonywania następujących kategorii operacji:

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

  Struktura Single obsługuje również kompletny zestaw operatorów porównania. Można na przykład przetestować równość lub nierówności albo określić, czy jedna wartość jest większa niż lub równa innej wartości. Jeśli jeden z operandów to Double, Single wartość jest konwertowana na wartość przed Double wykonaniem porównania. Jeśli jeden z operandów jest typem całkowitym, jest konwertowany na element Single przed wykonaniem porównania. Chociaż są to konwersje rozszerzające, mogą one obejmować utratę precyzji.

  Ostrzeżenie

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

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

• Operacje matematyczne. Typowe operacje arytmetyczne, takie jak dodawanie, odejmowanie, mnożenie i dzielenie, są implementowane przez kompilatory języka i instrukcje języka wspólnego języka pośredniego (CIL), a nie przez Single metody. Jeśli drugi operand w operacji matematycznej to Double, Single element jest konwertowany na element Double przed wykonaniem operacji, a wynik operacji jest również wartością Double . Jeśli drugi operand jest typem całkowitym, jest konwertowany na wartość Single przed wykonaniem operacji, a wynik operacji jest również wartością Single .

  Inne operacje matematyczne można wykonywać, wywołując static metody (Shared w Visual Basic) w System.Math klasie . Obejmują one dodatkowe metody powszechnie stosowane do arytmetyki (takich jak , Math.Signi ), geometrii (takich jak Math.CosMath.Absi Math.SqrtMath.Sin) i rachunku (na przykład ).Math.Log We wszystkich przypadkach Single wartość jest konwertowana na Doublewartość .

  Można również manipulować poszczególnymi bitami w Single wartości. Metoda BitConverter.GetBytes(Single) zwraca wzorzec bitowy w tablicy bajtów. Przekazując tę tablicę bajtów do BitConverter.ToInt32 metody, można również zachować Single wzorzec bitów wartości w 32-bitowej liczbą całkowitą.

• Zaokrąglanie. Zaokrąglanie jest często używane jako technika zmniejszania wpływu różnic między wartościami spowodowanymi problemami z reprezentacją zmiennoprzecinkową i precyzją. Wartość można zaokrąglić Single , wywołując metodę Math.Round . Należy jednak pamiętać, że Single wartość jest konwertowana na wartość Double przed wywołaną metodą, a konwersja może obejmować utratę precyzji.

• Formatowanie. Wartość można przekonwertować na reprezentację Single ciągu, wywołując metodę ToString lub używając funkcji formatowania złożonego. Aby uzyskać informacje na temat sposobu kontrolowania ciągów reprezentujących wartości zmiennoprzecinkowe, zobacz standardowe ciągi formatu liczbowego i niestandardowe ciągi formatu liczbowego.

• Analizowanie ciągów. Reprezentację ciągu wartości zmiennoprzecinkowej można przekonwertować na wartość, wywołując Parse metodę Single orTryParse. Jeśli operacja analizy nie powiedzie się, Parse metoda zgłasza wyjątek, podczas gdy TryParse metoda zwraca falsewartość .

• Konwersja typu. Struktura Single zapewnia jawną implementację interfejsu dla interfejsu IConvertible , która obsługuje konwersję między dwoma standardowymi typami danych platformy .NET. Kompilatory języka obsługują również niejawną konwersję wartości dla wszystkich innych standardowych typów liczbowych z wyjątkiem konwersji Double na Single wartości. Konwersja wartości dowolnego standardowego typu liczbowego innego niż na element DoubleSingle jest konwersją rozszerzającą i nie wymaga użycia operatora rzutowania ani metody konwersji.

  Jednak konwersja wartości 32-bitowych i 64-bitowych liczb całkowitych może obejmować utratę dokładności. W poniższej tabeli wymieniono różnice w precyzji dla 32-bitowych, 64-bitowych i Double typów:

  Typ	Maksymalna precyzja (w cyfrach dziesiętnych)	Precyzja wewnętrzna (w cyfrach dziesiętnych)
  Double	15	17
  Int32 i UInt32	10	10
  Int64 i UInt64	19	19
  Single	7	9

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

  using System;
  
  public class Example8
  {
      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
  

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