Single Struktura

Definice

Představuje číslo s plovoucí desetinnou čárkou s jednoduchou přesností.

public value class float : IComparable, IComparable<float>, IConvertible, IEquatable<float>, IFormattable
public value class float : IComparable, IComparable<float>, IConvertible, IEquatable<float>, ISpanFormattable
public value class float : IComparable, IConvertible, IFormattable
public value class float : IComparable, IComparable<float>, IEquatable<float>, IFormattable
public struct Single : IComparable, IComparable<float>, IConvertible, IEquatable<float>, IFormattable
public struct Single : IComparable, IComparable<float>, IConvertible, IEquatable<float>, ISpanFormattable
[System.Serializable]
public struct Single : IComparable, IConvertible, IFormattable
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public struct Single : IComparable, IComparable<float>, IConvertible, IEquatable<float>, IFormattable
public struct Single : IComparable, IComparable<float>, IEquatable<float>, IFormattable
type single = struct
    interface IConvertible
    interface IFormattable
type single = struct
    interface IConvertible
    interface ISpanFormattable
    interface IFormattable
[<System.Serializable>]
type single = struct
    interface IFormattable
    interface IConvertible
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type single = struct
    interface IFormattable
    interface IConvertible
type single = struct
    interface IFormattable
Public Structure Single
Implements IComparable, IComparable(Of Single), IConvertible, IEquatable(Of Single), IFormattable
Public Structure Single
Implements IComparable, IComparable(Of Single), IConvertible, IEquatable(Of Single), ISpanFormattable
Public Structure Single
Implements IComparable, IConvertible, IFormattable
Public Structure Single
Implements IComparable, IComparable(Of Single), IEquatable(Of Single), IFormattable
Dědičnost
Single
Atributy
Implementuje

Poznámky

SingleTyp hodnoty představuje 32 číslo s jednou přesností s hodnotami od záporného 3.402823 E38 po kladné 3.402823 E38, stejně jako kladné nebo záporné nuly, PositiveInfinity , NegativeInfinity a nikoliv číslo ( NaN ). Má představovat hodnoty, které jsou extrémně velké (například vzdálenost mezi Planet nebo Galaxies) nebo extrémně malý (například molekulová hmotnost látky v kilogramech) a často jsou nepřesné (například vzdálenost od země – do jiného slunečního systému). SingleTyp odpovídá standardu IEC 60559:1989 (IEEE 754) pro binární aritmetické operace s plovoucí desetinnou čárkou.

Tento článek se skládá z následujících částí:

System.Single poskytuje metody pro porovnání instancí tohoto typu, pro převod hodnoty instance na jeho řetězcovou reprezentaci a pro převod řetězcové reprezentace čísla na instanci tohoto typu. Informace o tom, jak kódy specifikace formátu řídí řetězcovou reprezentaci hodnotových typů, naleznete v tématu typy formátování, řetězce standardního číselného formátua vlastní číselné formátovací řetězce.

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

SingleDatový typ ukládá hodnoty s plovoucí desetinnou čárkou s jednoduchou přesností do 32 binárního binárního formátu, jak je znázorněno v následující tabulce:

Část Bity
Mantisa nebo mantisa 0-22
Mocnina 23-30
Sign (0 = kladné, 1 = negativní) 31

Stejně jako desítkové zlomky nemůžou přesně představovat některé desetinné hodnoty (například 1/3 nebo Math.PI ), binární zlomky nemůžou představovat některé desetinné hodnoty. Například 2/10, který je reprezentován přesně .2 jako desítkový zlomek, je reprezentována. 0011111001001100 jako binární zlomek se vzorem "1100" se opakuje na nekonečno. V tomto případě hodnota s plovoucí desetinnou čárkou poskytuje nepřesný reprezentace čísla, které představuje. Provádění dalších matematických operací na původní hodnotě s plovoucí desetinnou čárkou často zvyšuje nedostatečnou přesnost. Například pokud porovnáte výsledky vynásobení .3 hodnotou 10 a přidáním .3 do. 3 9 časů, uvidíte, že sčítání tvoří méně přesný výsledek, protože zahrnuje osm dalších operací, než násobení. Všimněte si, že tato neparita je zjevné pouze v případě, že zobrazíte dvě Single hodnoty pomocí řetězce standardního číselného formátu"R", který v případě potřeby zobrazí všechny 9 číslic přesnosti podporované Single typem.

using System;

public class Example
{
   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
Module Example
   Public Sub Main()
      Dim value As Single = .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

Vzhledem k tomu, že některá čísla nelze přesně reprezentovat jako zlomkové binární hodnoty, čísla s plovoucí desetinnou čárkou mohou být pouze přibližná reálné číslice.

Všechna čísla s plovoucí desetinnou čárkou mají omezený počet platných číslic, což také určuje, jak přesně je hodnota s plovoucí desetinnou čárkou přibližně reálné číslo. SingleHodnota má až 7 desítkových číslic, i když je interní uchováváno maximálně 9 číslic. To znamená, že některé operace s plovoucí desetinnou čárkou nemusí mít přesnost na změnu hodnoty s plovoucí desetinnou čárkou. Následující příklad definuje značnou hodnotu s jednoduchou přesností a potom přidá produkt Single.Epsilon a jeden quadrillion do něj. Produkt je však pro úpravu původní hodnoty s plovoucí desetinnou čárkou příliš malý. Jeho nejméně významnou číslicí je sekundy, zatímco nejvýznamnější číslice v produktu je 10– 30.

using System;

public class Example
{
   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
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

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

  • Dvě čísla s plovoucí desetinnou čárkou, která se zobrazují stejně jako konkrétní přesnost, nemusí být porovnána, protože jejich nejméně významné číslice se liší. V následujícím příkladu jsou společně přidány řady čísel a jejich celková hodnota je porovnána s očekávaným součtem. I když se tyto dvě hodnoty zdají být stejné, volání Equals metody označuje, že nejsou.

    using System;
    
    public class Example
    {
       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).
    
    Module Example
       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).
    

    Pokud změníte položky formátu v Console.WriteLine(String, Object, Object) příkazu z {0} a {1} na {0:R} a {1:R} zobrazíte všechny významné číslice dvou Single hodnot, je zřejmé, že tyto dvě hodnoty jsou nerovné, protože došlo ke ztrátě přesnosti během operací sčítání. V takovém případě může být problém vyřešen voláním Math.Round(Double, Int32) metody pro zaokrouhlení Single hodnot na požadovanou přesnost před provedením porovnání.

  • Operace matematického nebo porovnání, která používá číslo s plovoucí desetinnou čárkou, nemusí vracet stejný výsledek, pokud je použit desítkové číslo, protože binární číslo s plovoucí desetinnou čárkou se nemusí rovnat desítkovým číslům. Předchozí příklad ukazuje to zobrazením výsledku násobení .3 hodnotou 10 a přidáním .3 do. 3 9 časů.

    Je-li hodnota přesnosti v numerických operacích s hodnotami zlomků důležitá, použijte Decimal typ místo Single typu. Je-li hodnota přesnosti v numerických operacích s celočíselnými hodnotami nad rozsahem Int64 nebo UInt64 typy nebo je důležitá, použijte BigInteger typ.

  • Hodnota nemusí být v případě, že je zapojeno číslo s plovoucí desetinnou čárkou, nesmí být v přenosu. Hodnota se říká zpátečnímu přenosu, pokud operace převede původní číslo s plovoucí desetinnou čárkou na jiný formulář, inverzní operace transformuje převedený formulář zpět na číslo s plovoucí desetinnou čárkou a konečné číslo s plovoucí desetinnou čárkou je rovno původnímu číslu s plovoucí desetinnou čárkou. Zpoždění odezvy může selhat, protože při převodu dojde ke ztrátě nebo změně nejméně významných číslic. V následujícím příkladu Single jsou tři hodnoty převedeny na řetězce a uloženy v souboru. Jak ukazuje výstup, Přestože hodnoty vypadají jako identické, obnovené hodnoty se neshodují s původními hodnotami.

    using System;
    using System.IO;
    
    public class Example
    {
       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
    
    Imports System.IO
    
    Module Example
       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
    

    V tomto případě lze hodnoty úspěšně zaokrouhlit na Trip pomocí standardního číselného formátovacího řetězce "G9", který zachová úplnou přesnost Single hodnot, jak ukazuje následující příklad.

    using System;
    using System.IO;
    
    public class Example
    {
       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
    
    Imports System.IO
    
    Module Example
       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 hodnoty mají méně přesnosti než Double hodnoty. SingleHodnota, která je převedena na zdánlivý ekvivalent Double často, se nerovná Double hodnotě z důvodu rozdílů v přesnosti. V následujícím příkladu je výsledek identických operací dělení přiřazen k Double hodnotě a Single hodnotě. Po Single přetypování hodnoty na Double , porovnání dvou hodnot ukazuje, že jsou nerovné.

    using System;
    
    public class Example
    {
       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
    
    Module Example
       Public Sub Main()
          Dim value1 As Double = 1/3
          Dim sValue2 As Single = 1/3
          Dim value2 As Double = CDbl(sValue2)
          Console.WriteLine("{0} = {1}: {2}", value1, value2, value1.Equals(value2))
       End Sub
    End Module
    ' The example displays the following output:
    '       0.33333333333333331 = 0.3333333432674408: False
    

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

Testování rovnosti

Aby se dalo považovat za stejné, dvě Single hodnoty musí představovat stejné hodnoty. Kvůli rozdílům v přesnosti mezi hodnotami nebo z důvodu ztráty přesnosti podle jedné nebo obou hodnot jsou hodnoty s plovoucí desetinnou čárkou, které se očekávají jako identické, často neshodné kvůli rozdílům v jejich nejméně platných číslicích. V důsledku toho volání Equals metody určí, zda jsou dvě hodnoty stejné, nebo volání CompareTo metody pro určení vztahu mezi dvěma Single hodnotami, často poskytují neočekávané výsledky. V následujícím příkladu je zřejmé, že dvě zjevně rovné Single hodnoty se neshodují, protože první hodnota má 7 číslic přesnosti, zatímco druhá hodnota je 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
Module Example
   Public Sub Main()
      Dim value1 As Single = .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

Počítané hodnoty, které následují za různými cestami kódu a které jsou manipulovány různými způsoby, se často jeví jako nerovné. V následujícím příkladu Single je jedna hodnota čtvercová a druhá odmocnina je vypočítána k obnovení původní hodnoty. Druhá Single je vynásobena 3,51 a druhá mocnina před druhou odmocninou výsledku je vydělena 3,51em k obnovení původní hodnoty. I když se tyto dvě hodnoty zdají být identické, volání Equals(Single) metody označuje, že se neshodují. Použití standardního formátovacího řetězce "G9" k vrácení výsledného řetězce, který zobrazí všechny významné číslice každé Single hodnoty, ukazuje, že druhá hodnota je .0000000000001 menší než první.

using System;

public class Example
{
   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
Module Example
   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

V případech, kdy je pravděpodobnost ztráty přesnosti pravděpodobně ovlivněna výsledkem porovnání, lze použít následující techniky namísto volání Equals CompareTo metody nebo:

  • Zavolejte metodu, aby se Math.Round zajistilo, že obě hodnoty mají stejnou přesnost. Následující příklad upravuje předchozí příklad pro použití tohoto přístupu, takže dvě zlomkové hodnoty jsou ekvivalentní.

    using System;
    
    public class Example
    {
       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
    
    Module Example
       Public Sub Main()
          Dim value1 As Single = .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
    

    Problém přesnosti stále platí pro zaokrouhlení hodnot středního bodu. Další informace naleznete v Math.Round(Double, Int32, MidpointRounding) metodě.

  • Testujte přibližnou rovnost namísto rovnosti. Tato metoda vyžaduje, abyste definovali absolutní hodnotu, o kterou se tyto dvě hodnoty mohou lišit, ale stále se rovnají nebo že definujete relativní hodnotu, o kterou se menší hodnota může odchýlit od větší hodnoty.

    Upozornění

    Single.Epsilon se někdy používá jako absolutní míra vzdálenosti mezi dvěma Single hodnotami při testování rovnosti. Měří však Single.Epsilon nejmenší možnou hodnotu, která může být přidána do nebo odečtena od, a Single jejíž hodnota je nula. Pro většinu kladných a záporných Single hodnot hodnota Single.Epsilon je příliš malá, aby ji bylo možné zjistit. Proto s výjimkou hodnot, které jsou nulové, nedoporučujeme použití v testech pro rovnost.

    V následujícím příkladu je použit druhý přístup k definování IsApproximatelyEqual metody, která testuje relativní rozdíl mezi dvěma hodnotami. Také na rozdíl od výsledku volání IsApproximatelyEqual metody a Equals(Single) metody.

    using System;
    
    public class Example
    {
       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
    
    Module Example
       Public Sub Main()
          Dim one1 As Single = .1 * 10
          Dim one2 As Single = 0
          For ctr As Integer = 1 To 10
             one2 += CSng(.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, .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)
          Else If Single.IsInfinity(value2) Or Single.IsNaN(value2)
             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
    

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

Operace s hodnotami s plovoucí desetinnou čárkou nevyvolává výjimky, na rozdíl od operací s celočíselnými typy, které vyvolávají výjimky v případech neplatných operací, jako je dělení nulou nebo přetečení. Místo toho jsou v těchto situacích výsledkem operace s plovoucí desetinnou čárkou nula, kladné nekonečno, záporné nekonečno nebo nečíselné (NaN):

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

    using System;
    
    public class Example
    {
       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
    
    Module Example
       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
    
  • Pokud velikost výsledku operace s plovoucí desetinnou čárkou přesáhne rozsah cílového formátu, výsledek operace je PositiveInfinity nebo NegativeInfinity , podle potřeby pro znaménko výsledku. Výsledek operace, která přetéká Single.MaxValue PositiveInfinity , a výsledek operace, která přetéká Single.MinValue je NegativeInfinity , jak ukazuje následující příklad.

    using System;
    
    public class Example
    {
       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
    
    Module Example
       Public Sub Main()
          Dim value1 As Single = 3.065e35
          Dim value2 As Single = 6.9375e32
          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 také je výsledkem dělení nulou s kladným dividendem a NegativeInfinity výsledkem dělení nulou se záporným dividendem.

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

    • Dělení nulou s dividendou nula. Všimněte si, že jiné případy dělení nulou v buď PositiveInfinity nebo NegativeInfinity .

    • Jakákoli operace s plovoucí desetinnou čárkou s neplatným vstupem. Například pokus o nalezení druhé odmocniny záporné hodnoty vrátí NaN .

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

Převody typů a jedna struktura

SingleStruktura nedefinuje žádné explicitní ani implicitní operátory převodu. místo toho jsou převody implementovány kompilátorem.

Následující tabulka uvádí možné převody hodnoty jiných primitivních číselných typů na Single hodnotu, také označuje, zda je převod rozšířen nebo zúžený a zda výsledný výsledek Single může být menší, než původní hodnota.

Převod z Rozšiřování a zúžení Možná ztráta přesnosti
Byte Rozšíření No
Decimal Rozšíření

Všimněte si, že jazyk C# vyžaduje operátor přetypování.
Ano. Decimal podporuje 29 desítkových číslic přesnosti; Single podporuje 9.
Double Zužující hodnoty mimo rozsah jsou převedeny na Double.NegativeInfinity nebo Double.PositiveInfinity . Ano. Double podporuje 17 desítkových číslic přesnosti; Single podporuje 9.
Int16 Rozšíření No
Int32 Rozšíření Ano. Int32 podporuje 10 desítkových číslic přesnosti; Single podporuje 9.
Int64 Rozšíření Ano. Int64 podporuje 19 desítkových číslic přesnosti; Single podporuje 9.
SByte Rozšíření No
UInt16 Rozšíření No
UInt32 Rozšíření Ano. UInt32 podporuje 10 desítkových číslic přesnosti; Single podporuje 9.
UInt64 Rozšíření Ano. Int64 podporuje 20 desítkových číslic přesnosti; Single podporuje 9.

Následující příklad převede minimální nebo maximální hodnotu ostatních primitivních číselných typů na Single hodnotu.

using System;

public class Example
{
   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)
Module Example
   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)

Kromě toho Double hodnoty Double.NaN , Double.PositiveInfinity a Double.NegativeInfinity převeďte na Single.NaN , Single.PositiveInfinity , a v Single.NegativeInfinity uvedeném pořadí.

Všimněte si, že převod hodnoty některých číselných typů na Single hodnotu může zahrnovat ztrátu přesnosti. Jak ukazuje příklad, může dojít ke ztrátě přesnosti při převodu hodnot,,,, Decimal Double Int32 Int64 UInt32 a UInt64 hodnot na Single hodnoty.

Konverze Single hodnoty na Double je rozšiřující převod. Převod může způsobit ztrátu přesnosti, pokud Double typ nemá přesnou reprezentaci Single hodnoty.

Konverze Single hodnoty na hodnotu libovolného primitivního číselného datového typu jiného než Double je zužující převod a vyžaduje operátor přetypování (v jazyce C#) nebo metodu převodu (v Visual Basic). Hodnoty, které jsou mimo rozsah cílového datového typu, které jsou definovány MinValue vlastnostmi a vlastnostmi cílového typu MaxValue , se chovají, jak je uvedeno v následující tabulce.

Cílový typ Výsledek
Libovolný celočíselný typ OverflowExceptionVýjimka v případě, že dojde k převodu v kontrolovaném kontextu.

Pokud se převod vyskytne v nekontrolovaném kontextu (ve výchozím nastavení v jazyce C#), operace převodu bude úspěšná, ale hodnota přetéká.
Decimal OverflowExceptionVýjimka,

Kromě toho, Single.NaN , Single.PositiveInfinity a Single.NegativeInfinity vyvolejte OverflowException pro převody na celá čísla v kontrolovaném kontextu, ale přetečení těchto hodnot při převodu na celá čísla v nekontrolovaném kontextu. Pro převody na Decimal , vždy vyvolají OverflowException . Pro převody na, Double jsou převedeny na Double.NaN , Double.PositiveInfinity a v Double.NegativeInfinity uvedeném pořadí.

Všimněte si, že ztráta přesnosti může být výsledkem převodu Single hodnoty na jiný číselný typ. v případě převodu neintegrálních Single hodnot, jak ukazuje výstup z příkladu, je zlomková komponenta ztracena, když Single je hodnota buď zaokrouhlena (jako v Visual Basic), nebo zkrácena (jako v C#). Pro převody na Decimal hodnoty Single nesmí mít tato hodnota přesnou reprezentaci v cílovém datovém typu.

Následující příklad převede počet Single hodnot na několik dalších číselných typů. k převodům dochází v kontrolovaném kontextu v Visual Basic (ve výchozím nastavení) a v C# (kvůli kontrolovanému klíčovému slovu). Výstup z příkladu ukazuje výsledek pro převody v kontrolovaném nekontrolovaným kontextu. můžete provádět převody v nekontrolovaném kontextu v Visual Basic kompilací s /removeintchecks+ přepínačem kompilátoru a v jazyce C# zadáním komentáře k checked příkazu.

using System;

public class Example
{
   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)
Module Example
   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)

další informace o převodu číselných typů naleznete v tématu převod typu v tabulkách .NET Framework a převodech typů.

Funkce s plovoucí desetinnou čárkou

SingleStruktura a související typy poskytují metody pro provádění následujících kategorií operací:

  • Porovnání hodnot. Můžete zavolat Equals metodu pro zjištění, zda jsou dvě Single hodnoty stejné, nebo CompareTo metodu pro určení vztahu mezi dvěma hodnotami.

    SingleStruktura také podporuje úplnou sadu relačních operátorů. Můžete například testovat rovnost nebo nerovnost nebo určit, zda je jedna hodnota větší než nebo rovna jiné hodnotě. Pokud je jeden z operandů Double , Single hodnota je převedena na a Double před provedením porovnání. Pokud je jeden z operandů integrálního typu, je převedena na typ Single před provedením porovnání. I když jsou rozšiřující převody, mohou způsobit ztrátu přesnosti.

    Upozornění

    Kvůli rozdílům v přesnosti Single může být výsledkem nerovnost dvou hodnot, které mají být stejné, což má vliv na výsledek porovnání. Další informace o porovnávání dvou hodnot naleznete v části testování rovnosti Single .

    Můžete také volat IsNaN IsInfinity metody,, IsPositiveInfinity a IsNegativeInfinity pro testování těchto speciálních hodnot.

  • Matematické operace. Běžné aritmetické operace, jako například sčítání, odčítání, násobení a dělení, jsou implementovány pomocí kompilátorů jazyka a instrukcí Common Intermediate Language (CIL), nikoli pomocí Single metod. Pokud je druhý operand v matematické operaci Double , Single je převedena na a Double před provedením operace a výsledek operace je také Double hodnota. Je-li druhý operand integrálního typu, je převeden na typ Single před provedením operace a výsledek operace je také Single hodnota.

    můžete provádět jiné matematické operace voláním static metod ( Shared v Visual Basic) ve System.Math třídě. Mezi ně patří další metody běžně používané pro aritmetické operace (například Math.Abs , Math.Sign , a Math.Sqrt ), geometrie (například Math.Cos a Math.Sin ) a calculus (například Math.Log ). Ve všech případech Single je hodnota převedena na Double .

    Můžete také manipulovat s jednotlivými bity v Single hodnotě. BitConverter.GetBytes(Single)Metoda vrátí svůj bitový vzor v bajtovém poli. Předáním tohoto bajtového pole BitConverter.ToInt32 metodě můžete také zachovat Single bitový vzor hodnoty v 32ovém čísle bitu.

  • Zaokrouhlování. Zaokrouhlování se často používá jako technika pro snížení dopadu rozdílů mezi hodnotami způsobenými problémy v podobě reprezentace a přesnosti s plovoucí desetinnou čárkou. Hodnotu lze zaokrouhlit Single voláním Math.Round metody. Všimněte si však, že Single hodnota je převedena na hodnotu Double před voláním metody a převod může zahrnovat ztrátu přesnosti.

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

  • Analýza řetězců. Řetězcovou reprezentaci hodnoty s plovoucí desetinnou čárkou můžete převést na Single hodnotu voláním Parse metody nebo TryParse . Pokud operace analýzy neproběhne úspěšně, Parse vyvolá metoda výjimku, zatímco TryParse Metoda vrátí false .

  • Konverze typu. Singlestruktura poskytuje explicitní implementaci rozhraní pro IConvertible rozhraní, které podporuje převod mezi dvěma standardními .NET Frameworkmi datovými typy. Kompilátory jazyka také podporují implicitní převod hodnot pro všechny ostatní standardní číselné typy s výjimkou převodu Double na Single hodnoty. Konverze hodnoty jakéhokoli standardního číselného typu jiného než a Double na Single je rozšiřující převod a nevyžaduje použití operátoru přetypování nebo metody převodu.

    Převod hodnot 32 bitů a 64 bitové celočíselné hodnoty však může zahrnovat ztrátu přesnosti. V následující tabulce jsou uvedeny rozdíly v přesnosti pro 32, 64 bitů a Double typy:

    Typ Maximální přesnost (desítkové číslice) Interní přesnost (desítkové číslice)
    Double 15 17
    Int32 a UInt32 10 10
    Int64 a UInt64 19 19
    Single 7 9

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

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

Pole

Epsilon

Představuje nejmenší kladnou Single hodnotu, která je větší než nula. Toto pole je konstantní.

MaxValue

Představuje největší možnou hodnotu Single . Toto pole je konstantní.

MinValue

Představuje nejmenší možnou hodnotu Single . Toto pole je konstantní.

NaN

Nezastupuje číslo ( NaN ). Toto pole je konstantní.

NegativeInfinity

Představuje záporné nekonečno. Toto pole je konstantní.

PositiveInfinity

Představuje kladné nekonečno. Toto pole je konstantní.

Metody

CompareTo(Object)

Porovná tuto instanci se zadaným objektem a vrátí celé číslo, které určuje, zda je hodnota této instance menší než, rovna nebo větší než hodnota zadaného objektu.

CompareTo(Single)

Porovná tuto instanci se zadaným číslem s plovoucí desetinnou čárkou s přesností na jednu desetinnou čárku a vrátí celé číslo, které určuje, zda je hodnota této instance menší, rovna nebo větší než hodnota zadaného čísla s plovoucí desetinnou čárkou s přesností na jednu desetinnou čárku.

Equals(Object)

Vrací hodnotu, která určuje, zda je tato instance rovna zadanému objektu.

Equals(Single)

Vrátí hodnotu určující, zda tato instance a zadaný Single objekt představují stejnou hodnotu.

GetHashCode()

Vrátí hodnotu hash pro tuto instanci.

GetTypeCode()

Vrátí pro TypeCode typ hodnoty Single .

IsFinite(Single)

Určuje, jestli je zadaná hodnota konečná (nula, subnormální nebo normální).

IsInfinity(Single)

Vrátí hodnotu určující, jestli se zadané číslo vyhodnotí jako záporné nebo kladné nekonečno.

IsNaN(Single)

Vrátí hodnotu, která určuje, jestli zadaná hodnota není číslo ( NaN ).

IsNegative(Single)

Určuje, jestli je zadaná hodnota záporná.

IsNegativeInfinity(Single)

Vrátí hodnotu určující, jestli se zadané číslo vyhodnotí jako záporné nekonečno.

IsNormal(Single)

Určuje, jestli je zadaná hodnota normální.

IsPositiveInfinity(Single)

Vrátí hodnotu určující, jestli se zadané číslo vyhodnotí jako kladné nekonečno.

IsSubnormal(Single)

Určuje, jestli je zadaná hodnota subnormální.

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Převede rozsah znaků, který obsahuje řetězcové vyjádření čísla v zadaném stylu a formátu specifického pro jazykovou verzi, na číslo s plovoucí desetinnou čárkou s jednoduchou přesností.

Parse(String)

Převede řetězcové vyjádření čísla na odpovídající číslo s jednoduchou přesností a plovoucí desetinnou čárkou.

Parse(String, IFormatProvider)

Převede řetězcové vyjádření čísla v zadaném formátu specifickém pro jazykovou verzi na ekvivalent čísla s plovoucí desetinnou čárkou s přesností na jednu jazykovou verzi.

Parse(String, NumberStyles)

Převede řetězcové vyjádření čísla v zadaném stylu na jeho ekvivalent čísla s plovoucí desetinnou čárkou s jednou přesností.

Parse(String, NumberStyles, IFormatProvider)

Převede řetězcové vyjádření čísla v zadaném stylu a formátu specifického pro jazykovou verzi na hodnotu s plovoucí desetinnou čárkou s jednoduchou přesností.

ToString()

Převádí číselnou hodnotu této instance na její ekvivalentní řetězcové vyjádření.

ToString(IFormatProvider)

Převádí číselnou hodnotu této instance na její ekvivalentní řetězcové vyjádření pomocí určených informací o formátování specifických pro jazykovou verzi.

ToString(String)

Převádí číselnou hodnotu této instance na její ekvivalentní řetězcové vyjádření pomocí určeného formátu.

ToString(String, IFormatProvider)

Převádí číselnou hodnotu této instance na její ekvivalentní řetězcové vyjádření pomocí určeného formátu a informací o formátování specifických pro jazykovou verzi.

TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)

Pokusí se naformátovat hodnotu aktuální instance čísla s plovoucí desetinnou čárkou do poskytnutého rozsahu znaků.

TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Single)

Převede řetězcové vyjádření čísla v zadaném stylu a formátu specifického pro jazykovou verzi na hodnotu s plovoucí desetinnou čárkou s jednoduchou přesností. Vrácená hodnota označuje, zda byl převod úspěšný, či nikoli.

TryParse(ReadOnlySpan<Char>, Single)

Převede řetězcové vyjádření čísla ve znakovém rozsahu na jeho ekvivalent s plovoucí desetinnou čárkou s jednoduchou přesností. Vrácená hodnota označuje, zda byl převod úspěšný, či nikoli.

TryParse(String, NumberStyles, IFormatProvider, Single)

Převede řetězcové vyjádření čísla v zadaném stylu a formátu specifického pro jazykovou verzi na hodnotu s plovoucí desetinnou čárkou s jednoduchou přesností. Vrácená hodnota označuje, zda byl převod úspěšný, či nikoli.

TryParse(String, Single)

Převede řetězcové vyjádření čísla na odpovídající číslo s jednoduchou přesností a plovoucí desetinnou čárkou. Vrácená hodnota označuje, zda byl převod úspěšný, či nikoli.

Operátory

Equality(Single, Single)

Vrátí hodnotu, která určuje, zda jsou dvě zadané Single hodnoty stejné.

GreaterThan(Single, Single)

Vrátí hodnotu, která určuje, zda je Single zadaná hodnota větší než jiná zadaná Single hodnota.

GreaterThanOrEqual(Single, Single)

Vrátí hodnotu, která určuje, zda je zadaná Single hodnota větší nebo rovna jiné zadané Single hodnotě.

Inequality(Single, Single)

Vrátí hodnotu, která určuje, jestli se dvě Single zadané hodnoty nerovnají.

LessThan(Single, Single)

Vrátí hodnotu, která určuje, zda je Single zadaná hodnota menší než jiná zadaná Single hodnota.

LessThanOrEqual(Single, Single)

Vrátí hodnotu, která určuje, zda je zadaná Single hodnota menší nebo rovna jiné zadané Single hodnotě.

Explicitní implementace rozhraní

IComparable.CompareTo(Object)

Porovná aktuální instanci s jiným objektem stejného typu a vrátí celé číslo udávající, zda aktuální instance předchází, následuje nebo se vyskytuje ve stejné pozici v pořadí řazení jako druhý objekt.

IConvertible.GetTypeCode()

Vrátí hodnotu TypeCode pro tuto instanci.

IConvertible.ToBoolean(IFormatProvider)

Popis tohoto člena naleznete v tématu ToBoolean(IFormatProvider) .

IConvertible.ToByte(IFormatProvider)

Popis tohoto člena naleznete v tématu ToByte(IFormatProvider) .

IConvertible.ToChar(IFormatProvider)

Tento převod není podporován. Pokus o použití této metody vyvolá výjimku InvalidCastException .

IConvertible.ToDateTime(IFormatProvider)

Tento převod není podporován. Pokus o použití této metody vyvolá výjimku InvalidCastException .

IConvertible.ToDecimal(IFormatProvider)

Popis tohoto člena naleznete v tématu ToDecimal(IFormatProvider) .

IConvertible.ToDouble(IFormatProvider)

Popis tohoto člena naleznete v tématu ToDouble(IFormatProvider) .

IConvertible.ToInt16(IFormatProvider)

Popis tohoto člena naleznete v tématu ToInt16(IFormatProvider) .

IConvertible.ToInt32(IFormatProvider)

Popis tohoto člena naleznete v tématu ToInt32(IFormatProvider) .

IConvertible.ToInt64(IFormatProvider)

Popis tohoto člena najdete v tématu ToInt64(IFormatProvider) .

IConvertible.ToSByte(IFormatProvider)

Popis tohoto člena najdete v tématu ToSByte(IFormatProvider) .

IConvertible.ToSingle(IFormatProvider)

Popis tohoto člena najdete v tématu ToSingle(IFormatProvider) .

IConvertible.ToType(Type, IFormatProvider)

Popis tohoto člena najdete v tématu ToType(Type, IFormatProvider) .

IConvertible.ToUInt16(IFormatProvider)

Popis tohoto člena najdete v tématu ToUInt16(IFormatProvider) .

IConvertible.ToUInt32(IFormatProvider)

Popis tohoto člena najdete v tématu ToUInt32(IFormatProvider) .

IConvertible.ToUInt64(IFormatProvider)

Popis tohoto člena najdete v tématu ToUInt64(IFormatProvider) .

Platí pro

Bezpečný přístup z více vláken

Všechny členy tohoto typu jsou zabezpečeny pro přístup z více vláken. Členy, které patrně upravují stav instance, ve skutečnosti vrací novou instanci inicializovanou s použitím nové hodnoty. Jako u jakéhokoli typu, čtení a zápis do sdílené proměnné, která obsahuje instanci tohoto typu, musí být chráněn zámkem, který zaručí bezpečný přístup z více vláken.

Viz také