Single Struktura

Definice

Představuje číslo s plovoucí desetinnou čárkou s jednoduchou přesností.Represents a single-precision floating-point number.

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

Poznámky

Typ hodnoty Single představuje 32 číslo s jednoduchou přesností s hodnotami od záporného e38u 3.402823 po kladné 3.402823 E38, stejně jako kladné nebo záporné nuly, PositiveInfinity, NegativeInfinitya nikoli číslo (NaN).The Single value type represents a single-precision 32-bit number with values ranging from negative 3.402823e38 to positive 3.402823e38, as well as positive or negative zero, PositiveInfinity, NegativeInfinity, and not a number (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. ).It is intended to represent values that are extremely large (such as distances between planets or galaxies) or extremely small (such as the molecular mass of a substance in kilograms) and that often are imprecise (such as the distance from earth to another solar system). Typ Single vyhovuje standardu IEC 60559:1989 (IEEE 754) pro binární aritmetické operace s plovoucí desetinnou čárkou.The Single type complies with the IEC 60559:1989 (IEEE 754) standard for binary floating-point arithmetic.

Toto téma se skládá z následujících částí:This topic consists of the following sections:

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.System.Single provides methods to compare instances of this type, to convert the value of an instance to its string representation, and to convert the string representation of a number to an instance of this type. 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.For information about how format specification codes control the string representation of value types, see Formatting Types, Standard Numeric Format Strings, and Custom Numeric Format Strings.

Znázornění s pohyblivou desetinnou čárkou a přesnostFloating-point representation and precision

Datový typ Single 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:The Single data type stores single-precision floating-point values in a 32-bit binary format, as shown in the following table:

ČástíPart BityBits
Mantisa nebo mantisaSignificand or mantissa 0-220-22
ZmocněnExponent 23-3023-30
Sign (0 = kladné, 1 = negativní)Sign (0 = positive, 1 = negative) 3131

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.Just as decimal fractions are unable to precisely represent some fractional values (such as 1/3 or Math.PI), binary fractions are unable to represent some fractional values. 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.For example, 2/10, which is represented precisely by .2 as a decimal fraction, is represented by .0011111001001100 as a binary fraction, with the pattern "1100" repeating to infinity. V tomto případě hodnota s plovoucí desetinnou čárkou poskytuje nepřesný reprezentace čísla, které představuje.In this case, the floating-point value provides an imprecise representation of the number that it represents. Provádění dalších matematických operací na původní hodnotě s plovoucí desetinnou čárkou často zvyšuje nedostatečnou přesnost.Performing additional mathematical operations on the original floating-point value often increases its lack of precision. 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í.For example, if you compare the results of multiplying .3 by 10 and adding .3 to .3 nine times, you will see that addition produces the less precise result, because it involves eight more operations than multiplication. 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é typem Single.Note that this disparity is apparent only if you display the two Single values by using the "R" standard numeric format string, which, if necessary, displays all 9 digits of precision supported by the Single type.

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.Because some numbers cannot be represented exactly as fractional binary values, floating-point numbers can only approximate real numbers.

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.All floating-point numbers have a limited number of significant digits, which also determines how accurately a floating-point value approximates a real number. Hodnota Single má až 7 desítkových číslic, ale interní je udržováno maximálně 9 číslic.A Single value has up to 7 decimal digits of precision, although a maximum of 9 digits is maintained internally. To znamená, že některé operace s plovoucí desetinnou čárkou nemusí mít přesnost na změnu hodnoty s plovoucí desetinnou čárkou.This means that some floating-point operations may lack the precision to change a floating-point value. V následujícím příkladu je definována velká hodnota s jednoduchou přesností a plovoucí desetinnou čárkou s jednou přesností a poté přidá produkt Single.Epsilon a jeden quadrillion do něj.The following example defines a large single-precision floating-point value, and then adds the product of Single.Epsilon and one quadrillion to it. Produkt je však pro úpravu původní hodnoty s plovoucí desetinnou čárkou příliš malý.However, the product is too small to modify the original floating-point value. Jeho nejméně významnou číslicí je sekundy, zatímco nejvýznamnější číslice v produktu je 10– 30.Its least significant digit is thousandths, whereas the most significant digit in the product is 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ů:The limited precision of a floating-point number has several consequences:

  • 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ší.Two floating-point numbers that appear equal for a particular precision might not compare equal because their least significant digits are different. 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.In the following example, a series of numbers are added together, and their total is compared with their expected total. I když se tyto dvě hodnoty zdají být stejné, volání metody Equals značí, že nejsou.Although the two values appear to be the same, a call to the Equals method indicates that they are not.

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

    Změníte-li položky formátu v příkazu Console.WriteLine(String, Object, Object) z {0} a {1} na {0:R} a {1:R} zobrazíte všechny významné číslice dvou Single hodnot, je zřejmé, že jsou tyto dvě hodnoty nerovné, protože došlo ke ztrátě přesnosti během operací sčítání.If you change the format items in the Console.WriteLine(String, Object, Object) statement from {0} and {1} to {0:R} and {1:R} to display all significant digits of the two Single values, it is clear that the two values are unequal because of a loss of precision during the addition operations. V takovém případě může být problém vyřešen voláním metody Math.Round(Double, Int32) pro zaokrouhlení Single hodnot na požadovanou přesnost před provedením porovnání.In this case, the issue can be resolved by calling the Math.Round(Double, Int32) method to round the Single values to the desired precision before performing the comparison.

  • 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.A mathematical or comparison operation that uses a floating-point number might not yield the same result if a decimal number is used, because the binary floating-point number might not equal the decimal number. 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ů.A previous example illustrated this by displaying the result of multiplying .3 by 10 and adding .3 to .3 nine times.

    Je-li hodnota přesnosti v numerických operacích s hodnotami zlomků důležitá, použijte místo typu Single Decimal typ.When accuracy in numeric operations with fractional values is important, use the Decimal type instead of the Single type. Je-li hodnota přesnosti v numerických operacích s celočíselnými hodnotami nad rozsahem Int64 nebo UInt64ch typů důležitá, použijte typ BigInteger.When accuracy in numeric operations with integral values beyond the range of the Int64 or UInt64 types is important, use the BigInteger type.

  • Hodnota nemusí být v případě, že je zapojeno číslo s plovoucí desetinnou čárkou, nesmí být v přenosu.A value might not round-trip if a floating-point number is involved. 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í hodnotě. číslo s plovoucí desetinnou čárkou.A value is said to round-trip if an operation converts an original floating-point number to another form, an inverse operation transforms the converted form back to a floating-point number, and the final floating-point number is equal to the original floating-point number. 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.The round trip might fail because one or more least significant digits are lost or changed in a conversion. V následujícím příkladu jsou tři hodnoty Single převedeny na řetězce a uloženy v souboru.In the following example, three Single values are converted to strings and saved in a file. Jak ukazuje výstup, Přestože hodnoty vypadají jako identické, obnovené hodnoty se neshodují s původními hodnotami.As the output shows, although the values appear to be identical, the restored values are not equal to the original values.

    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ě se hodnoty mohou úspěšně zaokrouhlit pomocí řetězce standardního číselného formátu "G9", který zachová celou přesnost Single hodnot, jak ukazuje následující příklad.In this case, the values can be successfully round-tripped by using the "G9" standard numeric format string to preserve the full precision of Single values, as the following example shows.

    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
    
  • hodnoty Single mají méně přesnosti než hodnoty Double.Single values have less precision than Double values. Hodnota Single, která je převedena na zdánlivě ekvivalentní Double často se nerovná hodnotě Double z důvodu rozdílů v přesnosti.A Single value that is converted to a seemingly equivalent Double often does not equal the Double value because of differences in precision. V následujícím příkladu je výsledkem identické operace dělení přiřazena hodnota Double a hodnota Single.In the following example, the result of identical division operations is assigned to a Double value and a Single value. Po přetypování Single hodnoty na Double, porovnání dvou hodnot ukazuje, že se neshodují.After the Single value is cast to a Double, a comparison of the two values shows that they are unequal.

    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.To avoid this problem, either use the Double data type in place of the Single data type, or use the Round method so that both values have the same precision.

Testování rovnostiTesting for equality

Aby se dalo považovat za stejné, dvě Single hodnoty musí představovat stejné hodnoty.To be considered equal, two Single values must represent identical values. 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.However, because of differences in precision between values, or because of a loss of precision by one or both values, floating-point values that are expected to be identical often turn out to be unequal due to differences in their least significant digits. V důsledku toho volání metody Equals k určení, zda jsou dvě hodnoty stejné, nebo volání metody CompareTo k určení vztahu mezi dvěma Single hodnotami, často poskytují neočekávané výsledky.As a result, calls to the Equals method to determine whether two values are equal, or calls to the CompareTo method to determine the relationship between two Single values, often yield unexpected results. V následujícím příkladu je zřejmé, že dvě zjevně Single hodnoty se neshodují, protože první hodnota má 7 číslic přesnosti, zatímco druhá hodnota je 9.This is evident in the following example, where two apparently equal Single values turn out to be unequal, because the first value has 7 digits of precision, whereas the second value has 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é.Calculated values that follow different code paths and that are manipulated in different ways often prove to be unequal. V následujícím příkladu je jedna hodnota Single čtvercová a druhá odmocnina je vypočítána k obnovení původní hodnoty.In the following example, one Single value is squared, and then the square root is calculated to restore the original value. Druhý Single vynásobí 3,51 a čtvercem před druhou odmocninou výsledku je vydělen hodnotou 3,51 pro obnovení původní hodnoty.A second Single is multiplied by 3.51 and squared before the square root of the result is divided by 3.51 to restore the original value. I když se tyto dvě hodnoty zdají být identické, volání metody Equals(Single) značí, že se neshodují.Although the two values appear to be identical, a call to the Equals(Single) method indicates that they are not equal. 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 the "G9" standard format string to return a result string that displays all the significant digits of each Single value shows that the second value is .0000000000001 less than the first.

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í metody Equals nebo CompareTo:In cases where a loss of precision is likely to affect the result of a comparison, you can use the following techniques instead of calling the Equals or CompareTo method:

  • Zavolejte metodu Math.Round, aby se zajistilo, že obě hodnoty mají stejnou přesnost.Call the Math.Round method to ensure that both values have the same precision. Následující příklad upravuje předchozí příklad pro použití tohoto přístupu, takže dvě zlomkové hodnoty jsou ekvivalentní.The following example modifies a previous example to use this approach so that two fractional values are equivalent.

    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
    

    Všimněte si, že problém přesnosti stále platí pro zaokrouhlení hodnot středního bodu.Note that the problem of precision still applies to rounding of midpoint values. Další informace naleznete v metodě Math.Round(Double, Int32, MidpointRounding).For more information, see the Math.Round(Double, Int32, MidpointRounding) method.

  • Testujte přibližnou rovnost namísto rovnosti.Test for approximate equality instead of equality. 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.This technique requires that you define either an absolute amount by which the two values can differ but still be equal, or that you define a relative amount by which the smaller value can diverge from the larger value.

    Varování

    Single.Epsilon se někdy používá jako absolutní míra vzdálenosti mezi dvěma hodnotami Single při testování rovnosti.Single.Epsilon is sometimes used as an absolute measure of the distance between two Single values when testing for equality. Single.Epsilon ale měří nejmenší možnou hodnotu, kterou lze přidat do nebo odečíst od, Single, jejíž hodnota je nula.However, Single.Epsilon measures the smallest possible value that can be added to, or subtracted from, a Single whose value is zero. Pro nejvíc kladné a záporné Single hodnoty je hodnota Single.Epsilon příliš malá, aby ji bylo možné zjistit.For most positive and negative Single values, the value of Single.Epsilon is too small to be detected. Proto s výjimkou hodnot, které jsou nulové, nedoporučujeme použití v testech pro rovnost.Therefore, except for values that are zero, we do not recommend its use in tests for equality.

    Následující příklad používá druhý přístup k definování IsApproximatelyEqual metody, která testuje relativní rozdíl mezi dvěma hodnotami.The following example uses the latter approach to define an IsApproximatelyEqual method that tests the relative difference between two values. Také na rozdíl od výsledku volání metody IsApproximatelyEqual a metody Equals(Single).It also contrasts the result of calls to the IsApproximatelyEqual method and the Equals(Single) method.

    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ýjimkyFloating-point values and exceptions

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í.Operations with floating-point values do not throw exceptions, unlike operations with integral types, which throw exceptions in cases of illegal operations such as division by zero or overflow. 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):Instead, in these situations, the result of a floating-point operation is zero, positive infinity, negative infinity, or not a number (NaN):

  • Pokud je výsledek operace s plovoucí desetinnou čárkou příliš malý pro cílový formát, je výsledek nula.If the result of a floating-point operation is too small for the destination format, the result is zero. 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.This can occur when two very small floating-point numbers are multiplied, as the following example shows.

    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, jak je to vhodné pro znaménko výsledku.If the magnitude of the result of a floating-point operation exceeds the range of the destination format, the result of the operation is PositiveInfinity or NegativeInfinity, as appropriate for the sign of the result. Výsledek operace, která přetéká Single.MaxValue je PositiveInfinitya výsledek operace, která přetéká Single.MinValue je NegativeInfinity, jak ukazuje následující příklad.The result of an operation that overflows Single.MaxValue is PositiveInfinity, and the result of an operation that overflows Single.MinValue is NegativeInfinity, as the following example shows.

    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é výsledky z dělení nulou s kladným dividendem a NegativeInfinity výsledky z dělení nulou se záporným dividendem.PositiveInfinity also results from a division by zero with a positive dividend, and NegativeInfinity results from a division by zero with a negative dividend.

  • Pokud je operace s plovoucí desetinnou čárkou neplatná, výsledek operace je NaN.If a floating-point operation is invalid, the result of the operation is NaN. Například NaN výsledky z následujících operací:For example, NaN results from the following operations:

    • Dělení nulou s dividendou nula.Division by zero with a dividend of zero. Všimněte si, že jiné případy dělení nulou nejsou výsledkem buď PositiveInfinity, nebo NegativeInfinity.Note that other cases of division by zero result in either PositiveInfinity or NegativeInfinity.

    • Jakákoli operace s plovoucí desetinnou čárkou s neplatným vstupem.Any floating-point operation with invalid input. Například pokus o nalezení druhé odmocniny záporné hodnoty vrátí NaN.For example, attempting to find the square root of a negative value returns NaN.

    • Jakákoli operace s argumentem, jehož hodnota je Single.NaN.Any operation with an argument whose value is Single.NaN.

Převody typů a jedna strukturaType conversions and the Single structure

Struktura Single nedefinuje žádné explicitní ani implicitní operátory převodu; místo toho jsou převody implementovány kompilátorem.The Single structure does not define any explicit or implicit conversion operators; instead, conversions are implemented by the compiler.

V následující tabulce jsou uvedeny možné převody hodnoty jiných primitivních číselných typů do Single hodnoty, také označuje, zda je převod rozšířen nebo zúžený a zda výsledný Single může mít menší přesnost než původní hodnota.The following table lists the possible conversions of a value of the other primitive numeric types to a Single value, It also indicates whether the conversion is widening or narrowing and whether the resulting Single may have less precision than the original value.

Převod zConversion from Rozšiřování a zúženíWidening/narrowing Možná ztráta přesnostiPossible loss of precision
Byte RozšířeníWidening NeNo
Decimal RozšířeníWidening

Všimněte si C# , že vyžaduje operátor přetypování.Note that C# requires a cast operator.
Ano.Yes. Decimal podporuje 29 desítkových číslic přesnosti; Single podporuje 9.Decimal supports 29 decimal digits of precision; Single supports 9.
Double Zužující hodnoty mimo rozsah jsou převedeny na Double.NegativeInfinity nebo Double.PositiveInfinity.Narrowing; out-of-range values are converted to Double.NegativeInfinity or Double.PositiveInfinity. Ano.Yes. Double podporuje 17 desítkových číslic přesnosti; Single podporuje 9.Double supports 17 decimal digits of precision; Single supports 9.
Int16 RozšířeníWidening NeNo
Int32 RozšířeníWidening Ano.Yes. Int32 podporuje 10 desítkových číslic přesnosti; Single podporuje 9.Int32 supports 10 decimal digits of precision; Single supports 9.
Int64 RozšířeníWidening Ano.Yes. Int64 podporuje 19 desítkových číslic přesnosti; Single podporuje 9.Int64 supports 19 decimal digits of precision; Single supports 9.
SByte RozšířeníWidening NeNo
UInt16 RozšířeníWidening NeNo
UInt32 RozšířeníWidening Ano.Yes. UInt32 podporuje 10 desítkových číslic přesnosti; Single podporuje 9.UInt32 supports 10 decimal digits of precision; Single supports 9.
UInt64 RozšířeníWidening Ano.Yes. Int64 podporuje 20 desítkových číslic přesnosti; Single podporuje 9.Int64 supports 20 decimal digits of precision; Single supports 9.

Následující příklad převede minimální nebo maximální hodnotu ostatních primitivních číselných typů na Single hodnotu.The following example converts the minimum or maximum value of other primitive numeric types to a Single value.

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.PositiveInfinitya Double.NegativeInfinity převést na Single.NaN, Single.PositiveInfinitya Single.NegativeInfinityv uvedeném pořadí.In addition, the Double values Double.NaN, Double.PositiveInfinity, and Double.NegativeInfinity covert to Single.NaN, Single.PositiveInfinity, and Single.NegativeInfinity, respectively.

Všimněte si, že převod hodnoty některých číselných typů na hodnotu Single může zahrnovat ztrátu přesnosti.Note that the conversion of the value of some numeric types to a Single value can involve a loss of precision. Jak ukazuje příklad, může dojít ke ztrátě přesnosti při převodu Decimal, Double, Int32, Int64, UInt32a UInt64 hodnot na Single hodnoty.As the example illustrates, a loss of precision is possible when converting Decimal, Double, Int32, Int64, UInt32, and UInt64 values to Single values.

Převod Single hodnoty na Double je rozšiřující převod.The conversion of a Single value to a Double is a widening conversion. Převod může způsobit ztrátu přesnosti, pokud Double typ nemá přesnou reprezentaci pro hodnotu Single.The conversion may result in a loss of precision if the Double type does not have a precise representation for the Single value.

Konverze Single hodnoty na hodnotu jakéhokoli 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 C#) nebo metodu převodu (v Visual Basic).The conversion of a Single value to a value of any primitive numeric data type other than a Double is a narrowing conversion and requires a cast operator (in C#) or a conversion method (in Visual Basic). Hodnoty, které jsou mimo rozsah cílového datového typu, které jsou definovány MinValue a MaxValue vlastností cílového typu, se chovají, jak je uvedeno v následující tabulce.Values that are outside the range of the target data type, which are defined by the target type's MinValue and MaxValue properties, behave as shown in the following table.

Cílový typTarget type VýsledekResult
Libovolný celočíselný typAny integral type Výjimka OverflowException, pokud dojde k převodu v kontrolovaném kontextu.An OverflowException exception if the conversion occurs in a checked context.

Pokud se převod vyskytne v nekontrolovaném kontextu (ve C#výchozím nastavení), operace převodu bude úspěšná, ale hodnota přetéká.If the conversion occurs in an unchecked context (the default in C#), the conversion operation succeeds but the value overflows.
Decimal Výjimka OverflowException,An OverflowException exception,

Kromě toho Single.NaN, Single.PositiveInfinitya Single.NegativeInfinity vyvolají OverflowException pro převody na celá čísla v kontrolovaném kontextu, ale tyto hodnoty přetečení při převodu na celá čísla v nekontrolovaném kontextu.In addition, Single.NaN, Single.PositiveInfinity, and Single.NegativeInfinity throw an OverflowException for conversions to integers in a checked context, but these values overflow when converted to integers in an unchecked context. Pro převody na Decimalvždy vyvolají OverflowException.For conversions to Decimal, they always throw an OverflowException. Pro převody na Doublepřevádějí do Double.NaN, Double.PositiveInfinitya Double.NegativeInfinity, v uvedeném pořadí.For conversions to Double, they convert to Double.NaN, Double.PositiveInfinity, and Double.NegativeInfinity, respectively.

Všimněte si, že ztráta přesnosti může být výsledkem převodu Single hodnoty na jiný číselný typ.Note that a loss of precision may result from converting a Single value to another numeric type. V případě převodu neceločíselných Single hodnot, jak výstup z příkladu ukazuje, je desetinná komponenta ztracena, pokud je hodnota Single buď zaokrouhlena (jako v Visual Basic), nebo zkrácena (jako v C#rámci).In the case of converting non-integral Single values, as the output from the example shows, the fractional component is lost when the Single value is either rounded (as in Visual Basic) or truncated (as in C#). Pro převody na Decimal hodnoty nesmí mít Single hodnota přesnou reprezentaci v cílovém datovém typu.For conversions to Decimal values, the Single value may not have a precise representation in the target data type.

Následující příklad převede počet Single hodnot na několik dalších číselných typů.The following example converts a number of Single values to several other numeric types. K převodům dochází v kontrolovaném kontextu v Visual Basic (ve výchozím nastavení) C# a v (kvůli kontrolovanému klíčovému slovu).The conversions occur in a checked context in Visual Basic (the default) and in C# (because of the checked keyword). Výstup z příkladu ukazuje výsledek pro převody v kontrolovaném nekontrolovaným kontextu.The output from the example shows the result for conversions in both a checked an unchecked context. Můžete provádět převody v nekontrolovaném kontextu v Visual Basic kompilací s přepínačem kompilátoru /removeintchecks+ a v C# části komentářem k příkazu checked.You can perform conversions in an unchecked context in Visual Basic by compiling with the /removeintchecks+ compiler switch and in C# by commenting out the checked statement.

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ů.For more information on the conversion of numeric types, see Type Conversion in the .NET Framework and Type Conversion Tables.

Funkce s plovoucí desetinnou čárkouFloating-point functionality

Struktura Single a související typy poskytují metody pro provádění následujících kategorií operací:The Single structure and related types provide methods to perform the following categories of operations:

  • Porovnání hodnot.Comparison of values. Můžete zavolat metodu Equals, abyste zjistili, zda jsou dvě hodnoty Single stejné, nebo metodu CompareTo k určení vztahu mezi dvěma hodnotami.You can call the Equals method to determine whether two Single values are equal, or the CompareTo method to determine the relationship between two values.

    Struktura Single také podporuje úplnou sadu relačních operátorů.The Single structure also supports a complete set of comparison operators. Můžete například testovat rovnost nebo nerovnost nebo určit, zda je jedna hodnota větší než nebo rovna jiné hodnotě.For example, you can test for equality or inequality, or determine whether one value is greater than or equal to another value. Pokud je jeden z operandů Double, hodnota Single je před provedením porovnání převedena na Double.If one of the operands is a Double, the Single value is converted to a Double before performing the comparison. Pokud je jeden z operandů integrálního typu, je před provedením porovnání převeden na Single.If one of the operands is an integral type, it is converted to a Single before performing the comparison. I když jsou rozšiřující převody, mohou způsobit ztrátu přesnosti.Although these are widening conversions, they may involve a loss of precision.

    Varování

    Kvůli rozdílům v přesnosti mohou být dvě Single hodnoty, které mají být stejné, nerovné, což má vliv na výsledek porovnání.Because of differences in precision, two Single values that you expect to be equal may turn out to be unequal, which affects the result of the comparison. Další informace o porovnávání dvou Singlech hodnot naleznete v části testování rovnosti .See the Testing for equality section for more information about comparing two Single values.

    Můžete také volat IsNaN, IsInfinity, IsPositiveInfinitya metody IsNegativeInfinity k otestování těchto speciálních hodnot.You can also call the IsNaN, IsInfinity, IsPositiveInfinity, and IsNegativeInfinity methods to test for these special values.

  • Matematické operace.Mathematical operations. 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.Common arithmetic operations such as addition, subtraction, multiplication, and division are implemented by language compilers and Common Intermediate Language (CIL) instructions rather than by Single methods. Pokud je druhý operand v matematické operaci Double, Single je před provedením operace převeden na Double a výsledek operace je také Double hodnota.If the other operand in a mathematical operation is a Double, the Single is converted to a Double before performing the operation, and the result of the operation is also a Double value. Pokud je druhý operand integrálního typu, je před provedením operace převeden na Single a výsledek operace je také Single hodnota.If the other operand is an integral type, it is converted to a Single before performing the operation, and the result of the operation is also a Single value.

    Jiné matematické operace můžete provádět voláním metod static (Shared in Visual Basic) ve třídě System.Math.You can perform other mathematical operations by calling static (Shared in Visual Basic) methods in the System.Math class. Patří mezi ně i další metody, které se běžně používají pro aritmetické operace (například Math.Abs, Math.Signa Math.Sqrt), geometrie (například Math.Cos a Math.Sin) a calculus (například Math.Log).These include additional methods commonly used for arithmetic (such as Math.Abs, Math.Sign, and Math.Sqrt), geometry (such as Math.Cos and Math.Sin), and calculus (such as Math.Log). Ve všech případech je hodnota Single převedena na Double.In all cases, the Single value is converted to a Double.

    Můžete také manipulovat s jednotlivými bity ve Single hodnotě.You can also manipulate the individual bits in a Single value. Metoda BitConverter.GetBytes(Single) vrátí svůj bitový vzor v bajtovém poli.The BitConverter.GetBytes(Single) method returns its bit pattern in a byte array. Předáním tohoto bajtového pole metodě BitConverter.ToInt32 lze také zachovat bitový vzor Single hodnoty v 32ovém čísle bitového čísla.By passing that byte array to the BitConverter.ToInt32 method, you can also preserve the Single value's bit pattern in a 32-bit integer.

  • Zaokrouhlování.Rounding. 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.Rounding is often used as a technique for reducing the impact of differences between values caused by problems of floating-point representation and precision. Hodnotu Single lze zaokrouhlit voláním metody Math.Round.You can round a Single value by calling the Math.Round method. Všimněte si však, že hodnota Single je převedena na Double před voláním metody a převod může zahrnovat ztrátu přesnosti.However, note that the Single value is converted to a Double before the method is called, and the conversion can involve a loss of precision.

  • Formátování.Formatting. Hodnotu Single můžete převést na její řetězcové vyjádření voláním metody ToString nebo pomocí funkce složeného formátování .You can convert a Single value to its string representation by calling the ToString method or by using the composite formatting feature. 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 .For information about how format strings control the string representation of floating-point values, see the Standard Numeric Format Strings and Custom Numeric Format Strings topics.

  • Analýza řetězců.Parsing strings. Řetězcovou reprezentaci hodnoty s plovoucí desetinnou čárkou můžete převést na hodnotu Single voláním metody Parse nebo TryParse.You can convert the string representation of a floating-point value to a Single value by calling the Parse or TryParse method. Pokud operace analýzy neproběhne úspěšně, vyvolá metoda Parse výjimku, zatímco metoda TryParse vrátí false.If the parse operation fails, the Parse method throws an exception, whereas the TryParse method returns false.

  • Konverze typu.Type conversion. Struktura Single poskytuje explicitní implementaci rozhraní IConvertible rozhraní, které podporuje převod mezi dvěma standardními .NET Framework datovými typy.The Single structure provides an explicit interface implementation for the IConvertible interface, which supports conversion between any two standard .NET Framework data types. Kompilátory jazyka také podporují implicitní převod hodnot pro všechny ostatní standardní číselné typy s výjimkou konverze Double na Single hodnoty.Language compilers also support the implicit conversion of values for all other standard numeric types except for the conversion of Double to Single values. Konverze hodnoty libovolného standardního číselného typu jiného než Double do Single je rozšiřující konverze a nevyžaduje použití operátoru přetypování nebo metody převodu.Conversion of a value of any standard numeric type other than a Double to a Single is a widening conversion and does not require the use of a casting operator or conversion method.

    Převod hodnot 32 bitů a 64 bitové celočíselné hodnoty však může zahrnovat ztrátu přesnosti.However, conversion of 32-bit and 64-bit integer values can involve a loss of precision. V následující tabulce jsou uvedeny rozdíly v přesnosti pro 32 Double, 64-bit a typy:The following table lists the differences in precision for 32-bit, 64-bit, and Double types:

    TypType Maximální přesnost (desítkové číslice)Maximum precision (in decimal digits) Interní přesnost (desítkové číslice)Internal precision (in decimal digits)
    Double 1515 1717
    Int32 a UInt32Int32 and UInt32 1010 1010
    Int64 a UInt64Int64 and UInt64 1919 1919
    Single 77 99

    Problém s přesností nejčastěji ovlivňuje Single hodnoty, které jsou převedeny na Double hodnoty.The problem of precision most frequently affects Single values that are converted to Double values. V následujícím příkladu jsou dvě hodnoty vytvořené identickými operacemi dělení nerovné, protože jedna z hodnot je hodnota s plovoucí desetinnou čárkou s jednoduchou přesností, která je převedena na Double.In the following example, two values produced by identical division operations are unequal, because one of the values is a single-precision floating point value that is converted to a 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.Represents the smallest positive Single value that is greater than zero. Toto pole je konstantní.This field is constant.

MaxValue

Představuje největší možnou hodnotu Single.Represents the largest possible value of Single. Toto pole je konstantní.This field is constant.

MinValue

Představuje nejmenší možnou hodnotu Single.Represents the smallest possible value of Single. Toto pole je konstantní.This field is constant.

NaN

Představuje číslo (NaN).Represents not a number (NaN). Toto pole je konstantní.This field is constant.

NegativeInfinity

Představuje záporné nekonečno.Represents negative infinity. Toto pole je konstantní.This field is constant.

PositiveInfinity

Představuje kladné nekonečno.Represents positive infinity. Toto pole je konstantní.This field is constant.

Metody

CompareTo(Object)

Porovná tuto instanci se zadaným objektem a vrátí celé číslo, které označuje, zda je hodnota této instance menší než, rovna nebo větší než hodnota zadaného objektu.Compares this instance to a specified object and returns an integer that indicates whether the value of this instance is less than, equal to, or greater than the value of the specified object.

CompareTo(Single)

Porovná tuto instanci se zadaným číslem s plovoucí desetinnou čárkou s jednoduchou přesností a vrátí celé číslo, které označuje, zda je hodnota této instance menší než, rovna nebo větší než hodnota zadaného čísla s plovoucí desetinnou čárkou s jednoduchou přesností.Compares this instance to a specified single-precision floating-point number and returns an integer that indicates whether the value of this instance is less than, equal to, or greater than the value of the specified single-precision floating-point number.

Equals(Object)

Vrací hodnotu, která určuje, zda je tato instance rovna zadanému objektu.Returns a value indicating whether this instance is equal to a specified object.

Equals(Single)

Vrátí hodnotu, která označuje, zda tato instance a zadaný objekt Single reprezentují stejnou hodnotu.Returns a value indicating whether this instance and a specified Single object represent the same value.

GetHashCode()

Vrátí kód hash této instance.Returns the hash code for this instance.

GetTypeCode()

Vrátí TypeCode pro typ hodnoty Single.Returns the TypeCode for value type Single.

IsFinite(Single)

Určuje, zda je zadaná hodnota konečná (0, normální nebo normální).Determines whether the specified value is finite (zero, subnormal or normal).

IsInfinity(Single)

Vrátí hodnotu, která označuje, zda je zadané číslo vyhodnoceno jako záporné nebo kladné nekonečno.Returns a value indicating whether the specified number evaluates to negative or positive infinity.

IsNaN(Single)

Vrátí hodnotu, která označuje, zda zadaná hodnota není číslo (NaN).Returns a value that indicates whether the specified value is not a number (NaN).

IsNegative(Single)

Určuje, zda je zadaná hodnota záporná.Determines whether the specified value is negative.

IsNegativeInfinity(Single)

Vrátí hodnotu, která označuje, zda je zadané číslo vyhodnoceno jako záporné nekonečno.Returns a value indicating whether the specified number evaluates to negative infinity.

IsNormal(Single)

Určuje, zda je zadaná hodnota normální.Determines whether the specified value is normal.

IsPositiveInfinity(Single)

Vrátí hodnotu, která označuje, zda je zadané číslo vyhodnoceno jako kladné nekonečno.Returns a value indicating whether the specified number evaluates to positive infinity.

IsSubnormal(Single)

Určuje, zda je zadaná hodnota mezinormální.Determines whether the specified value is subnormal.

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í.Converts a character span that contains the string representation of a number in a specified style and culture-specific format to its single-precision floating-point number equivalent.

Parse(String)

Převede řetězcové vyjádření čísla na odpovídající číslo s jednoduchou přesností a plovoucí desetinnou čárkou.Converts the string representation of a number to its single-precision floating-point number equivalent.

Parse(String, IFormatProvider)

Převede řetězcové vyjádření čísla v zadaném formátu specifickém pro jazykovou verzi na jeho ekvivalent s plovoucí desetinnou čárkou s jednoduchou přesností.Converts the string representation of a number in a specified culture-specific format to its single-precision floating-point number equivalent.

Parse(String, NumberStyles)

Převede řetězcové vyjádření čísla v zadaném stylu na jeho ekvivalent s plovoucí desetinnou čárkou s jednoduchou přesností.Converts the string representation of a number in a specified style to its single-precision floating-point number equivalent.

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í.Converts the string representation of a number in a specified style and culture-specific format to its single-precision floating-point number equivalent.

ToString()

Převádí číselnou hodnotu této instance na její ekvivalentní řetězcové vyjádření.Converts the numeric value of this instance to its equivalent string representation.

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.Converts the numeric value of this instance to its equivalent string representation using the specified culture-specific format information.

ToString(String)

Převádí číselnou hodnotu této instance na její ekvivalentní řetězcové vyjádření pomocí určeného formátu.Converts the numeric value of this instance to its equivalent string representation, using the specified format.

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.Converts the numeric value of this instance to its equivalent string representation using the specified format and culture-specific format information.

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

Pokusí se naformátovat hodnotu aktuální instance čísla float do zadaného rozsahu znaků.Tries to format the value of the current float number instance into the provided span of characters.

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í.Converts the span representation of a number in a specified style and culture-specific format to its single-precision floating-point number equivalent. Vrácená hodnota označuje, zda byl převod úspěšný, či nikoli.A return value indicates whether the conversion succeeded or failed.

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í.Converts the string representation of a number in a character span to its single-precision floating-point number equivalent. Vrácená hodnota označuje, zda byl převod úspěšný, či nikoli.A return value indicates whether the conversion succeeded or failed.

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í.Converts the string representation of a number in a specified style and culture-specific format to its single-precision floating-point number equivalent. Vrácená hodnota označuje, zda byl převod úspěšný, či nikoli.A return value indicates whether the conversion succeeded or failed.

TryParse(String, Single)

Převede řetězcové vyjádření čísla na odpovídající číslo s jednoduchou přesností a plovoucí desetinnou čárkou.Converts the string representation of a number to its single-precision floating-point number equivalent. Vrácená hodnota označuje, zda byl převod úspěšný, či nikoli.A return value indicates whether the conversion succeeded or failed.

Operátory

Equality(Single, Single)

Vrátí hodnotu, která označuje, zda jsou dvě zadané hodnoty Single stejné.Returns a value that indicates whether two specified Single values are equal.

GreaterThan(Single, Single)

Vrátí hodnotu, která označuje, zda je zadaná hodnota Single větší než jiná zadaná hodnota Single.Returns a value that indicates whether a specified Single value is greater than another specified Single value.

GreaterThanOrEqual(Single, Single)

Vrátí hodnotu, která označuje, zda je zadaná hodnota Single větší než nebo rovna jiné zadané Single hodnotě.Returns a value that indicates whether a specified Single value is greater than or equal to another specified Single value.

Inequality(Single, Single)

Vrátí hodnotu, která označuje, zda nejsou dvě zadané hodnoty Single stejné.Returns a value that indicates whether two specified Single values are not equal.

LessThan(Single, Single)

Vrátí hodnotu, která označuje, zda je zadaná hodnota Single menší než jiná zadaná hodnota Single.Returns a value that indicates whether a specified Single value is less than another specified Single value.

LessThanOrEqual(Single, Single)

Vrátí hodnotu, která označuje, zda je zadaná hodnota Single menší nebo rovna jiné zadané Single hodnotě.Returns a value that indicates whether a specified Single value is less than or equal to another specified Single value.

Explicitní implementace rozhraní

IComparable.CompareTo(Object)
IConvertible.GetTypeCode()
IConvertible.ToBoolean(IFormatProvider)

Popis tohoto člena naleznete v tématu ToBoolean(IFormatProvider).For a description of this member, see ToBoolean(IFormatProvider).

IConvertible.ToByte(IFormatProvider)

Popis tohoto člena naleznete v tématu ToByte(IFormatProvider).For a description of this member, see ToByte(IFormatProvider).

IConvertible.ToChar(IFormatProvider)

Tento převod není podporován.This conversion is not supported. Při pokusu o použití této metody dojde k vyvolání InvalidCastException.Attempting to use this method throws an InvalidCastException.

IConvertible.ToDateTime(IFormatProvider)

Tento převod není podporován.This conversion is not supported. Při pokusu o použití této metody dojde k vyvolání InvalidCastException.Attempting to use this method throws an InvalidCastException.

IConvertible.ToDecimal(IFormatProvider)

Popis tohoto člena naleznete v tématu ToDecimal(IFormatProvider).For a description of this member, see ToDecimal(IFormatProvider).

IConvertible.ToDouble(IFormatProvider)

Popis tohoto člena naleznete v tématu ToDouble(IFormatProvider).For a description of this member, see ToDouble(IFormatProvider).

IConvertible.ToInt16(IFormatProvider)

Popis tohoto člena naleznete v tématu ToInt16(IFormatProvider).For a description of this member, see ToInt16(IFormatProvider).

IConvertible.ToInt32(IFormatProvider)

Popis tohoto člena naleznete v tématu ToInt32(IFormatProvider).For a description of this member, see ToInt32(IFormatProvider).

IConvertible.ToInt64(IFormatProvider)

Popis tohoto člena naleznete v tématu ToInt64(IFormatProvider).For a description of this member, see ToInt64(IFormatProvider).

IConvertible.ToSByte(IFormatProvider)

Popis tohoto člena naleznete v tématu ToSByte(IFormatProvider).For a description of this member, see ToSByte(IFormatProvider).

IConvertible.ToSingle(IFormatProvider)

Popis tohoto člena naleznete v tématu ToSingle(IFormatProvider).For a description of this member, see ToSingle(IFormatProvider).

IConvertible.ToType(Type, IFormatProvider)

Popis tohoto člena naleznete v tématu ToType(Type, IFormatProvider).For a description of this member, see ToType(Type, IFormatProvider).

IConvertible.ToUInt16(IFormatProvider)

Popis tohoto člena naleznete v tématu ToUInt16(IFormatProvider).For a description of this member, see ToUInt16(IFormatProvider).

IConvertible.ToUInt32(IFormatProvider)

Popis tohoto člena naleznete v tématu ToUInt32(IFormatProvider).For a description of this member, see ToUInt32(IFormatProvider).

IConvertible.ToUInt64(IFormatProvider)

Popis tohoto člena naleznete v tématu ToUInt64(IFormatProvider).For a description of this member, see 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.All members of this type are thread safe. Členy, které patrně upravují stav instance, ve skutečnosti vrací novou instanci inicializovanou s použitím nové hodnoty.Members that appear to modify instance state actually return a new instance initialized with the new value. 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.As with any other type, reading and writing to a shared variable that contains an instance of this type must be protected by a lock to guarantee thread safety.

Viz také