# 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
public value class Single : IComparable, IConvertible, IFormattable
public value class Single : IComparable, IComparable<float>, IEquatable<float>, IFormattable
public struct Single : IComparable, IComparable<float>, IConvertible, IEquatable<float>, IFormattable
[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
[<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, 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 ).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). SingleTyp odpovídá 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

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

ČástPart BityBits
Mantisa nebo mantisaSignificand or mantissa 0-220-22
MocninaExponent 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é Single typem.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. SingleHodnota má až 7 desítkových číslic, i když je interní uchovává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. 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.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;
}
}
// 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
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í Equals metody označuje, ž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).

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í.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 Math.Round(Double, Int32) metody 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 Decimal typ místo Single typu.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 UInt64 typy nebo je důležitá, použijte BigInteger typ.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ímu číslu 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 Single jsou tři hodnoty 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];
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 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.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];
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 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.Single values have less precision than Double values. SingleHodnota, která je převedena na zdánlivý ekvivalent Double často, se nerovná Double hodnotě 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ýsledek identických operací dělení přiřazen k Double hodnotě a Single hodnotě.In the following example, the result of identical division operations is assigned to a Double value and a Single value. Po Single přetypování hodnoty na Double , porovnání dvou hodnot ukazuje, že jsou nerovné.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í 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.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ě rovné 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 Single je jedna hodnota č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 je vynásobena 3,51 a druhá mocnina před druhou odmocninou výsledku je vydělena 3,51em k 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í Equals(Single) metody označuje, ž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í Equals CompareTo metody nebo: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, aby se Math.Round 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 Math.Round(Double, Int32, MidpointRounding) metodě.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.

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.Single.Epsilon is sometimes used as an absolute measure of the distance between two Single values when testing for equality. 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.However, Single.Epsilon measures the smallest possible value that can be added to, or subtracted from, a Single whose value is zero. 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.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.

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.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í IsApproximatelyEqual metody a Equals(Single) metody.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 , podle potřeby 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 PositiveInfinity , a 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é je výsledkem dělení nulou s kladným dividendem a NegativeInfinity výsledkem 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 v 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

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

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.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 NoNo
Decimal RozšířeníWidening

Všimněte si, že jazyk C# 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 NoNo
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 NoNo
UInt16 RozšířeníWidening NoNo
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.PositiveInfinity a Double.NegativeInfinity převeďte na Single.NaN , Single.PositiveInfinity , a v Single.NegativeInfinity uvedeném pořadí.In addition, the Double values Double.NaN, Double.PositiveInfinity, and Double.NegativeInfinity convert to Single.NaN, Single.PositiveInfinity, and Single.NegativeInfinity, respectively.

Všimněte si, že převod hodnoty některých číselných typů na Single hodnotu 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 hodnot,,,, Decimal Double Int32 Int64 UInt32 a 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.

Konverze 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 Single hodnoty.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 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).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 vlastnostmi a vlastnostmi cílového typu MaxValue , 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 OverflowExceptionVýjimka v případě, že 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 výchozím nastavení v jazyce C#), 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 OverflowExceptionVýjimka,An OverflowException exception,

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.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 Decimal , vždy vyvolají OverflowException .For conversions to Decimal, they always throw an OverflowException. Pro převody na, Double jsou převedeny na Double.NaN , Double.PositiveInfinity a v Double.NegativeInfinity 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 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#).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 Single nesmí mít tato 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í) a v C# (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 /removeintchecks+ přepínačem kompilátoru a v jazyce C# zadáním komentáře k checked příkazu.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

SingleStruktura 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 Equals metodu pro zjištění, zda jsou dvě Single hodnoty stejné, nebo CompareTo metodu pro 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.

SingleStruktura 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 , Single hodnota je převedena na a Double před provedením porovnání.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řevedena na typ Single před provedením porovnání.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.

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í.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 hodnot naleznete v části testování rovnosti Single .See the Testing for equality section for more information about comparing two Single values.

Můžete také volat IsNaN IsInfinity metody,, IsPositiveInfinity a IsNegativeInfinity pro testová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řevedena na a Double před provedením operace 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. 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.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.

Můžete provádět jiné matematické operace voláním static metod ( Shared v Visual Basic) ve System.Math třídě.You can perform other mathematical operations by calling static (Shared in Visual Basic) methods in the System.Math class. 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 ).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 Single je hodnota převedena na Double .In all cases, the Single value is converted to a Double.

Můžete také manipulovat s jednotlivými bity v Single hodnotě.You can also manipulate the individual bits in a Single value. BitConverter.GetBytes(Single)Metoda 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 BitConverter.ToInt32 metodě můžete také zachovat Single bitový vzor hodnoty v 32ovém čísle bitu.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 lze zaokrouhlit Single voláním Math.Round metody.You can round a Single value by calling the Math.Round method. 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.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 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í .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 Single hodnotu voláním Parse metody 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ě, Parse vyvolá metoda výjimku, zatímco TryParse Metoda vrátí false .If the parse operation fails, the Parse method throws an exception, whereas the TryParse method returns false.

• Konverze typu.Type conversion. SingleStruktura poskytuje explicitní implementaci rozhraní pro IConvertible rozhraní, které podporuje převod mezi dvěma standardními .NET Frameworkmi 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 převodu 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 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.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, 64 bitů a Double 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 and UInt32 1010 1010
Int64 and UInt64 1919 1919
Single 77 99

Problémy s přesností jsou nejčastěji ovlivněny Single hodnotami, 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

 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. Představuje největší možnou hodnotu Single .Represents the largest possible value of Single. Toto pole je konstantní.This field is constant. Představuje nejmenší možnou hodnotu Single .Represents the smallest possible value of Single. Toto pole je konstantní.This field is constant. Představuje číslo ( NaN ).Represents not a number (NaN). Toto pole je konstantní.This field is constant. Představuje záporné nekonečno.Represents negative infinity. Toto pole je konstantní.This field is constant. Představuje kladné nekonečno.Represents positive infinity. Toto pole je konstantní.This field is constant.

## Operátory

 Vrátí hodnotu, která označuje, zda jsou dvě zadané Single hodnoty stejné.Returns a value that indicates whether two specified Single values are equal. Vrátí hodnotu, která označuje, zda Single je zadaná hodnota větší než jiná zadaná Single hodnota.Returns a value that indicates whether a specified Single value is greater than another specified Single value. Vrátí hodnotu, která označuje, zda Single je zadaná hodnota 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. Vrátí hodnotu, která označuje, zda dvě zadané Single hodnoty nejsou stejné.Returns a value that indicates whether two specified Single values are not equal. Vrátí hodnotu, která označuje, zda Single je zadaná hodnota menší než jiná zadaná Single hodnota.Returns a value that indicates whether a specified Single value is less than another specified Single value. Vrátí hodnotu, která označuje, zda Single je zadaná hodnota 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í

 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.Compares the current instance with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other object. Vrátí hodnotu TypeCode pro tuto instanci.Returns the TypeCode for this instance. Popis tohoto člena naleznete v tématu ToBoolean(IFormatProvider) .For a description of this member, see ToBoolean(IFormatProvider). Popis tohoto člena naleznete v tématu ToByte(IFormatProvider) .For a description of this member, see ToByte(IFormatProvider). Tento převod není podporován.This conversion is not supported. Pokus o použití této metody vyvolá výjimku InvalidCastException .Attempting to use this method throws an InvalidCastException. Tento převod není podporován.This conversion is not supported. Pokus o použití této metody vyvolá výjimku InvalidCastException .Attempting to use this method throws an InvalidCastException. Popis tohoto člena naleznete v tématu ToDecimal(IFormatProvider) .For a description of this member, see ToDecimal(IFormatProvider). Popis tohoto člena naleznete v tématu ToDouble(IFormatProvider) .For a description of this member, see ToDouble(IFormatProvider). Popis tohoto člena naleznete v tématu ToInt16(IFormatProvider) .For a description of this member, see ToInt16(IFormatProvider). Popis tohoto člena naleznete v tématu ToInt32(IFormatProvider) .For a description of this member, see ToInt32(IFormatProvider). Popis tohoto člena naleznete v tématu ToInt64(IFormatProvider) .For a description of this member, see ToInt64(IFormatProvider). Popis tohoto člena naleznete v tématu ToSByte(IFormatProvider) .For a description of this member, see ToSByte(IFormatProvider). Popis tohoto člena naleznete v tématu ToSingle(IFormatProvider) .For a description of this member, see ToSingle(IFormatProvider). Popis tohoto člena naleznete v tématu ToType(Type, IFormatProvider) .For a description of this member, see ToType(Type, IFormatProvider). Popis tohoto člena naleznete v tématu ToUInt16(IFormatProvider) .For a description of this member, see ToUInt16(IFormatProvider). Popis tohoto člena naleznete v tématu ToUInt32(IFormatProvider) .For a description of this member, see ToUInt32(IFormatProvider). Popis tohoto člena naleznete v tématu ToUInt64(IFormatProvider) .For a description of this member, see ToUInt64(IFormatProvider).

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