Single Struktura

Definice

public value class float : IComparable, IComparable<float>, IConvertible, IEquatable<float>, IFormattable

public value class float : IComparable<float>, IConvertible, IEquatable<float>, IParsable<float>, ISpanParsable<float>, IUtf8SpanParsable<float>, System::Numerics::IAdditionOperators<float, float, float>, System::Numerics::IAdditiveIdentity<float, float>, System::Numerics::IBinaryFloatingPointIeee754<float>, System::Numerics::IBinaryNumber<float>, System::Numerics::IBitwiseOperators<float, float, float>, System::Numerics::IComparisonOperators<float, float, bool>, System::Numerics::IDecrementOperators<float>, System::Numerics::IDivisionOperators<float, float, float>, System::Numerics::IEqualityOperators<float, float, bool>, System::Numerics::IExponentialFunctions<float>, System::Numerics::IFloatingPoint<float>, System::Numerics::IFloatingPointConstants<float>, System::Numerics::IFloatingPointIeee754<float>, System::Numerics::IHyperbolicFunctions<float>, System::Numerics::IIncrementOperators<float>, System::Numerics::ILogarithmicFunctions<float>, System::Numerics::IMinMaxValue<float>, System::Numerics::IModulusOperators<float, float, float>, System::Numerics::IMultiplicativeIdentity<float, float>, System::Numerics::IMultiplyOperators<float, float, float>, System::Numerics::INumber<float>, System::Numerics::INumberBase<float>, System::Numerics::IPowerFunctions<float>, System::Numerics::IRootFunctions<float>, System::Numerics::ISignedNumber<float>, System::Numerics::ISubtractionOperators<float, float, float>, System::Numerics::ITrigonometricFunctions<float>, System::Numerics::IUnaryNegationOperators<float, float>, System::Numerics::IUnaryPlusOperators<float, float>

public value class float : IComparable, IComparable<float>, IConvertible, IEquatable<float>, ISpanFormattable

public value class float : IComparable<float>, IConvertible, IEquatable<float>, IParsable<float>, ISpanParsable<float>, System::Numerics::IAdditionOperators<float, float, float>, System::Numerics::IAdditiveIdentity<float, float>, System::Numerics::IBinaryFloatingPointIeee754<float>, System::Numerics::IBinaryNumber<float>, System::Numerics::IBitwiseOperators<float, float, float>, System::Numerics::IComparisonOperators<float, float, bool>, System::Numerics::IDecrementOperators<float>, System::Numerics::IDivisionOperators<float, float, float>, System::Numerics::IEqualityOperators<float, float, bool>, System::Numerics::IExponentialFunctions<float>, System::Numerics::IFloatingPoint<float>, System::Numerics::IFloatingPointConstants<float>, System::Numerics::IFloatingPointIeee754<float>, System::Numerics::IHyperbolicFunctions<float>, System::Numerics::IIncrementOperators<float>, System::Numerics::ILogarithmicFunctions<float>, System::Numerics::IMinMaxValue<float>, System::Numerics::IModulusOperators<float, float, float>, System::Numerics::IMultiplicativeIdentity<float, float>, System::Numerics::IMultiplyOperators<float, float, float>, System::Numerics::INumber<float>, System::Numerics::INumberBase<float>, System::Numerics::IPowerFunctions<float>, System::Numerics::IRootFunctions<float>, System::Numerics::ISignedNumber<float>, System::Numerics::ISubtractionOperators<float, float, float>, System::Numerics::ITrigonometricFunctions<float>, System::Numerics::IUnaryNegationOperators<float, float>, System::Numerics::IUnaryPlusOperators<float, float>

public value class float : IComparable, IConvertible, IFormattable

public value class float : IComparable, IComparable<float>, IEquatable<float>, IFormattable

public struct Single : IComparable, IComparable<float>, IConvertible, IEquatable<float>, IFormattable

public readonly struct Single : IComparable<float>, IConvertible, IEquatable<float>, IParsable<float>, ISpanParsable<float>, IUtf8SpanParsable<float>, System.Numerics.IAdditionOperators<float,float,float>, System.Numerics.IAdditiveIdentity<float,float>, System.Numerics.IBinaryFloatingPointIeee754<float>, System.Numerics.IBinaryNumber<float>, System.Numerics.IBitwiseOperators<float,float,float>, System.Numerics.IComparisonOperators<float,float,bool>, System.Numerics.IDecrementOperators<float>, System.Numerics.IDivisionOperators<float,float,float>, System.Numerics.IEqualityOperators<float,float,bool>, System.Numerics.IExponentialFunctions<float>, System.Numerics.IFloatingPoint<float>, System.Numerics.IFloatingPointConstants<float>, System.Numerics.IFloatingPointIeee754<float>, System.Numerics.IHyperbolicFunctions<float>, System.Numerics.IIncrementOperators<float>, System.Numerics.ILogarithmicFunctions<float>, System.Numerics.IMinMaxValue<float>, System.Numerics.IModulusOperators<float,float,float>, System.Numerics.IMultiplicativeIdentity<float,float>, System.Numerics.IMultiplyOperators<float,float,float>, System.Numerics.INumber<float>, System.Numerics.INumberBase<float>, System.Numerics.IPowerFunctions<float>, System.Numerics.IRootFunctions<float>, System.Numerics.ISignedNumber<float>, System.Numerics.ISubtractionOperators<float,float,float>, System.Numerics.ITrigonometricFunctions<float>, System.Numerics.IUnaryNegationOperators<float,float>, System.Numerics.IUnaryPlusOperators<float,float>

public readonly struct Single : IComparable, IComparable<float>, IConvertible, IEquatable<float>, IFormattable

public readonly struct Single : IComparable, IComparable<float>, IConvertible, IEquatable<float>, ISpanFormattable

public readonly struct Single : IComparable<float>, IConvertible, IEquatable<float>, IParsable<float>, ISpanParsable<float>, System.Numerics.IAdditionOperators<float,float,float>, System.Numerics.IAdditiveIdentity<float,float>, System.Numerics.IBinaryFloatingPointIeee754<float>, System.Numerics.IBinaryNumber<float>, System.Numerics.IBitwiseOperators<float,float,float>, System.Numerics.IComparisonOperators<float,float,bool>, System.Numerics.IDecrementOperators<float>, System.Numerics.IDivisionOperators<float,float,float>, System.Numerics.IEqualityOperators<float,float,bool>, System.Numerics.IExponentialFunctions<float>, System.Numerics.IFloatingPoint<float>, System.Numerics.IFloatingPointConstants<float>, System.Numerics.IFloatingPointIeee754<float>, System.Numerics.IHyperbolicFunctions<float>, System.Numerics.IIncrementOperators<float>, System.Numerics.ILogarithmicFunctions<float>, System.Numerics.IMinMaxValue<float>, System.Numerics.IModulusOperators<float,float,float>, System.Numerics.IMultiplicativeIdentity<float,float>, System.Numerics.IMultiplyOperators<float,float,float>, System.Numerics.INumber<float>, System.Numerics.INumberBase<float>, System.Numerics.IPowerFunctions<float>, System.Numerics.IRootFunctions<float>, System.Numerics.ISignedNumber<float>, System.Numerics.ISubtractionOperators<float,float,float>, System.Numerics.ITrigonometricFunctions<float>, System.Numerics.IUnaryNegationOperators<float,float>, System.Numerics.IUnaryPlusOperators<float,float>

[System.Serializable]
public struct Single : IComparable, IConvertible, IFormattable

[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public struct Single : IComparable, IComparable<float>, IConvertible, IEquatable<float>, IFormattable

public struct Single : IComparable, IComparable<float>, IEquatable<float>, IFormattable

type single = struct
    interface IConvertible
    interface IFormattable

type single = struct
    interface IConvertible
    interface IFormattable
    interface IParsable<single>
    interface ISpanFormattable
    interface ISpanParsable<single>
    interface IUtf8SpanFormattable
    interface IUtf8SpanParsable<single>
    interface IAdditionOperators<single, single, single>
    interface IAdditiveIdentity<single, single>
    interface IBinaryFloatingPointIeee754<single>
    interface IBinaryNumber<single>
    interface IBitwiseOperators<single, single, single>
    interface IComparisonOperators<single, single, bool>
    interface IEqualityOperators<single, single, bool>
    interface IDecrementOperators<single>
    interface IDivisionOperators<single, single, single>
    interface IIncrementOperators<single>
    interface IModulusOperators<single, single, single>
    interface IMultiplicativeIdentity<single, single>
    interface IMultiplyOperators<single, single, single>
    interface INumber<single>
    interface INumberBase<single>
    interface ISubtractionOperators<single, single, single>
    interface IUnaryNegationOperators<single, single>
    interface IUnaryPlusOperators<single, single>
    interface IExponentialFunctions<single>
    interface IFloatingPointConstants<single>
    interface IFloatingPoint<single>
    interface ISignedNumber<single>
    interface IFloatingPointIeee754<single>
    interface IHyperbolicFunctions<single>
    interface ILogarithmicFunctions<single>
    interface IPowerFunctions<single>
    interface IRootFunctions<single>
    interface ITrigonometricFunctions<single>
    interface IMinMaxValue<single>

type single = struct
    interface IConvertible
    interface ISpanFormattable
    interface IFormattable

type single = struct
    interface IConvertible
    interface IFormattable
    interface IParsable<single>
    interface ISpanFormattable
    interface ISpanParsable<single>
    interface IAdditionOperators<single, single, single>
    interface IAdditiveIdentity<single, single>
    interface IBinaryFloatingPointIeee754<single>
    interface IBinaryNumber<single>
    interface IBitwiseOperators<single, single, single>
    interface IComparisonOperators<single, single, bool>
    interface IEqualityOperators<single, single, bool>
    interface IDecrementOperators<single>
    interface IDivisionOperators<single, single, single>
    interface IIncrementOperators<single>
    interface IModulusOperators<single, single, single>
    interface IMultiplicativeIdentity<single, single>
    interface IMultiplyOperators<single, single, single>
    interface INumber<single>
    interface INumberBase<single>
    interface ISubtractionOperators<single, single, single>
    interface IUnaryNegationOperators<single, single>
    interface IUnaryPlusOperators<single, single>
    interface IExponentialFunctions<single>
    interface IFloatingPointConstants<single>
    interface IFloatingPoint<single>
    interface ISignedNumber<single>
    interface IFloatingPointIeee754<single>
    interface IHyperbolicFunctions<single>
    interface ILogarithmicFunctions<single>
    interface IPowerFunctions<single>
    interface IRootFunctions<single>
    interface ITrigonometricFunctions<single>
    interface IMinMaxValue<single>

type single = struct
    interface IConvertible
    interface IFormattable
    interface IParsable<single>
    interface ISpanFormattable
    interface ISpanParsable<single>
    interface IAdditionOperators<single, single, single>
    interface IAdditiveIdentity<single, single>
    interface IBinaryFloatingPointIeee754<single>
    interface IBinaryNumber<single>
    interface IBitwiseOperators<single, single, single>
    interface IComparisonOperators<single, single, bool>
    interface IEqualityOperators<single, single, bool>
    interface IDecrementOperators<single>
    interface IDivisionOperators<single, single, single>
    interface IIncrementOperators<single>
    interface IModulusOperators<single, single, single>
    interface IMultiplicativeIdentity<single, single>
    interface IMultiplyOperators<single, single, single>
    interface INumber<single>
    interface INumberBase<single>
    interface ISubtractionOperators<single, single, single>
    interface IUnaryNegationOperators<single, single>
    interface IUnaryPlusOperators<single, single>
    interface IUtf8SpanFormattable
    interface IUtf8SpanParsable<single>
    interface IExponentialFunctions<single>
    interface IFloatingPointConstants<single>
    interface IFloatingPoint<single>
    interface ISignedNumber<single>
    interface IFloatingPointIeee754<single>
    interface IHyperbolicFunctions<single>
    interface ILogarithmicFunctions<single>
    interface IPowerFunctions<single>
    interface IRootFunctions<single>
    interface ITrigonometricFunctions<single>
    interface IMinMaxValue<single>

[<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 IAdditionOperators(Of Single, Single, Single), IAdditiveIdentity(Of Single, Single), IBinaryFloatingPointIeee754(Of Single), IBinaryNumber(Of Single), IBitwiseOperators(Of Single, Single, Single), IComparable(Of Single), IComparisonOperators(Of Single, Single, Boolean), IConvertible, IDecrementOperators(Of Single), IDivisionOperators(Of Single, Single, Single), IEqualityOperators(Of Single, Single, Boolean), IEquatable(Of Single), IExponentialFunctions(Of Single), IFloatingPoint(Of Single), IFloatingPointConstants(Of Single), IFloatingPointIeee754(Of Single), IHyperbolicFunctions(Of Single), IIncrementOperators(Of Single), ILogarithmicFunctions(Of Single), IMinMaxValue(Of Single), IModulusOperators(Of Single, Single, Single), IMultiplicativeIdentity(Of Single, Single), IMultiplyOperators(Of Single, Single, Single), INumber(Of Single), INumberBase(Of Single), IParsable(Of Single), IPowerFunctions(Of Single), IRootFunctions(Of Single), ISignedNumber(Of Single), ISpanParsable(Of Single), ISubtractionOperators(Of Single, Single, Single), ITrigonometricFunctions(Of Single), IUnaryNegationOperators(Of Single, Single), IUnaryPlusOperators(Of Single, Single), IUtf8SpanParsable(Of Single)

Public Structure Single
Implements IComparable, IComparable(Of Single), IConvertible, IEquatable(Of Single), ISpanFormattable

Public Structure Single
Implements IAdditionOperators(Of Single, Single, Single), IAdditiveIdentity(Of Single, Single), IBinaryFloatingPointIeee754(Of Single), IBinaryNumber(Of Single), IBitwiseOperators(Of Single, Single, Single), IComparable(Of Single), IComparisonOperators(Of Single, Single, Boolean), IConvertible, IDecrementOperators(Of Single), IDivisionOperators(Of Single, Single, Single), IEqualityOperators(Of Single, Single, Boolean), IEquatable(Of Single), IExponentialFunctions(Of Single), IFloatingPoint(Of Single), IFloatingPointConstants(Of Single), IFloatingPointIeee754(Of Single), IHyperbolicFunctions(Of Single), IIncrementOperators(Of Single), ILogarithmicFunctions(Of Single), IMinMaxValue(Of Single), IModulusOperators(Of Single, Single, Single), IMultiplicativeIdentity(Of Single, Single), IMultiplyOperators(Of Single, Single, Single), INumber(Of Single), INumberBase(Of Single), IParsable(Of Single), IPowerFunctions(Of Single), IRootFunctions(Of Single), ISignedNumber(Of Single), ISpanParsable(Of Single), ISubtractionOperators(Of Single, Single, Single), ITrigonometricFunctions(Of Single), IUnaryNegationOperators(Of Single, Single), IUnaryPlusOperators(Of Single, Single)

Public Structure Single
Implements IComparable, IConvertible, IFormattable

Public Structure Single
Implements IComparable, IComparable(Of Single), IEquatable(Of Single), IFormattable

Dědičnost

Object

ValueType

Single

Atributy

SerializableAttribute ComVisibleAttribute

Implementuje

IComparable IComparable<Single> IConvertible IEquatable<Single> IFormattable IComparable<TSelf> IEquatable<TSelf> IParsable<Single> IParsable<TSelf> ISpanFormattable ISpanParsable<Single> ISpanParsable<TSelf> IUtf8SpanFormattable IUtf8SpanParsable<Single> IUtf8SpanParsable<TSelf> IAdditionOperators<Single,Single,Single> IAdditionOperators<TSelf,TSelf,TSelf> IAdditiveIdentity<Single,Single> IAdditiveIdentity<TSelf,TSelf> IBinaryFloatingPointIeee754<Single> IBinaryNumber<Single> IBinaryNumber<TSelf> IBitwiseOperators<Single,Single,Single> IBitwiseOperators<TSelf,TSelf,TSelf> IComparisonOperators<Single,Single,Boolean> IComparisonOperators<TSelf,TSelf,Boolean> IDecrementOperators<Single> IDecrementOperators<TSelf> IDivisionOperators<Single,Single,Single> IDivisionOperators<TSelf,TSelf,TSelf> IEqualityOperators<Single,Single,Boolean> IEqualityOperators<TSelf,TOther,TResult> IEqualityOperators<TSelf,TSelf,Boolean> IExponentialFunctions<Single> IExponentialFunctions<TSelf> IFloatingPoint<Single> IFloatingPoint<TSelf> IFloatingPointConstants<Single> IFloatingPointConstants<TSelf> IFloatingPointIeee754<Single> IFloatingPointIeee754<TSelf> IHyperbolicFunctions<Single> IHyperbolicFunctions<TSelf> IIncrementOperators<Single> IIncrementOperators<TSelf> ILogarithmicFunctions<Single> ILogarithmicFunctions<TSelf> IMinMaxValue<Single> IModulusOperators<Single,Single,Single> IModulusOperators<TSelf,TSelf,TSelf> IMultiplicativeIdentity<Single,Single> IMultiplicativeIdentity<TSelf,TSelf> IMultiplyOperators<Single,Single,Single> IMultiplyOperators<TSelf,TSelf,TSelf> INumber<Single> INumber<TSelf> INumberBase<Single> INumberBase<TSelf> IPowerFunctions<Single> IPowerFunctions<TSelf> IRootFunctions<Single> IRootFunctions<TSelf> ISignedNumber<Single> ISignedNumber<TSelf> ISubtractionOperators<Single,Single,Single> ISubtractionOperators<TSelf,TSelf,TSelf> ITrigonometricFunctions<Single> ITrigonometricFunctions<TSelf> IUnaryNegationOperators<Single,Single> IUnaryNegationOperators<TSelf,TSelf> IUnaryPlusOperators<Single,Single> IUnaryPlusOperators<TSelf,TSelf>

Poznámky

Typ hodnoty Single představuje jednopřesné 32bitové číslo s hodnotami v rozsahu od záporných 3,402823e38 až po kladné 3,402823e38, stejně jako kladné nebo záporné nuly, PositiveInfinity, NegativeInfinitya nikoli číslo (NaN). Má představovat hodnoty, které jsou extrémně velké (například vzdálenosti mezi planetami nebo galaxiemi) nebo extrémně malé (například molekulární hmotnost látky v kg) a které jsou často nepřesné (například vzdálenost od země k jinému slunečnímu systému). Typ Single odpovídá standardu IEC 60559:1989 (IEEE 754) pro binární plovoucí desetinnou čárku.

System.Single poskytuje metody pro porovnání instancí tohoto typu, pro převod hodnoty instance na řetězcové vyjádření a převod řetězcové reprezentace čísla na instanci tohoto typu. Informace o tom, jak kódy formátu specifikace řídí řetězcové znázornění typů hodnot, naleznete v tématu Typy formátování, standardní číselné formátovací řetězcea vlastní číselné formátovací řetězce.

Reprezentace a přesnost čísel s plovoucí desetinnou čárkou

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

Stejně jako desetinné zlomky nemohou přesně reprezentovat některé desetinné hodnoty (například 1/3 nebo Math.PI), binární zlomky nemohou představovat některé desetinné hodnoty. Například 2/10, který je reprezentován přesně jako 0,2 v desetinném číselném vyjádření, je reprezentován jako .0011111001001100 jako binární zlomek, se vzorem "1100", který se opakuje do nekonečna. V tomto případě hodnota s plovoucí desetinnou čárkou reprezentuje číslo nepřesně. Provádění dalších matematických operací na původní hodnotě s plovoucí desetinnou čárkou často snižuje její přesnost. Pokud například porovnáte výsledky násobení 0,3 číslem 10 a přičtením 0,3 až 0,3 devětkrát, uvidíte, že sčítání produkuje méně přesný výsledek, protože zahrnuje osm více operací než násobení. Všimněte si, že tato rozdílnost je zřejmá pouze v případě, že zobrazíte dvě hodnoty Single pomocí standardního číselného formátu "R" , který v případě potřeby zobrazí všech 9 číslic přesnosti podporovaných typem Single.

using System;

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

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

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

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

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

' The example displays the following output:
'       .2 * 10:           2
'       .2 Added 10 times: 2.0000002

Protože některá čísla nemohou být reprezentována přesně jako binární hodnoty, mohou čísla s plovoucí desetinnou čárkou pouze přibližovat reálná čísla.

Všechna čísla s plovoucí řádovou čárkou mají omezený počet platných číslic, což také určuje, jak přesně hodnota s plovoucí řádovou čárkou přibližuje skutečné číslo. Hodnota Single má až 7 desetinných míst přesnosti, i když se interně udržuje maximálně 9 číslic. To znamená, že některé operace s plovoucí desetinnou čárkou nemusí mít dostatečnou přesnost ke změně hodnoty s plovoucí desetinnou čárkou. Následující příklad definuje velkou hodnotu v plovoucí desetinné čárce s jednoduchou přesností a potom k ní přidá součin Single.Epsilon a jednoho kvadrilionu. Produkt je však příliš malý, aby změnil původní hodnotu s plovoucí desetinnou čárkou. Nejméně významná číslice je tisíciny, zatímco nejvýznamnější číslice v produktu je 10^-30.

using System;

public class Example13
{
    public static void Main()
    {
        Single value = 123.456f;
        Single additional = Single.Epsilon * 1e15f;
        Console.WriteLine($"{value} + {additional} = {value + additional}");
    }
}

// The example displays the following output:
//    123.456 + 1.401298E-30 = 123.456

open System

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

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

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

• Dvě čísla s plovoucí desetinnou čárkou, která se zdají být stejná pro určitou přesnost, nemusí při porovnání být rovna, protože jejich nejméně významné číslice se liší. V následujícím příkladu se sečtou řady čísel a jejich celkový součet se porovná s očekávaným součtem. Volání Equals metody označuje, že hodnoty nejsou stejné.

  using System;
  
  public class PrecisionList3Example
  {
      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 ({total}) does not equal the total ({result}).");
      }
  }
  
  // The example displays the following output on .NET:
  //      The sum of the values (27.650002) does not equal the total (27.65).
  // The example displays the following output on .NET Framework:
  //      The sum of the values (27.65) does not equal the total (27.65).
  

  let values = [| 10.01f; 2.88f; 2.88f; 2.88f; 9f |]
  let result = 27.65f
  let mutable total = 0f
  for value in values do
      total <- total + value
  
  if total.Equals result then
      printfn "The sum of the values equals the total."
  else
      printfn "The sum of the values ({total}) does not equal the total ({result})."
  // The example displays the following output:
  //      The sum of the values (27.65) does not equal the total (27.65).   
  //
  // If the index items in the Console.WriteLine statement are changed to {0:R},
  // the example displays the following output:
  //       The sum of the values (27.6500015) does not equal the total (27.65).
  

      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 ({total}) does not equal the total ({result}).")
      End If
  End Sub
  
  ' The example displays the following output on .NET:
  '      The sum of the values (27.650002) does not equal the total (27.65).
  ' The example displays the following output on .NET Framework:
  '      The sum of the values (27.65) does not equal the total (27.65).
  

  Tyto dvě hodnoty jsou nerovné kvůli ztrátě přesnosti během operací sčítání. V takovém případě je možné problém vyřešit voláním metody Math.Round(Double, Int32), která před porovnáním zaokrouhlí hodnoty Single na požadovanou přesnost.

• Matematická nebo porovnávací operace, která používá číslo s plovoucí desetinnou čárkou, nemusí přinést stejný výsledek, pokud se použije desetinné číslo, protože binární číslo s plovoucí desetinnou čárkou se nemusí shodovat s desetinným číslem. Předchozí příklad znázorňuje výsledek vynásobení 0,3 číslem 10 a přičtením 0,3 do 0,3 devětkrát.

  Pokud je přesnost v numerických operacích s desetinnými hodnotami důležitá, použijte místo Decimal typu typ Single. Pokud je přesnost v numerických operacích s celočíselnými hodnotami nad rozsahem typů Int64 nebo UInt64 důležitá, použijte typ BigInteger.

• Single hodnoty mají menší přesnost než Double hodnoty. Hodnota Single převedená na zdánlivě ekvivalentní Double se často nerovná Double hodnotě kvůli rozdílům v přesnosti. V následujícím příkladu je výsledek identických operací dělení přiřazen k hodnotě Double a hodnotě Single. Po přetypování hodnoty Single na Doubleukazuje porovnání dvou hodnot, že jsou nerovné.

  using System;
  
  public class Example9
  {
      public static void Run()
      {
          double value1 = 1 / 3.0;
          float sValue2 = 1 / 3.0f;
          double value2 = (double)sValue2;
          Console.WriteLine($"{value1:R} = {value2:R}: {value1.Equals(value2)}");
      }
  }
  
  // The example displays the following output:
  //        0.33333333333333331 = 0.3333333432674408: False
  

  open System
  
  let value1 = 1. / 3.
  let sValue2 = 1f /3f
  
  let value2 = double sValue2
  printfn $"{value1:R} = {value2:R}: {value1.Equals value2}"
  // The example displays the following output:
  //        0.33333333333333331 = 0.3333333432674408: False
  

  Module Example10
      Public Sub Run()
          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, použijte Double datový typ místo Single datového typu, nebo použijte metodu Round tak, aby obě hodnoty měly stejnou přesnost.

Testování rovnosti

Aby byly považovány za stejné, musí dvě Single hodnoty představovat stejné hodnoty. Vzhledem k rozdílům v přesnosti mezi hodnotami nebo kvůli ztrátě přesnosti o jednu nebo obě hodnoty však hodnoty s plovoucí desetinnou čárkou, u které se očekává, že budou identické, se často zdají být nerovné kvůli rozdílům v nejméně významných číslicích. Výsledkem je, že volání Equals metody určující, zda jsou dvě hodnoty stejné, nebo volání CompareTo metody k určení vztahu mezi dvěma Single hodnotami, často poskytují neočekávané výsledky. To je zřejmé v následujícím příkladu, kdy se dvě zdánlivě stejné Single hodnoty ukázaly jako nerovné, protože první hodnota má 7 číslic přesnosti, zatímco druhá hodnota má 9.

using System;

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

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

Module Example1
    Public Sub Main()
        Dim value1 As Single = 0.3333333
        Dim value2 As Single = 1 / 3
        Console.WriteLine("{0:R} = {1:R}: {2}", value1, value2, value1.Equals(value2))
    End Sub
End Module
' The example displays the following output:
'       0.3333333 = 0.333333343: False

Počítané hodnoty, které se řídí různými cestami kódu a které jsou manipulovány různými způsoby, se často ukazují jako nerovné. V následujícím příkladu je jedna hodnota Single umocněna na druhou a pak je vypočítána druhá odmocnina k obnovení původní hodnoty. Druhý Single se vynásobí hodnotou 3,51 a umocní na druhou, poté se odmocnina výsledku vydělí hodnotou 3,51, aby se obnovila původní hodnota. I když se tyto dvě hodnoty jeví jako identické, volání metody Equals(Single) znamená, že nejsou stejné.

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($"{value1} = {value2}: {value1.Equals(value2)}");

// The example displays the following output on .NET:
//       10.201438 = 10.201439: False
// The example displays the following output on .NET Framework:
//       10.20144 = 10.20144: False

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

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

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

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

' The example displays the following output on .NET:
'       10.201438 = 10.201439: False
' The example displays the following output on .NET Framework:
'       10.20144 = 10.20144: False

V případech, kdy ztráta přesnosti pravděpodobně ovlivní výsledek porovnání, můžete místo volání Equals nebo metody CompareTo použít následující techniky:

• Zavolejte metodu Math.Round, abyste zajistili, že obě hodnoty mají stejnou přesnost. Následující příklad upraví předchozí příklad tak, aby tento přístup používal tak, aby dvě desetinné hodnoty byly ekvivalentní.

  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($"{value1:R} = {value2:R}: {value1.Equals(value2)}");
  
  // The example displays the following output:
  //        0.3333333 = 0.3333333: True
  

  open System
  
  let value1 = 0.3333333f
  let value2 = 1f / 3f
  let precision = 7
  let value1r = Math.Round(float value1, precision) |> float32
  let value2r = Math.Round(float value2, precision) |> float32
  printfn $"{value1:R} = {value2:R}: {value1.Equals value2}"
  // The example displays the following output:
  //        0.3333333 = 0.3333333: True
  

  Module Example3
      Public Sub Main()
          Dim value1 As Single = 0.3333333
          Dim value2 As Single = 1 / 3
          Dim precision As Integer = 7
          value1 = CSng(Math.Round(value1, precision))
          value2 = CSng(Math.Round(value2, precision))
          Console.WriteLine("{0:R} = {1:R}: {2}", value1, value2, value1.Equals(value2))
      End Sub
  End Module
  ' The example displays the following output:
  '       0.3333333 = 0.3333333: True
  

  Problém přesnosti se stále týká zaokrouhlování středních hodnot. Další informace najdete v metodě Math.Round(Double, Int32, MidpointRounding).

• Otestujte přibližnou rovnost místo rovnosti. Tato technika vyžaduje, abyste definovali buď absolutní částku, o kterou se tyto dvě hodnoty mohou lišit, ale stále se rovnají, nebo definujete relativní množství, o které se menší hodnota může od větší hodnoty lišit.

  Warning

  Single.Epsilon se při testování rovnosti někdy používá jako absolutní míra vzdálenosti mezi dvěma Single hodnotami. Single.Epsilon však měří nejmenší možnou hodnotu, kterou lze přičíst k, nebo odečíst od, Single, jehož hodnota je nula. U většiny kladných a záporných hodnot Single je hodnota Single.Epsilon příliš malá, aby se zjistila. Proto s výjimkou hodnot, které jsou nula, nedoporučujeme jeho použití v testech rovnosti.

  Následující příklad používá druhý přístup k definování IsApproximatelyEqual metody, která testuje relativní rozdíl mezi dvěma hodnotami. Také kontrastuje výsledky volání metody IsApproximatelyEqual a metody Equals(Single).

  public static void Main()
  {
      float one1 = .1f * 10;
      float one2 = 0f;
      for (int ctr = 1; ctr <= 10; ctr++)
          one2 += .1f;
  
      Console.WriteLine($"{one1:R} = {one2:R}: {one1.Equals(one2)}");
      Console.WriteLine($"{one1:R} is approximately equal to {one2:R}: " +
          $"{IsApproximatelyEqual(one1, one2, .000001f)}");
  
      float negativeOne1 = -1 * one1;
      float negativeOne2 = -1 * one2;
  
      Console.WriteLine($"{negativeOne1:R} = {negativeOne2:R}: {negativeOne1.Equals(negativeOne2)}");
      Console.WriteLine($"{negativeOne1:R} is approximately equal to {negativeOne2:R}: " +
          $"{IsApproximatelyEqual(negativeOne1, negativeOne2, .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 on .NET:
  //       1 = 1.0000001: False
  //       1 is approximately equal to 1.0000001: True
  //       -1 = -1.0000001: False
  //       -1 is approximately equal to -1.0000001: True
  

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

  Public Sub Main()
      Dim one1 As Single = 0.1 * 10
      Dim one2 As Single = 0
      For ctr As Integer = 1 To 10
          one2 += CSng(0.1)
      Next
      Console.WriteLine("{0:R} = {1:R}: {2}", one1, one2, one1.Equals(one2))
      Console.WriteLine("{0:R} is approximately equal to {1:R}: {2}",
                      one1, one2,
                      IsApproximatelyEqual(one1, one2, 0.000001))
  End Sub
  
  Function IsApproximatelyEqual(value1 As Single, value2 As Single,
                               epsilon As Single) As Boolean
      ' If they are equal anyway, just return True.
      If value1.Equals(value2) Then Return True
  
      ' Handle NaN, Infinity.
      If Single.IsInfinity(value1) Or Single.IsNaN(value1) Then
          Return value1.Equals(value2)
      ElseIf Single.IsInfinity(value2) Or Single.IsNaN(value2) Then
          Return value1.Equals(value2)
      End If
  
      ' Handle zero to avoid division by zero.
      Dim divisor As Single = Math.Max(value1, value2)
      If divisor.Equals(0) Then
          divisor = Math.Min(value1, value2)
      End If
  
      Return Math.Abs(value1 - value2) / divisor <= epsilon
  End Function
  
  ' The example displays the following output:
  '       1 = 1.0000001: False
  '       1 is approximately equal to 1.0000001: True
  

Hodnoty a výjimky s plovoucí řádovou čárkou

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

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

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

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

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

• Pokud velikost výsledku operace s plovoucí desetinnou čárkou překročí rozsah cílového formátu, výsledek operace je PositiveInfinity nebo NegativeInfinity, v závislosti na znaménku výsledku. Výsledek operace přetékající Single.MaxValue je PositiveInfinitya operace přetékající Single.MinValue je NegativeInfinity, jak ukazuje následující příklad.

  float value1 = 3.065e35f;
  float value2 = 6.9375e32f;
  float result = value1 * value2;
  Console.WriteLine($"PositiveInfinity: {Single.IsPositiveInfinity(result)}");
  Console.WriteLine($"NegativeInfinity: {Single.IsNegativeInfinity(result)}");
  Console.WriteLine();
  
  value1 = -value1;
  result = value1 * value2;
  Console.WriteLine($"PositiveInfinity: {Single.IsPositiveInfinity(result)}");
  Console.WriteLine($"NegativeInfinity: {Single.IsNegativeInfinity(result)}");
  
  // The example displays the following output:
  //       PositiveInfinity: True
  //       NegativeInfinity: False
  //
  //       PositiveInfinity: False
  //       NegativeInfinity: True
  

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

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

  PositiveInfinity je také výsledkem dělení nulou pro kladný dividenda a NegativeInfinity je výsledkem dělení nulou pro záporný dividenda.

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

  • Dělení nulou, kde dělenec je nula. Všimněte si, že jiné případy dělení nulou mají za následek PositiveInfinity nebo NegativeInfinity.
  • Jakákoli operace s plovoucí desetinnou čárkou s neplatným vstupem. Například pokus o nalezení druhé odmocniny záporné hodnoty vrátí NaN.
  • Jakákoli operace s argumentem, jehož hodnota je Single.NaN.

Převody typů

Struktura Single nedefinuje žádné explicitní ani implicitní převodní operátory; místo toho kompilátor implementuje převody.

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

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

using System;

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

open System

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

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

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

Kromě toho se hodnoty DoubleDouble.NaN, Double.PositiveInfinitya Double.NegativeInfinity převedou na Single.NaN, Single.PositiveInfinitya Single.NegativeInfinity.

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

Převod hodnoty Single na Double je rozšiřující konverze. Převod může vést ke ztrátě přesnosti, pokud typ Double nemá přesné vyjádření hodnoty Single.

Převod hodnoty Single 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 jazyce Visual Basic). Hodnoty, které jsou mimo rozsah cílového datového typu, definované vlastnostmi MinValue a MaxValue tohoto typu, se chovají, jak je znázorněno v následující tabulce.

Kromě toho Single.NaN, Single.PositiveInfinitya Single.NegativeInfinity vyvolají OverflowException pro převody na celá čísla v kontrolovaném kontextu, ale tyto hodnoty přetékají při převodu na celá čísla v nekontrolovaném kontextu. Pro převody na Decimalvždy vyvolají OverflowException. Při převodech na Doublese přemění na Double.NaN, Double.PositiveInfinitya Double.NegativeInfinity, v uvedeném pořadí.

Všimněte si, že ztráta přesnosti může mít za následek převod hodnoty Single na jiný číselný typ. V případě převodu nenedílnou Single hodnot, jak ukazuje výstup z příkladu, se zlomková komponenta ztratí, když je hodnota Single buď zaokrouhlená (jako v jazyce Visual Basic), nebo zkrácená (jako v jazyce C# a F#). U převodů na Decimal hodnoty nemusí mít hodnota Single přesné vyjádření v cílovém datovém typu.

Následující příklad převede počet Single hodnot na několik dalších číselných typů. Převody probíhají v kontrolovaném kontextu v jazyce Visual Basic (výchozí), v jazyce C# (kvůli zaškrtnutému klíčovému slovu) a v jazyce F# (z důvodu příkazu open Checked). Výstup z příkladu ukazuje výsledek pro převody jak v zaškrtnutém, tak i nezaškrtnutém kontextu. Převody v nezaškrtnutém kontextu v jazyce Visual Basic můžete provést kompilováním přepínače kompilátoru /removeintchecks+, v jazyce C# zakomentováním příkazu checked a v jazyce F# zakomentováním příkazu open Checked.

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($"{value} ({value.GetType().Name}) --> {lValue} (0x{lValue:X16}) ({lValue.GetType().Name})");
        }
        catch (OverflowException)
        {
            Console.WriteLine($"Unable to convert {value} to Int64.");
        }
        try
        {
            UInt64 ulValue = (ulong)value;
            Console.WriteLine($"{value} ({value.GetType().Name}) --> {ulValue} (0x{ulValue:X16}) ({ulValue.GetType().Name})");
        }
        catch (OverflowException)
        {
            Console.WriteLine($"Unable to convert {value} to UInt64.");
        }
        try
        {
            Decimal dValue = (decimal)value;
            Console.WriteLine($"{value} ({value.GetType().Name}) --> {dValue} ({dValue.GetType().Name})");
        }
        catch (OverflowException)
        {
            Console.WriteLine($"Unable to convert {value} to Decimal.");
        }

        Double dblValue = value;
        Console.WriteLine($"{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 ∞ to Int64.
//       Unable to convert ∞ to UInt64.
//       Unable to convert ∞ to Decimal.
//       ∞ (Single) --> ∞ (Double)
//
//       Unable to convert -∞ to Int64.
//       Unable to convert -∞ to UInt64.
//       Unable to convert -∞ to Decimal.
//       -∞ (Single) --> -∞ (Double)

open System
open Checked

let values = 
    [ Single.MinValue; -67890.1234f; -12345.6789f
      12345.6789f; 67890.1234f; Single.MaxValue
      Single.NaN; Single.PositiveInfinity
      Single.NegativeInfinity ]

for value in values do
    try
        let lValue = int64 value
        printfn $"{value} ({value.GetType().Name}) --> {lValue} (0x{lValue:X16}) ({lValue.GetType().Name})"
    with :? OverflowException ->
        printfn $"Unable to convert {value} to Int64."
    try
        let ulValue = uint64 value
        printfn $"{value} ({value.GetType().Name}) --> {ulValue} (0x{ulValue:X16}) ({ulValue.GetType().Name})"
    with :? OverflowException ->
        printfn $"Unable to convert {value} to UInt64."
    try
        let dValue = decimal value
        printfn $"{value} ({value.GetType().Name}) --> {dValue} ({dValue.GetType().Name})"
    with :? OverflowException ->
        printfn $"Unable to convert {value} to Decimal."

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

Module Example6
    Public Sub Main()
        Dim values() As Single = {Single.MinValue, -67890.1234, -12345.6789,
                                 12345.6789, 67890.1234, Single.MaxValue,
                                 Single.NaN, Single.PositiveInfinity,
                                 Single.NegativeInfinity}
        For Each value In values
            Try
                Dim lValue As Long = CLng(value)
                Console.WriteLine("{0} ({1}) --> {2} (0x{2:X16}) ({3})",
                               value, value.GetType().Name,
                               lValue, lValue.GetType().Name)
            Catch e As OverflowException
                Console.WriteLine("Unable to convert {0} to Int64.", value)
            End Try
            Try
                Dim ulValue As UInt64 = CULng(value)
                Console.WriteLine("{0} ({1}) --> {2} (0x{2:X16}) ({3})",
                               value, value.GetType().Name,
                               ulValue, ulValue.GetType().Name)
            Catch e As OverflowException
                Console.WriteLine("Unable to convert {0} to UInt64.", value)
            End Try
            Try
                Dim dValue As Decimal = CDec(value)
                Console.WriteLine("{0} ({1}) --> {2} ({3})",
                               value, value.GetType().Name,
                               dValue, dValue.GetType().Name)
            Catch e As OverflowException
                Console.WriteLine("Unable to convert {0} to Decimal.", value)
            End Try

            Dim dblValue As Double = value
            Console.WriteLine("{0} ({1}) --> {2} ({3})",
                           value, value.GetType().Name,
                           dblValue, dblValue.GetType().Name)
            Console.WriteLine()
        Next
    End Sub
End Module

' The example displays the following output for conversions performed
' in a checked context:
'       Unable to convert -3.402823E+38 to Int64.
'       Unable to convert -3.402823E+38 to UInt64.
'       Unable to convert -3.402823E+38 to Decimal.
'       -3.402823E+38 (Single) --> -3.40282346638529E+38 (Double)
'
'       -67890.13 (Single) --> -67890 (0xFFFFFFFFFFFEF6CE) (Int64)
'       Unable to convert -67890.13 to UInt64.
'       -67890.13 (Single) --> -67890.12 (Decimal)
'       -67890.13 (Single) --> -67890.125 (Double)
'
'       -12345.68 (Single) --> -12346 (0xFFFFFFFFFFFFCFC6) (Int64)
'       Unable to convert -12345.68 to UInt64.
'       -12345.68 (Single) --> -12345.68 (Decimal)
'       -12345.68 (Single) --> -12345.6787109375 (Double)
'
'       12345.68 (Single) --> 12346 (0x000000000000303A) (Int64)
'       12345.68 (Single) --> 12346 (0x000000000000303A) (UInt64)
'       12345.68 (Single) --> 12345.68 (Decimal)
'       12345.68 (Single) --> 12345.6787109375 (Double)
'
'       67890.13 (Single) --> 67890 (0x0000000000010932) (Int64)
'       67890.13 (Single) --> 67890 (0x0000000000010932) (UInt64)
'       67890.13 (Single) --> 67890.12 (Decimal)
'       67890.13 (Single) --> 67890.125 (Double)
'
'       Unable to convert 3.402823E+38 to Int64.
'       Unable to convert 3.402823E+38 to UInt64.
'       Unable to convert 3.402823E+38 to Decimal.
'       3.402823E+38 (Single) --> 3.40282346638529E+38 (Double)
'
'       Unable to convert NaN to Int64.
'       Unable to convert NaN to UInt64.
'       Unable to convert NaN to Decimal.
'       NaN (Single) --> NaN (Double)
'
'       Unable to convert ∞ to Int64.
'       Unable to convert ∞ to UInt64.
'       Unable to convert ∞ to Decimal.
'       ∞ (Single) --> ∞ (Double)
'
'       Unable to convert -∞ to Int64.
'       Unable to convert -∞ to UInt64.
'       Unable to convert -∞ to Decimal.
'       -∞ (Single) --> -∞ (Double)

Další informace o převodu číselných typů naleznete v tématu Type Conversion in .NET and Type Conversion Tables.

Funkce s plovoucí čárkou

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

• Porovnání hodnot. Metodu Equals můžete volat, abyste zjistili, zda jsou dvě Single hodnoty stejné, nebo CompareTo metodu pro určení vztahu mezi dvěma hodnotami.

  Struktura Single také podporuje úplnou sadu relačních operátorů. Můžete například otestovat rovnost nebo nerovnost nebo určit, jestli je jedna hodnota větší nebo rovna jiné hodnotě. Pokud je jedním z operandů Double, hodnota Single se před porovnáním převede na Double. Pokud je jedním z operandů celočíselný typ, před provedením porovnání se převede na Single. I když se jedná o konverze se širším rozsahem, při kterých může dojít ke ztrátě přesnosti.

  Warning

  Vzhledem k rozdílům v přesnosti mohou být dvě Single hodnoty, u kterých očekáváte, že budou stejné, ve skutečnosti nerovné, což má vliv na výsledek porovnání. Další informace o porovnání dvou hodnot najdete v části Single.

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

• matematické operace. Běžné aritmetické operace, jako jsou sčítání, odčítání, násobení a dělení, jsou implementovány kompilátory jazyka a instrukcemi CIL (Common Intermediate Language) místo metodami Single. Pokud je druhý operand v matematické operaci Double, Single se před provedením operace převede na Double a výsledek operace je také Double hodnota. Pokud je druhý operand celočíselný typ, je před provedením operace převeden na Single a výsledek operace je také Single hodnota.

  Další matematické operace můžete provádět voláním metod static (Shared v jazyce Visual Basic) ve třídě System.Math. Patří mezi ně další metody běžně používané pro aritmetické metody (například Math.Abs, Math.Signa Math.Sqrt), geometrii (například Math.Cos a Math.Sin) a kalkulus (například Math.Log). Ve všech případech se hodnota Single převede na Double.

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

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

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

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

• Převod typu. Struktura Single poskytuje explicitní implementaci rozhraní pro rozhraní IConvertible, které podporuje převod mezi libovolnými dvěma standardními datovými typy .NET. 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. Převod hodnoty jiného standardního číselného typu než Double na Single je rozšiřující převod a nevyžaduje použití operátoru přetypování nebo metody převodu.

  Převod 32bitové a 64bitové celočíselné hodnoty ale může zahrnovat ztrátu přesnosti. Následující tabulka uvádí rozdíly v přesnosti pro 32bitové, 64bitové a Double typy:

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

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

  Double value1 = 1 / 3.0;
  Single sValue2 = 1 / 3.0f;
  Double value2 = (Double)sValue2;
  Console.WriteLine($"{value1:R} = {value2:R}: {value1.Equals(value2)}");
  
  // The example displays the following output on .NET:
  //        0.3333333333333333 = 0.3333333432674408: False
  

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

  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))
  
  ' The example displays the following output:
  '       0.3333333333333333 = 0.3333333432674408: False
  

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

Všichni členové tohoto typu jsou bezpečné pro přístup z více vláken. Členové, kteří se zdá, že upravují stav instance, ve skutečnosti vrátí novou instanci inicializovanou s novou hodnotou. Stejně jako u jakéhokoli jiného typu musí být čtení a zápis do sdílené proměnné, která obsahuje instanci tohoto typu, chráněn zámkem, aby se zajistilo zabezpečení vlákna.

Viz také

• Decimal
• Double