Single Struktura

Definicja

Przestrzeń nazw:

System

Zestawy:

netstandard.dll, System.Runtime.dll

Źródło:

Single.cs

Reprezentuje liczbę zmiennoprzecinkową o pojedynczej precyzji.

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

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>

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)

Dziedziczenie

Object

ValueType

Single

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>

Uwagi

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

System.Single Udostępnia metody porównywania wystąpień tego typu, aby przekonwertować wartość wystąpienia na jego reprezentację ciągu i przekonwertować reprezentację ciągu liczby na wystąpienie tego typu. Informacje o tym, jak kody specyfikacji formatu kontrolują reprezentację typów wartości jako ciągów, można znaleźć w tematach Typy formatowania, Standardowe ciągi formatu liczbowego oraz Niestandardowe ciągi formatu liczbowego.

Reprezentacja zmiennoprzecinkowa i precyzja

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

Część	Bity
Część znacząca lub mantysa	0-22
Exponent	23-30
Znak (0 = dodatni, 1 = ujemny)	31

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

using System;

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

        Console.WriteLine($".2 * 10:           {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

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

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

using System;

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

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

open System

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

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

Ograniczona precyzja liczby zmiennoprzecinkowej ma kilka konsekwencji:

• Dwie liczby zmiennoprzecinkowe, które wydają się równe dla określonej precyzji, mogą nie porównywać się jako równe, ponieważ ich najmniej znaczące cyfry są różne. W poniższym przykładzie seria liczb jest sumowana, a ich suma jest porównywana z oczekiwaną sumą. Wywołanie Equals metody wskazuje, że wartości nie są równe.

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

  Te dwie wartości są nierówne ze względu na utratę precyzji podczas operacji dodawania. W takim przypadku problem można rozwiązać, wywołując metodę Math.Round(Double, Int32), aby zaokrąglić wartości Single do żądanej dokładności przed wykonaniem porównania.

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

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

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

  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
  

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

Testowanie pod kątem równości

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

using System;

public class Example
{
   public static void Main()
   {
      float value1 = .3333333f;
      float value2 = 1.0f/3;
      Console.WriteLine($"{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

Obliczone wartości, które są zgodne z różnymi ścieżkami kodu i które są manipulowane na różne sposoby, często okazują się nierówne. W poniższym przykładzie jedna wartość Single jest podnoszona do kwadratu, a następnie oblicza się pierwiastek kwadratowy, aby przywrócić oryginalną wartość. Druga Single jest pomnożona przez 3,51 i podniesiona do kwadratu, zanim pierwiastek kwadratowy z wyniku zostanie podzielony przez 3,51, aby przywrócić oryginalną wartość. Chociaż dwie wartości wydają się być identyczne, wywołanie metody Equals(Single) wskazuje, że nie są równe.

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

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

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

  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
  

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

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

  Warning

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

  W poniższym przykładzie użyto drugiego podejścia do zdefiniowania metody IsApproximatelyEqual, która testuje względną różnicę między dwiema wartościami. Przeciwstawia także wyniki wywołań metody IsApproximatelyEqual i 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
  

Wartości zmiennoprzecinkowe i wyjątki

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

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

  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
  

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

  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 również wynika z podziału o zero z dodatnią dywidendą, a NegativeInfinity wynika z podziału o zero z ujemną dywidendą.

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

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

Konwersje typu

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

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

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

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

using System;

public class Example4
{
    public static void Main()
    {
        dynamic[] values = { Byte.MinValue, Byte.MaxValue, Decimal.MinValue,
                           Decimal.MaxValue, Double.MinValue, Double.MaxValue,
                           Int16.MinValue, Int16.MaxValue, Int32.MinValue,
                           Int32.MaxValue, Int64.MinValue, Int64.MaxValue,
                           SByte.MinValue, SByte.MaxValue, UInt16.MinValue,
                           UInt16.MaxValue, UInt32.MinValue, UInt32.MaxValue,
                           UInt64.MinValue, UInt64.MaxValue };
        float sngValue;
        foreach (var value in values)
        {
            if (value.GetType() == typeof(Decimal) ||
                value.GetType() == typeof(Double))
                sngValue = (float)value;
            else
                sngValue = value;
            Console.WriteLine($"{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)

Ponadto wartości DoubleDouble.NaN, Double.PositiveInfinityi Double.NegativeInfinity są konwertowane na odpowiednio Single.NaN, Single.PositiveInfinityi Single.NegativeInfinity.

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

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

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

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

Ponadto Single.NaN, Single.PositiveInfinityi Single.NegativeInfinity zgłaszają OverflowException podczas konwersji na liczby całkowite w kontrolowanym kontekście, ale te wartości przepełniają się po przekonwertowaniu na liczby całkowite w niekontrolowanym kontekście. W przypadku konwersji na Decimalzawsze rzucają OverflowException. W przypadku konwersji na Doublekonwertują odpowiednio na Double.NaN, Double.PositiveInfinityi Double.NegativeInfinity.

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

W poniższym przykładzie liczba wartości Single jest konwertowana na kilka innych typów liczbowych. Konwersje występują w zaznaczonym kontekście w Visual Basic (wartość domyślna), w języku C# (ze względu na zaznaczone słowo kluczowe) i w języku F# (ze względu na instrukcję open Checked ). Dane wyjściowe z przykładu pokazują wynik konwersji w kontekście zarówno sprawdzonym, jak i niesprawdzonym. Konwersje można wykonać w nieznakowanym kontekście: w Visual Basic, kompilując z przełącznikiem kompilatora /removeintchecks+; w C#, komentując instrukcję checked; oraz w F#, komentując instrukcję 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)

Aby uzyskać więcej informacji na temat konwersji typów liczbowych, zobacz Type Conversion in .NET and Type Conversion Tables.

Funkcjonalność zmiennoprzecinkowa

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

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

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

  Warning

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

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

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

  Inne operacje matematyczne można wykonywać, wywołując metody static (Shared w Visual Basic) w klasie System.Math. Obejmują one dodatkowe metody powszechnie stosowane do arytmetyki (takie jak Math.Abs, Math.Sign i Math.Sqrt), geometrii (takie jak Math.Cos i Math.Sin) oraz rachunku (takie jak Math.Log). We wszystkich przypadkach wartość Single jest konwertowana na Double.

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

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

• formatowanie. Wartość można przekonwertować na reprezentację Single ciągu, wywołując metodę ToString lub używając funkcji formatowania złożonego . Aby uzyskać informacje o tym, jak ciągi formatujące kontrolują sposób reprezentacji wartości zmiennoprzecinkowych, zobacz Standard Numeric Format Strings i Custom Numeric Format Strings.

• analizowanie ciągów. Możesz przekonwertować reprezentację ciągu wartości zmiennoprzecinkowej na wartość Single, wywołując metodę Parse lub TryParse. Jeśli operacja analizy zakończy się niepowodzeniem, metoda Parse zgłasza wyjątek, natomiast metoda TryParse zwraca false.

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

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

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

  Problem dokładności najczęściej dotyczy wartości Single, które są konwertowane na wartości Double. W poniższym przykładzie dwie wartości uzyskane z identycznych operacji dzielenia są nierówne, ponieważ jedna z wartości jest liczbą zmiennoprzecinkową o pojedynczej precyzji, która jest konwertowana 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
  

Pola

Nazwa	Opis
E	Reprezentuje naturalną bazę logarytmiczna określoną przez stałą e.
Epsilon	Reprezentuje najmniejszą wartość dodatnią Single , która jest większa niż zero. To pole jest stałe.
MaxValue	Reprezentuje największą możliwą wartość Single. To pole jest stałe.
MinValue	Reprezentuje najmniejszą możliwą wartość Single. To pole jest stałe.
NaN	Reprezentuje nie liczbę (NaN). To pole jest stałe.
NegativeInfinity	Reprezentuje nieskończoność ujemną. To pole jest stałe.
NegativeZero	Reprezentuje liczbę ujemną zero (-0).
Pi	Przedstawia stosunek obwodu okręgu do jego średnicy określonej przez stałą π.
PositiveInfinity	Reprezentuje nieskończoność dodatnią. To pole jest stałe.
Tau	Reprezentuje liczbę radianów z jednej kolei określoną przez stałą τ.

Metody

Nazwa	Opis
Abs(Single)	Oblicza wartość bezwzględną.
Acos(Single)	Oblicza cosinus arc-cosinus wartości.
Acosh(Single)	Oblicza hiperboliczny arc-cosinus wartości.
AcosPi(Single)	Oblicza cosinus arc-cosinus wartości i dzieli wynik przez piwartość .
Asin(Single)	Oblicza sinus wartości arc-sine.
Asinh(Single)	Oblicza hiperboliczny sinus wartości.
AsinPi(Single)	Oblicza sinus arc wartości i dzieli wynik przez piwartość .
Atan(Single)	Oblicza tangens łuku wartości.
Atan2(Single, Single)	Oblicza tangens łukowy iloraz dwóch wartości.
Atan2Pi(Single, Single)	Oblicza tangens łukowy dla ilorazu dwóch wartości i dzieli wynik przez pi.
Atanh(Single)	Oblicza tangens hiperboliczny wartości.
AtanPi(Single)	Oblicza tangens łuku wartości i dzieli wynik przez pi.
BitDecrement(Single)	Zwraca największą wartość, która porównuje wartość mniejszą niż określona wartość.
BitIncrement(Single)	Zwraca najmniejszą wartość, która porównuje większą niż określona wartość.
Cbrt(Single)	Oblicza pierwiastek modułu wartości.
Ceiling(Single)	Oblicza limit wartości.
Clamp(Single, Single, Single)	Zaciska wartość do wartości minimalnej i maksymalnej.
ClampNative(Single, Single, Single)	Zaciska wartość do wartości minimalnej i maksymalnej przy użyciu zachowania specyficznego dla platformy i NaNNegativeZero.
CompareTo(Object)	Porównuje to wystąpienie z określonym obiektem i zwraca liczbę całkowitą wskazującą, czy wartość tego wystąpienia jest mniejsza niż, równa lub większa niż wartość określonego obiektu.
CompareTo(Single)	Porównuje to wystąpienie z określoną liczbą zmiennoprzecinkową o pojedynczej precyzji i zwraca liczbę całkowitą wskazującą, czy wartość tego wystąpienia jest mniejsza niż, równa lub większa niż wartość określonej liczby zmiennoprzecinkowej o pojedynczej precyzji.
ConvertToInteger<TInteger>(Single)	Konwertuje wartość na określony typ liczb całkowitych przy użyciu nasycenia w przypadku przepełnienia
ConvertToIntegerNative<TInteger>(Single)	Konwertuje wartość na określony typ całkowity przy użyciu zachowania specyficznego dla platformy podczas przepełnienia.
CopySign(Single, Single)	Kopiuje znak wartości do znaku innej wartości.
Cos(Single)	Oblicza cosinus wartości.
Cosh(Single)	Oblicza cosinus hiperboliczny wartości.
CosPi(Single)	Oblicza cosinus wartości, która została wielokrotna przez pielement .
CreateChecked<TOther>(TOther)	Tworzy wystąpienie bieżącego typu na podstawie wartości, zgłaszając wyjątek przepełnienia dla wszystkich wartości, które mieszczą się poza dopuszczalnym zakresem bieżącego typu.
CreateSaturating<TOther>(TOther)	Tworzy wystąpienie bieżącego typu na podstawie wartości, usytując wszystkie wartości, które wykraczają poza reprezentowany zakres bieżącego typu.
CreateTruncating<TOther>(TOther)	Tworzy wystąpienie bieżącego typu na podstawie wartości, obcinając wszystkie wartości, które wykraczają poza reprezentowany zakres bieżącego typu.
DegreesToRadians(Single)	Konwertuje daną wartość z stopni na radiany.
Equals(Object)	Zwraca wartość wskazującą, czy to wystąpienie jest równe określonemu obiektowi.
Equals(Single)	Zwraca wartość wskazującą, czy to wystąpienie i określony Single obiekt reprezentują tę samą wartość.
Exp(Single)	Obliczenia podniesione E do danej mocy.
Exp10(Single)	Obliczenia podniesione 10 do danej mocy.
Exp10M1(Single)	Obliczenia podniesione 10 do danej mocy i odejmuje je.
Exp2(Single)	Obliczenia podniesione 2 do danej mocy.
Exp2M1(Single)	Obliczenia podniesione 2 do danej mocy i odejmuje je.
ExpM1(Single)	Obliczenia podniesione E do danej mocy i odejmuje je.
Floor(Single)	Oblicza podłogę wartości.
FusedMultiplyAdd(Single, Single, Single)	Oblicza bezpieczną pomnożną liczbę trzech wartości.
GetHashCode()	Zwraca kod skrótu dla tego wystąpienia.
GetTypeCode()	Zwraca wartość TypeCode dla typu Singlewartości .
Hypot(Single, Single)	Oblicza niedocięcie, biorąc pod uwagę dwie wartości reprezentujące długości krótszych boków w trójkątach kątowych po prawej stronie.
Ieee754Remainder(Single, Single)	Oblicza pozostałe dwie wartości określone przez IEEE 754.
ILogB(Single)	Oblicza logarytm liczb całkowitych wartości.
IsEvenInteger(Single)	Określa, czy wartość reprezentuje liczbę całkowitą parzystą.
IsFinite(Single)	Określa, czy określona wartość jest skończona (zero, podnormalne lub normalne).
IsInfinity(Single)	Zwraca wartość wskazującą, czy określona liczba ma wartość ujemną lub dodatnią nieskończoność.
IsInteger(Single)	Określa, czy wartość reprezentuje wartość całkowitą.
IsNaN(Single)	Zwraca wartość wskazującą, czy określona wartość nie jest liczbą (NaN).
IsNegative(Single)	Określa, czy określona wartość jest ujemna.
IsNegativeInfinity(Single)	Zwraca wartość wskazującą, czy określona liczba ma wartość ujemną nieskończoności.
IsNormal(Single)	Określa, czy określona wartość jest normalna.
IsOddInteger(Single)	Określa, czy wartość reprezentuje nieparzystną liczbę całkowitą.
IsPositive(Single)	Określa, czy wartość jest dodatnia.
IsPositiveInfinity(Single)	Zwraca wartość wskazującą, czy określona liczba daje wynik nieskończoności dodatniej.
IsPow2(Single)	Określa, czy wartość jest potęgą dwóch.
IsRealNumber(Single)	Określa, czy wartość reprezentuje liczbę rzeczywistą.
IsSubnormal(Single)	Określa, czy określona wartość jest podnormalna.
Lerp(Single, Single, Single)	Wykonuje interpolację liniową między dwiema wartościami na podstawie danej wagi.
Log(Single, Single)	Oblicza logarytm wartości w określonej bazie.
Log(Single)	Oblicza wartość naturalną (base-E logarytm wartości.
Log10(Single)	Oblicza logarytm base-10 wartości.
Log10P1(Single)	Oblicza logarytm base-10 wartości plus jeden.
Log2(Single)	Oblicza dziennik2 wartości.
Log2P1(Single)	Oblicza logarytm base-2 wartości plus jeden.
LogP1(Single)	Oblicza logarytm naturalny (base-E) wartości plus jeden.
Max(Single, Single)	Porównuje dwie wartości z obliczeniami, które są większe.
MaxMagnitude(Single, Single)	Porównuje dwie wartości z obliczeniami, które są większe.
MaxMagnitudeNumber(Single, Single)	Porównuje dwie wartości z obliczeniami o większej wielkości i zwraca drugą wartość, jeśli dane wejściowe to NaN.
MaxNative(Single, Single)	Porównuje dwie wartości z obliczeniami, które są większe przy użyciu zachowania specyficznego dla platformy dla NaN i NegativeZero.
MaxNumber(Single, Single)	Porównuje dwie wartości z obliczeniami, które są większe i zwracają drugą wartość, jeśli dane wejściowe to NaN.
Min(Single, Single)	Porównuje dwie wartości z obliczeniami, które są mniejsze.
MinMagnitude(Single, Single)	Porównuje dwie wartości z obliczeniami, które są mniejsze.
MinMagnitudeNumber(Single, Single)	Porównuje dwie wartości z obliczeniami o mniejszej wielkości i zwraca drugą wartość, jeśli dane wejściowe to NaN.
MinNative(Single, Single)	Porównuje dwie wartości do obliczeń, które są mniejsze przy użyciu zachowania specyficznego dla platformy dla NaN i NegativeZero.
MinNumber(Single, Single)	Porównuje dwie wartości z obliczeniami, które są mniejsze i zwracają drugą wartość, jeśli dane wejściowe to NaN.
MultiplyAddEstimate(Single, Single, Single)	Oblicza oszacowanie (left * right) i . addend
Parse(ReadOnlySpan<Byte>, IFormatProvider)	Analizuje zakres znaków UTF-8 w wartość.
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)	Analizuje zakres znaków UTF-8 w wartość.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Analizuje zakres znaków w wartości.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Konwertuje zakres znaków, który zawiera reprezentację ciągu liczby w określonym stylu i formacie specyficznym dla kultury na odpowiednik liczby zmiennoprzecinkowych o pojedynczej precyzji.
Parse(String, IFormatProvider)	Konwertuje reprezentację ciągu liczby w określonym formacie specyficznym dla kultury na odpowiednik liczb zmiennoprzecinkowych o pojedynczej precyzji.
Parse(String, NumberStyles, IFormatProvider)	Konwertuje reprezentację ciągu liczby w określonym stylu i formacie specyficznym dla kultury na odpowiednik liczb zmiennoprzecinkowych o pojedynczej precyzji.
Parse(String, NumberStyles)	Konwertuje reprezentację ciągu liczby w określonym stylu na równoważnik liczby zmiennoprzecinkowych o pojedynczej precyzji.
Parse(String)	Konwertuje reprezentację ciągu liczby na równoważnik liczby zmiennoprzecinkowych o pojedynczej precyzji.
Pow(Single, Single)	Oblicza wartość podniesioną do danej mocy.
RadiansToDegrees(Single)	Konwertuje daną wartość z radianów na stopnie.
ReciprocalEstimate(Single)	Oblicza oszacowanie wzajemnej wartości.
ReciprocalSqrtEstimate(Single)	Oblicza oszacowanie wzajemnego pierwiastek kwadratowy wartości.
RootN(Single, Int32)	Oblicza n-ty element główny wartości.
Round(Single, Int32, MidpointRounding)	Zaokrągla wartość do określonej liczby cyfr ułamkowych przy użyciu domyślnego trybu zaokrąglania (ToEven).
Round(Single, Int32)	Zaokrągla wartość do określonej liczby cyfr ułamkowych przy użyciu domyślnego trybu zaokrąglania (ToEven).
Round(Single, MidpointRounding)	Zaokrągla wartość do najbliższej liczby całkowitej przy użyciu określonego trybu zaokrąglania.
Round(Single)	Zaokrągla wartość do najbliższej liczby całkowitej przy użyciu domyślnego trybu zaokrąglania (ToEven).
ScaleB(Single, Int32)	Oblicza iloczyn wartości i jego promienistość bazową podniesioną do określonej mocy.
Sign(Single)	Oblicza znak wartości.
Sin(Single)	Oblicza sinus wartości.
SinCos(Single)	Oblicza sinus i cosinus wartości.
SinCosPi(Single)	Oblicza sinus i cosinus wartości.
Sinh(Single)	Oblicza sinus hiperboliczny wartości.
SinPi(Single)	Oblicza sinus wartości, która została pomnożona przez pielement .
Sqrt(Single)	Oblicza pierwiastek kwadratowy wartości.
Tan(Single)	Oblicza tangens wartości.
Tanh(Single)	Oblicza tangens hiperboliczny wartości.
TanPi(Single)	Oblicza tangens wartości, która została wielokrotna przez pielement .
ToString()	Konwertuje wartość liczbową tego wystąpienia na równoważną reprezentację ciągu.
ToString(IFormatProvider)	Konwertuje wartość liczbową tego wystąpienia na równoważną reprezentację ciągu przy użyciu określonych informacji o formacie specyficznym dla kultury.
ToString(String, IFormatProvider)	Konwertuje wartość liczbową tego wystąpienia na równoważną reprezentację ciągu przy użyciu określonego formatu i informacji o formacie specyficznym dla kultury.
ToString(String)	Konwertuje wartość liczbową tego wystąpienia na równoważną reprezentację ciągu przy użyciu określonego formatu.
Truncate(Single)	Obcina wartość.
TryFormat(Span<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Próbuje sformatować wartość bieżącego wystąpienia jako UTF-8 w podanym zakresie bajtów.
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Próbuje sformatować wartość bieżącego wystąpienia liczby zmiennoprzecinkowej do podanego zakresu znaków.
TryParse(ReadOnlySpan<Byte>, IFormatProvider, Single)	Próbuje przeanalizować zakres znaków UTF-8 w wartość.
TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, Single)	Próbuje przeanalizować zakres znaków UTF-8 w wartość.
TryParse(ReadOnlySpan<Byte>, Single)	Próbuje przekonwertować zakres znaków UTF-8 zawierający reprezentację ciągu liczby na równoważnik liczby zmiennoprzecinkowych o pojedynczej precyzji.
TryParse(ReadOnlySpan<Char>, IFormatProvider, Single)	Próbuje przeanalizować zakres znaków w wartości.
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Single)	Konwertuje reprezentację zakresu liczby w określonym stylu i formacie specyficznym dla kultury na odpowiednik liczb zmiennoprzecinkowych o pojedynczej precyzji. Wartość zwracana wskazuje, czy konwersja zakończyła się powodzeniem, czy niepowodzeniem.
TryParse(ReadOnlySpan<Char>, Single)	Konwertuje reprezentację ciągu liczby w zakresie znaków na równoważnik liczby zmiennoprzecinkowych o pojedynczej precyzji. Wartość zwracana wskazuje, czy konwersja zakończyła się powodzeniem, czy niepowodzeniem.
TryParse(String, IFormatProvider, Single)	Próbuje przeanalizować ciąg w wartości.
TryParse(String, NumberStyles, IFormatProvider, Single)	Konwertuje reprezentację ciągu liczby w określonym stylu i formacie specyficznym dla kultury na odpowiednik liczb zmiennoprzecinkowych o pojedynczej precyzji. Wartość zwracana wskazuje, czy konwersja zakończyła się powodzeniem, czy niepowodzeniem.
TryParse(String, Single)	Konwertuje reprezentację ciągu liczby na równoważnik liczby zmiennoprzecinkowych o pojedynczej precyzji. Wartość zwracana wskazuje, czy konwersja zakończyła się powodzeniem, czy niepowodzeniem.

Operatory

Nazwa	Opis
Equality(Single, Single)	Zwraca wartość wskazującą, czy dwie określone Single wartości są równe.
GreaterThan(Single, Single)	Zwraca wartość wskazującą, czy określona Single wartość jest większa niż inna określona Single wartość.
GreaterThanOrEqual(Single, Single)	Zwraca wartość wskazującą, czy określona Single wartość jest większa, czy równa innej określonej Single wartości.
Inequality(Single, Single)	Zwraca wartość wskazującą, czy dwie określone Single wartości nie są równe.
LessThan(Single, Single)	Zwraca wartość wskazującą, czy określona Single wartość jest mniejsza niż inna określona Single wartość.
LessThanOrEqual(Single, Single)	Zwraca wartość wskazującą, czy określona Single wartość jest mniejsza, czy równa innej określonej Single wartości.

Jawne implementacje interfejsu

Nazwa	Opis
IAdditionOperators<Single,Single,Single>.Addition(Single, Single)	Dodaje dwie wartości w celu obliczenia ich sumy.
IAdditiveIdentity<Single,Single>.AdditiveIdentity	Pobiera tożsamość addytywnego bieżącego typu.
IBinaryNumber<Single>.AllBitsSet	Pobiera wystąpienie typu binarnego, w którym są ustawione wszystkie bity.
IBitwiseOperators<Single,Single,Single>.BitwiseAnd(Single, Single)	Oblicza bitowe wartości i dwie wartości.
IBitwiseOperators<Single,Single,Single>.BitwiseOr(Single, Single)	Oblicza bitowe lub dwie wartości.
IBitwiseOperators<Single,Single,Single>.ExclusiveOr(Single, Single)	Oblicza wyłącznie lub dwie wartości.
IBitwiseOperators<Single,Single,Single>.OnesComplement(Single)	Oblicza reprezentację danej wartości jako uzupełnienie.
IConvertible.ToBoolean(IFormatProvider)	Aby uzyskać opis tego elementu członkowskiego, zobacz ToBoolean(IFormatProvider).
IConvertible.ToByte(IFormatProvider)	Aby uzyskać opis tego elementu członkowskiego, zobacz ToByte(IFormatProvider).
IConvertible.ToChar(IFormatProvider)	Ta konwersja nie jest obsługiwana. Próba użycia tej metody zgłasza błąd InvalidCastException.
IConvertible.ToDateTime(IFormatProvider)	Ta konwersja nie jest obsługiwana. Próba użycia tej metody zgłasza błąd InvalidCastException.
IConvertible.ToDecimal(IFormatProvider)	Aby uzyskać opis tego elementu członkowskiego, zobacz ToDecimal(IFormatProvider).
IConvertible.ToDouble(IFormatProvider)	Aby uzyskać opis tego elementu członkowskiego, zobacz ToDouble(IFormatProvider).
IConvertible.ToInt16(IFormatProvider)	Aby uzyskać opis tego elementu członkowskiego, zobacz ToInt16(IFormatProvider).
IConvertible.ToInt32(IFormatProvider)	Aby uzyskać opis tego elementu członkowskiego, zobacz ToInt32(IFormatProvider).
IConvertible.ToInt64(IFormatProvider)	Aby uzyskać opis tego elementu członkowskiego, zobacz ToInt64(IFormatProvider).
IConvertible.ToSByte(IFormatProvider)	Aby uzyskać opis tego elementu członkowskiego, zobacz ToSByte(IFormatProvider).
IConvertible.ToSingle(IFormatProvider)	Aby uzyskać opis tego elementu członkowskiego, zobacz ToSingle(IFormatProvider).
IConvertible.ToType(Type, IFormatProvider)	Aby uzyskać opis tego elementu członkowskiego, zobacz ToType(Type, IFormatProvider).
IConvertible.ToUInt16(IFormatProvider)	Aby uzyskać opis tego elementu członkowskiego, zobacz ToUInt16(IFormatProvider).
IConvertible.ToUInt32(IFormatProvider)	Aby uzyskać opis tego elementu członkowskiego, zobacz ToUInt32(IFormatProvider).
IConvertible.ToUInt64(IFormatProvider)	Aby uzyskać opis tego elementu członkowskiego, zobacz ToUInt64(IFormatProvider).
IDecrementOperators<Single>.Decrement(Single)	Dekrementuje wartość.
IDivisionOperators<Single,Single,Single>.Division(Single, Single)	Dzieli jedną wartość przez inną, aby obliczyć ich iloraz.
IFloatingPoint<Single>.GetExponentByteCount()	Pobiera liczbę bajtów, które zostaną zapisane w ramach elementu TryWriteExponentLittleEndian(Span<Byte>, Int32).
IFloatingPoint<Single>.GetExponentShortestBitLength()	Pobiera długość, w bitach, najkrótszej reprezentacji dwóch uzupełnień bieżącego wykładnika.
IFloatingPoint<Single>.GetSignificandBitLength()	Pobiera długość w bitach bieżącego znaku.
IFloatingPoint<Single>.GetSignificandByteCount()	Pobiera liczbę bajtów, które zostaną zapisane w ramach elementu TryWriteSignificandLittleEndian(Span<Byte>, Int32).
IFloatingPoint<Single>.TryWriteExponentBigEndian(Span<Byte>, Int32)	Próbuje napisać bieżący wykładnik w formacie big-endian do danego zakresu.
IFloatingPoint<Single>.TryWriteExponentLittleEndian(Span<Byte>, Int32)	Próbuje napisać bieżący wykładnik w formacie mało endianu do danego zakresu.
IFloatingPoint<Single>.TryWriteSignificandBigEndian(Span<Byte>, Int32)	Próbuje napisać bieżący znak w formacie big-endian do danego zakresu.
IFloatingPoint<Single>.TryWriteSignificandLittleEndian(Span<Byte>, Int32)	Próbuje napisać bieżący znak w formacie little-endian do danego zakresu.
IFloatingPointConstants<Single>.E	Pobiera stałą ematematyczną .
IFloatingPointConstants<Single>.Pi	Pobiera stałą pimatematyczną .
IFloatingPointConstants<Single>.Tau	Pobiera stałą taumatematyczną .
IFloatingPointIeee754<Single>.Epsilon	Pobiera najmniejszą wartość, którą można dodać do 0 tego elementu, nie powoduje .0
IFloatingPointIeee754<Single>.NaN	Pobiera wartość reprezentującą NaNwartość .
IFloatingPointIeee754<Single>.NegativeInfinity	Pobiera wartość reprezentującą wartość ujemną infinity.
IFloatingPointIeee754<Single>.NegativeZero	Pobiera wartość reprezentującą wartość ujemną zero.
IFloatingPointIeee754<Single>.PositiveInfinity	Pobiera wartość reprezentującą dodatnią infinitywartość .
IIncrementOperators<Single>.Increment(Single)	Zwiększa wartość.
IMinMaxValue<Single>.MaxValue	Pobiera maksymalną wartość bieżącego typu.
IMinMaxValue<Single>.MinValue	Pobiera minimalną wartość bieżącego typu.
IModulusOperators<Single,Single,Single>.Modulus(Single, Single)	Dzieli dwie wartości, aby obliczyć ich modulo lub resztę.
IMultiplicativeIdentity<Single,Single>.MultiplicativeIdentity	Pobiera mnożenie tożsamości bieżącego typu.
IMultiplyOperators<Single,Single,Single>.Multiply(Single, Single)	Mnoży dwie wartości, aby obliczyć swój produkt.
INumberBase<Single>.IsCanonical(Single)	Określa, czy wartość znajduje się w jej kanonicznej reprezentacji.
INumberBase<Single>.IsComplexNumber(Single)	Określa, czy wartość reprezentuje liczbę zespolonej.
INumberBase<Single>.IsImaginaryNumber(Single)	Określa, czy wartość reprezentuje czystą liczbę wyimaginowaną.
INumberBase<Single>.IsZero(Single)	Określa, czy wartość ma wartość zero.
INumberBase<Single>.One	Pobiera wartość 1 typu.
INumberBase<Single>.Radix	Pobiera podstawę (radix) dla typu.
INumberBase<Single>.TryConvertFromChecked<TOther>(TOther, Single)	Reprezentuje liczbę zmiennoprzecinkową o pojedynczej precyzji.
INumberBase<Single>.TryConvertFromSaturating<TOther>(TOther, Single)	Reprezentuje liczbę zmiennoprzecinkową o pojedynczej precyzji.
INumberBase<Single>.TryConvertFromTruncating<TOther>(TOther, Single)	Reprezentuje liczbę zmiennoprzecinkową o pojedynczej precyzji.
INumberBase<Single>.TryConvertToChecked<TOther>(Single, TOther)	Próbuje przekonwertować wystąpienie bieżącego typu na inny typ, zgłaszając wyjątek przepełnienia dla wszystkich wartości, które mieszczą się poza dopuszczalnym zakresem bieżącego typu.
INumberBase<Single>.TryConvertToSaturating<TOther>(Single, TOther)	Próbuje przekonwertować wystąpienie bieżącego typu na inny typ, saturując wszystkie wartości, które mieszczą się poza dopuszczalnym zakresem bieżącego typu.
INumberBase<Single>.TryConvertToTruncating<TOther>(Single, TOther)	Próbuje przekonwertować wystąpienie bieżącego typu na inny typ, obcinając wszystkie wartości, które wykraczają poza reprezentowany zakres bieżącego typu.
INumberBase<Single>.Zero	Pobiera wartość 0 typu.
ISignedNumber<Single>.NegativeOne	Pobiera wartość -1 typu.
ISubtractionOperators<Single,Single,Single>.Subtraction(Single, Single)	Odejmuje dwie wartości, aby obliczyć ich różnicę.
IUnaryNegationOperators<Single,Single>.UnaryNegation(Single)	Oblicza jednoargumentowe negację wartości.
IUnaryPlusOperators<Single,Single>.UnaryPlus(Single)	Oblicza jednoargumentowy plus wartość.

Bezpieczeństwo wątkowe

Wszyscy członkowie tego typu są bezpieczni wątkami. Elementy członkowskie, które wydają się modyfikować stan wystąpienia, zwracają nowe wystąpienie zainicjowane przy użyciu nowej wartości. Podobnie jak w przypadku dowolnego innego typu odczyt i zapis w zmiennej udostępnionej, która zawiera wystąpienie tego typu, musi być chroniona przez blokadę, aby zagwarantować bezpieczeństwo wątków.

Zobacz też

• Decimal
• Double