Single Структура

Определение

Пространство имен:

System

Сборки:

netstandard.dll, System.Runtime.dll

Исходный код:

Single.cs

Представляет одноточное число с плавающей запятой.

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)

Наследование

Object

ValueType

Single

Реализации

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>

Комментарии

Тип значения Single представляет одноточное 32-разрядное число со значениями от отрицательного 3,402823e38 до положительного 3,402823e38, а также положительного или отрицательного нуля, PositiveInfinity, NegativeInfinity, а не числа (NaN). Оно предназначено для представления значений, которые чрезвычайно большие (например, расстояния между планетами или галактиками) или крайне малы (например, молекулярной массы вещества в килограммах) и которые часто являются неуловкими (например, расстояние от земли к другой солнечной системе). Тип Single соответствует стандарту IEC 60559:1989 (IEEE 754) для арифметики с плавающей запятой.

System.Single предоставляет методы для сравнения экземпляров этого типа, преобразования значения экземпляра в его строковое представление и преобразования строкового представления числа в экземпляр этого типа. Сведения о том, как коды спецификаций формата управляют строковым представлением типов значений, см. в типах форматирования, строках стандартного числового форматаи строк пользовательского числового формата.

Представление и точность чисел с плавающей точкой

Тип данных Single сохраняет значения с плавающей запятой с одной точностью в 32-разрядном двоичном формате, как показано в следующей таблице:

Часть	Биты
Значение или мантисса	0-22
Exponent	23-30
Знак (0 = положительный, 1 = отрицательный)	31

Так же, как десятичные дроби не могут точно представлять некоторые дробные значения (например, 1/3 или Math.PI), двоичные дроби не могут представлять некоторые дробные значения. Например, 2/10, которое представлено как 0.2 в виде десятичной дроби, представлено как 0.0011111001001100 в виде двоичной дроби, при этом цикл "1100" повторяется до бесконечности. В этом случае значение с плавающей запятой дает неточное представление о числе, которое оно обозначает. Выполнение дополнительных математических операций с исходным значением с плавающей запятой часто увеличивает его отсутствие точности. Например, если сравнить результаты умножения .3 на 10 и добавления .3 к .3 девять раз, вы увидите, что добавление создает менее точный результат, так как он включает в себя восемь больше операций, чем умножение. Обратите внимание, что это различие очевидно, только если вы отображаете оба значения Single, используя строку стандартного числового формата "R" , которая при необходимости отображает все 9 цифр точности, поддерживаемых типом 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

Так как некоторые числа не могут быть представлены точно как дробные двоичные значения, числа с плавающей запятой могут приблизиться только к реальным числам.

Все числа с плавающей запятой имеют ограниченное количество значимых цифр, которое также определяет, насколько точно значение с плавающей запятой приближается к реальному числу. Значение Single имеет до 7 десятичных цифр точности, хотя внутренне поддерживается максимальное количество в 9 цифр. Это означает, что некоторые операции с плавающей запятой могут недоставать точности для изменения значения с плавающей запятой. В следующем примере определяется большое число с плавающей запятой с одинарной точностью, а затем к нему добавляется произведение Single.Epsilon и одного квадриллиона. Однако результат умножения слишком мал, чтобы изменить исходное значение с плавающей запятой. Его наименьшая значимая цифра — тысячные, в то время как наиболее значимая цифра в продукте составляет 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

Ограниченная точность числа с плавающей запятой имеет несколько последствий:

• Два числа с плавающей запятой, которые, как представляется, равны для определенной точности, могут не сравниться, так как их наименьшие значимые цифры отличаются. В следующем примере ряд чисел добавляется вместе, и их общее значение сравнивается с ожидаемым итогом. Вызов Equals метода указывает, что значения не равны.

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

  Два значения неравны из-за потери точности во время операций сложения. В этом случае проблему можно устранить, вызвав метод Math.Round(Double, Int32) для округления значений Single до требуемой точности перед выполнением сравнения.

• Математические операции или операции сравнения, использующие число с плавающей запятой, могут не дать тот же результат, если используется десятичное число, так как двоичное число с плавающей запятой может не совпадать с десятичным числом. Предыдущий пример иллюстрировал это, отображая результат умножения .3 на 10 и прибавления .3 к .3 девять раз подряд.

  Если точность числовых операций с дробными значениями важна, используйте тип Decimal вместо типа Single. Если точность в числовых операциях со целыми значениями за пределами диапазона типов Int64 или UInt64 важна, используйте тип BigInteger.

• Single значения имеют меньше точности, чем Double значения. Значение Single, которое преобразуется в казалось бы эквивалентное Double часто не равно значению Double из-за различий в точности. В следующем примере результат идентичных операций деления назначается значению Double и значению Single. После того, как значение Single было приведено к Double, сравнение двух значений показывает, что они не равны.

  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
  

  Чтобы избежать этой проблемы, используйте Double тип данных вместо типа данных Single или используйте метод Round, чтобы оба значения имели одинаковую точность.

Проверка на равенство

Чтобы считаться равным, два значения Single должны представлять идентичные значения. Однако из-за различий в точности между значениями или из-за потери точности по одному или обоим значениям значения с плавающей запятой, которые, как ожидается, будут одинаковыми, часто оказываются неравными из-за различий в их наименее значимых цифрах. В результате вызовы метода Equals, чтобы определить, равны ли два значения, или вызовы метода CompareTo для определения связи между двумя значениями Single, часто дают непредвиденные результаты. Очевидно в следующем примере: два значения Single, казалось бы, равные, оказываются не равны, потому что первое значение имеет точность в 7 цифр, тогда как второе - в 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

Вычисляемые значения, которые следуют разным путям кода и которые управляются различными способами, часто оказываются неравными. В следующем примере одно значение Single возводится в квадрат, а затем вычисляется квадратный корень для получения исходного значения. Второй Single умножается на 3,51 и квадрат перед квадратным корнем результата делится на 3,51, чтобы восстановить исходное значение. Хотя два значения, как представляется, идентичны, вызов метода Equals(Single) указывает, что они не равны.

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

В случаях, когда потеря точности, скорее всего, влияет на результат сравнения, можно использовать следующие методы вместо вызова метода Equals или CompareTo:

• Вызовите метод Math.Round, чтобы убедиться, что оба значения имеют одинаковую точность. Следующий пример изменяет предыдущий пример для использования этого подхода таким образом, чтобы два дробных значения были эквивалентны.

  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
  

  Проблема точности по-прежнему применяется к округлениям значений средней точки. Дополнительные сведения см. в методе Math.Round(Double, Int32, MidpointRounding).

• Проверяйте приблизительное равенство вместо точного равенства. Для этого метода необходимо определить абсолютное значение, по которому эти два значения могут отличаться, но по-прежнему равны, или определить относительную сумму, по которой меньшее значение может отличаться от большего значения.

  Предупреждение

  Single.Epsilon иногда используется в качестве абсолютной меры расстояния между двумя Single значениями при тестировании на равенство. Однако Single.Epsilon измеряет наименьшее возможное значение, которое можно добавить или вычесть из Single, значение которого равно нулю. Для большинства положительных и отрицательных значений Single значение Single.Epsilon слишком мало для обнаружения. Поэтому, за исключением значений, равных нулю, мы не рекомендуем использовать его в тестах на равенство.

  В следующем примере используется последний подход для определения метода IsApproximatelyEqual, который проверяет относительную разницу между двумя значениями. Он также сравнивает результаты вызовов метода IsApproximatelyEqual и метода 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
  

Исключения и значения с плавающей запятой

Операции с числами с плавающей точкой не вызывают исключений, в отличие от операций с целочисленными типами, которые вызывают исключения в случаях незаконных операций, таких как деление на ноль или переполнение. Вместо этого в этих ситуациях результат операции с плавающей запятой равен нулю, положительной бесконечности, отрицательной бесконечности или не числом (NaN):

• Если результат операции с плавающей запятой слишком мал для целевого формата, результат равен нулю. Это может произойти при умножении двух очень маленьких чисел с плавающей запятой, как показано в следующем примере.

  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
  

• Если величина результата операции с плавающей запятой превышает диапазон целевого формата, результат операции — PositiveInfinity или NegativeInfinity, как это подходит для знака результата. Результат операции, которая переполняет Single.MaxValue, это PositiveInfinity, а результат операции, которая переполняет Single.MinValue, это NegativeInfinity, как показано в следующем примере.

  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 также является результатом деления положительного числа на ноль, а NegativeInfinity является результатом деления отрицательного числа на ноль.

• Если операция с плавающей запятой недопустима, результат операции NaN. Например, NaN - результат от следующих операций:

  • Деление на ноль с дивидендами от нуля. Обратите внимание, что другие случаи деления на ноль приводят либо к PositiveInfinity, либо к NegativeInfinity.
  • Любая операция с плавающей запятой с недопустимыми входными данными. Например, попытка найти квадратный корень отрицательного значения возвращает NaN.
  • Любая операция с аргументом, значение которого равно Single.NaN.

Преобразование типов

Структура Single не определяет никаких явных или неявных операторов преобразования; Вместо этого преобразования реализуются компилятором.

В следующей таблице перечислены возможные преобразования значения других примитивных числовых типов в Single значение. Он также указывает, расширяется ли преобразование или сужается, и может ли результат Single иметь меньшую точность, чем исходное значение.

Преобразование из	Расширение и сужение	Возможная потеря точности
Byte	Расширение	Нет
Decimal	Расширение Обратите внимание, что для C# требуется оператор приведения.	Yes. Decimal поддерживает 29 десятичных цифр точности; Single поддерживает 9.
Double	Сужение; Значения вне диапазона преобразуются в Double.NegativeInfinity или Double.PositiveInfinity.	Yes. Double поддерживает 17 десятичных цифр точности; Single поддерживает 9.
Int16	Расширение	Нет
Int32	Расширение	Yes. Int32 поддерживает 10 десятичных цифр точности; Single поддерживает 9.
Int64	Расширение	Yes. Int64 поддерживает 19 десятичных цифр точности; Single поддерживает 9.
SByte	Расширение	Нет
UInt16	Расширение	Нет
UInt32	Расширение	Yes. UInt32 поддерживает 10 десятичных цифр точности; Single поддерживает 9.
UInt64	Расширение	Yes. Int64 поддерживает 20 десятичных цифр точности; Single поддерживает 9.

Следующий пример преобразует минимальное или максимальное значение других примитивных числовых типов в значение 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)

Кроме того, значения DoubleDouble.NaN, Double.PositiveInfinityи Double.NegativeInfinity преобразуются в Single.NaN, Single.PositiveInfinityи Single.NegativeInfinityсоответственно.

Обратите внимание, что преобразование значения некоторых числовых типов в Single значение может привести к потере точности. Как показано в примере, при преобразовании Decimal, Double, Int32, Int64, UInt32и UInt64 значений в Single возможны потери точности.

Преобразование значения Single в Double является расширением преобразования. Преобразование может привести к потере точности, если тип Double не имеет точного представления для значения Single.

Преобразование значения Single в значение любого примитивного числового типа данных, отличного от Double, является сужающим преобразованием и требует оператора приведения (в C#) или метода преобразования (в Visual Basic). Значения, которые находятся за пределами диапазона целевого типа данных, определяемого MinValue и MaxValue свойств целевого типа, ведут себя, как показано в следующей таблице.

Тип целевого объекта	Result
Любой целочисленный тип	Исключение OverflowException, если преобразование происходит в проверенном контексте. Если преобразование происходит в неконтролируемом контексте (по умолчанию в C#), преобразование выполняется успешно, но значение переполняется.
Decimal	Исключение OverflowException .

Кроме того, Single.NaN, Single.PositiveInfinityи Single.NegativeInfinity выбрасывают OverflowException для преобразования в целые числа в контексте с проверкой, но эти значения переполняются при преобразовании в целые числа в контексте без проверки. Для преобразования в Decimal они всегда выбрасывают OverflowException. Для преобразований в Doubleони преобразуются в Double.NaN, Double.PositiveInfinityи Double.NegativeInfinityсоответственно.

Обратите внимание, что потеря точности может привести к преобразованию значения Single в другой числовой тип. В случае преобразования нецелых значений Single, как показано в примере, дробный компонент теряется, когда значение Single округляется (как в Visual Basic) или усекается (как в C# и F#). Для преобразования в значения Decimal значение Single может не иметь точного представления в целевом типе данных.

В следующем примере число значений Single преобразуется в несколько других числовых типов. Преобразования происходят в проверяемом контексте в Visual Basic (по умолчанию), в C# (из-за проверенного ключевого слова) и в F# (из-за инструкции open Checked). Выходные данные из примера показывают результат преобразования как в проверенном, так и в непроверенном контексте. Вы можете выполнять преобразования в незаверяемом контексте в Visual Basic, скомпилировав с переключателем компилятора /removeintchecks+, в C# — закомментировав инструкцию checked, и в F# — закомментировав инструкцию 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)

Дополнительные сведения о преобразовании числовых типов см. в статье Type Conversion in .NET and Type Conversion Tables.

Функциональность для чисел с плавающей запятой

Структура Single и связанные типы предоставляют методы для выполнения следующих категорий операций:

• сравнение значений. Можно вызвать метод Equals, чтобы определить, равны ли два значения Single или метод CompareTo для определения связи между двумя значениями.

  Структура Single также поддерживает полный набор операторов сравнения. Например, можно проверить равенство или неравенство или определить, больше ли одно значение или равно другому значению. Если один из операндов является Double, то значение Single преобразуется в Double перед выполнением сравнения. Если один из операндов является целочисленным типом, он преобразуется в Single перед выполнением сравнения. Хотя эти преобразования расширяются, они могут привести к потере точности.

  Предупреждение

  Из-за различий в точности два значения Single, которые, как ожидается, будут равными, могут оказаться неравными, что влияет на результат сравнения. Дополнительные сведения о сравнении двух значений Single".

  Можно также вызвать методы IsNaN, IsInfinity, IsPositiveInfinityи IsNegativeInfinity для проверки этих специальных значений.

• Математическая операция. Распространенные арифметические операции, такие как добавление, вычитание, умножение и деление, реализуются компиляторами языка и инструкциями CIL, а не методами Single. Если другой операнд в математической операции является Double, Single преобразуется в Double перед выполнением операции, а результат операции также является значением Double. Если другой операнд является целочисленным типом, он преобразуется в Single перед выполнением операции, а результат операции также является Single значением.

  Вы можете выполнять другие математические операции, вызывая методы static (Shared в Visual Basic) в классе System.Math. К ним относятся дополнительные методы, часто используемые для арифметики (например, Math.Abs, Math.Signи Math.Sqrt), геометрии (например, Math.Cos и Math.Sin), а также вычислений (например, Math.Log). Во всех случаях значение Single преобразуется в Double.

  Вы также можете управлять отдельными битами в значении Single. Метод BitConverter.GetBytes(Single) возвращает свой битовый шаблон в массиве байтов. Передав этот массив байтов в метод BitConverter.ToInt32, можно также сохранить битовое значение Single в 32-разрядном целочисленном значении.

• округление. Округление часто используется в качестве метода для снижения влияния различий между значениями, вызванных проблемами представления чисел с плавающей запятой и их точности. Можно округить значение Single путем вызова метода Math.Round. Однако обратите внимание, что значение Single преобразуется в Double перед вызовом метода, а преобразование может привести к потере точности.

• форматирование. Значение Single можно преобразовать в строковое представление, вызвав метод ToString или используя функцию составного форматирования . Для получения информации о том, как строковые форматы управляют строковым представлением значений с плавающей точкой, см. Стандартные числовые форматы и Пользовательские числовые форматы.

• Строки синтаксического анализа. Строковое представление значения с плавающей запятой можно преобразовать в значение Single путем вызова метода Parse или TryParse. Если операция синтаксического анализа завершается ошибкой, метод Parse создает исключение, а метод TryParse возвращает false.

• Преобразование типов. Структура Single предоставляет явную реализацию интерфейса для интерфейса IConvertible, который поддерживает преобразование между двумя стандартными типами данных .NET. Компиляторы языка также поддерживают неявное преобразование значений для всех других стандартных числовых типов, за исключением преобразования Double в Single значений. Преобразование значения любого стандартного числового типа, отличного от Double в Single, является расширяющим преобразованием и не требует использования оператора приведения или метода преобразования.

  Однако преобразование 32-разрядных и 64-разрядных целых значений может привести к потере точности. В следующей таблице перечислены различия в точности для 32-разрядных, 64-разрядных и Double типов:

  Type	Максимальная точность (десятичные цифры)	Внутренняя точность (десятичные цифры)
  Double	15	17
  Int32 и UInt32.	10	10
  Int64 и UInt64.	19	19
  Single	7	9

  Проблема точности чаще всего влияет на значения Single, которые преобразуются в значения Double. В следующем примере два значения, созданные идентичными операциями деления, неравны, поскольку одно из значений — это значение с плавающей запятой с одной точностью, которое преобразуется в 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
  

Поля

Имя	Описание
E	Представляет естественную логарифмическую базу, указанную константой, e.
Epsilon	Представляет наименьшее положительное Single значение, которое больше нуля. Это поле является константой.
MaxValue	Представляет наибольшее возможное значение Single. Это поле является константой.
MinValue	Представляет наименьшее возможное значение Single. Это поле является константой.
NaN	Представляет не число (NaN). Это поле является константой.
NegativeInfinity	Представляет отрицательную бесконечность. Это поле является константой.
NegativeZero	Представляет отрицательное число (-0).
Pi	Представляет отношение окружности круга к его диаметру, заданному константой, π.
PositiveInfinity	Представляет положительную бесконечность. Это поле является константой.
Tau	Представляет количество радианов в одном повороте, указанное константой, fx.

Методы

Имя	Описание
Abs(Single)	Вычисляет абсолютное значение.
Acos(Single)	Вычисляет arc-cosine значения.
Acosh(Single)	Вычисляет гиперболический арк-косинус значения.
AcosPi(Single)	Вычисляет arc-cosine значения и делит результат на pi.
Asin(Single)	Вычисляет arc-sine значения.
Asinh(Single)	Вычисляет гиперболический arc-sine значения.
AsinPi(Single)	Вычисляет arc-sine значения и делит результат на pi.
Atan(Single)	Вычисляет дуго-тангенс значения.
Atan2(Single, Single)	Вычисляет дуго-тангенс кворента двух значений.
Atan2Pi(Single, Single)	Вычисляет дуго-тангенс для кворента двух значений и делит результат на pi.
Atanh(Single)	Вычисляет гиперболический дуговой тангенс значения.
AtanPi(Single)	Вычисляет дуго-тангенс значения и делит результат на pi.
BitDecrement(Single)	Возвращает наибольшее значение, которое сравнивает меньше указанного значения.
BitIncrement(Single)	Возвращает наименьшее значение, которое сравнивает больше указанного значения.
Cbrt(Single)	Вычисляет корень куба значения.
Ceiling(Single)	Вычисляет потолок значения.
Clamp(Single, Single, Single)	Зацепляет значение к инклюзивному минимальному и максимальному значению.
ClampNative(Single, Single, Single)	Зацепляет значение к инклюзивному минимальному и максимальному значению, используя поведение, зависящее от платформы, и NaNNegativeZero.
CompareTo(Object)	Сравнивает этот экземпляр с указанным объектом и возвращает целое число, указывающее, меньше ли значение этого экземпляра, равно или больше значения указанного объекта.
CompareTo(Single)	Сравнивает этот экземпляр с указанным числом с плавающей запятой с одной точностью и возвращает целое число, указывающее, меньше ли значение этого экземпляра, равно или больше указанного числа с плавающей запятой с одной точностью.
ConvertToInteger<TInteger>(Single)	Преобразует значение в указанный целочисленный тип, используя насыщенность при переполнении
ConvertToIntegerNative<TInteger>(Single)	Преобразует значение в указанный целочисленный тип, используя конкретное поведение платформы при переполнении.
CopySign(Single, Single)	Копирует знак значения в знак другого значения.
Cos(Single)	Вычисляет косинус значения.
Cosh(Single)	Вычисляет гиперболический косинус значения.
CosPi(Single)	Вычисляет косинус значения, которое было несколько.pi
CreateChecked<TOther>(TOther)	Создает экземпляр текущего типа из значения, вызывая исключение переполнения для всех значений, которые выходят за пределы представляющего диапазона текущего типа.
CreateSaturating<TOther>(TOther)	Создает экземпляр текущего типа из значения, насыщая все значения, которые выходят за пределы представляющего диапазона текущего типа.
CreateTruncating<TOther>(TOther)	Создает экземпляр текущего типа из значения, усечение всех значений, которые выходят за пределы представляющего диапазона текущего типа.
DegreesToRadians(Single)	Преобразует заданное значение из градусов в радианы.
Equals(Object)	Возвращает значение, указывающее, равен ли этот экземпляр указанному объекту.
Equals(Single)	Возвращает значение, указывающее, представляет ли этот экземпляр и указанный Single объект одинаковые значения.
Exp(Single)	Вычисления, поднятые E на определенную мощность.
Exp10(Single)	Вычисления, поднятые 10 на определенную мощность.
Exp10M1(Single)	Вычисления, поднятые 10 на определенную мощность и вычитает один.
Exp2(Single)	Вычисления, поднятые 2 на определенную мощность.
Exp2M1(Single)	Вычисления, поднятые 2 на определенную мощность и вычитает один.
ExpM1(Single)	Вычисления, поднятые E на определенную мощность и вычитает один.
Floor(Single)	Вычисляет пол значения.
FusedMultiplyAdd(Single, Single, Single)	Вычисляет умноженное умножение трех значений.
GetHashCode()	Возвращает хэш-код для этого экземпляра.
GetTypeCode()	TypeCode Возвращает тип Singleзначения.
Hypot(Single, Single)	Вычисляет гипотенуз с двумя значениями, представляющими длину более коротких сторон в правом углу треугольника.
Ieee754Remainder(Single, Single)	Вычисляет оставшуюся часть двух значений, указанных IEEE 754.
ILogB(Single)	Вычисляет целочисленный логарифм значения.
IsEvenInteger(Single)	Определяет, представляет ли значение даже целочисленное число.
IsFinite(Single)	Определяет, является ли указанное значение конечным (ноль, субнормальный или нормальный).
IsInfinity(Single)	Возвращает значение, указывающее, вычисляется ли указанное число отрицательным или положительным бесконечностью.
IsInteger(Single)	Определяет, представляет ли значение целочисленное значение.
IsNaN(Single)	Возвращает значение, указывающее, не является ли указанное значение числом (NaN).
IsNegative(Single)	Определяет, является ли указанное значение отрицательным.
IsNegativeInfinity(Single)	Возвращает значение, указывающее, вычисляется ли указанное число отрицательной бесконечности.
IsNormal(Single)	Определяет, является ли указанное значение нормальным.
IsOddInteger(Single)	Определяет, представляет ли значение нечетное целочисленное число.
IsPositive(Single)	Определяет, является ли значение положительным.
IsPositiveInfinity(Single)	Возвращает значение, указывающее, вычисляется ли указанное число положительным бесконечностью.
IsPow2(Single)	Определяет, является ли значение двумя.
IsRealNumber(Single)	Определяет, представляет ли значение реальное число.
IsSubnormal(Single)	Определяет, является ли указанное значение ненормальным.
Lerp(Single, Single, Single)	Выполняет линейную интерполяцию между двумя значениями на основе заданного веса.
Log(Single, Single)	Вычисляет логарифм значения в указанной базе.
Log(Single)	Вычисляет естественный (base-E логарифм значения).
Log10(Single)	Вычисляет логарифм базового-10 значения.
Log10P1(Single)	Вычисляет логарифм базового-10 значения плюс один.
Log2(Single)	Вычисляет журнал 2 значения.
Log2P1(Single)	Вычисляет логарифм базового-2 значения плюс один.
LogP1(Single)	Вычисляет естественный (base-E) логарифм значения плюс один.
Max(Single, Single)	Сравнивает два значения с вычислениями, которые больше.
MaxMagnitude(Single, Single)	Сравнивает два значения с вычислениями, которые больше.
MaxMagnitudeNumber(Single, Single)	Сравнивает два значения с вычислениями, которые имеют большую величину и возвращают другое значение, если входные данные.NaN
MaxNative(Single, Single)	Сравнивает два значения с вычислениями, которые больше используют поведение NaN для конкретной платформы и NegativeZero.
MaxNumber(Single, Single)	Сравнивает два значения с вычислениями, которые больше и возвращают другое значение, если входные данные.NaN
Min(Single, Single)	Сравнивает два значения с вычислениями, которые меньше.
MinMagnitude(Single, Single)	Сравнивает два значения с вычислениями, которые меньше.
MinMagnitudeNumber(Single, Single)	Сравнивает два значения с вычислениями, которые имеют меньшую величину и возвращают другое значение, если входные данные.NaN
MinNative(Single, Single)	Сравнивает два значения с вычислениями, которые меньше используют поведение NaN для конкретной платформы и NegativeZero.
MinNumber(Single, Single)	Сравнивает два значения с вычислениями, которые меньше и возвращают другое значение, если входные данные имеют NaNзначение.
MultiplyAddEstimate(Single, Single, Single)	Вычисляет оценку (left * right) + . addend
Parse(ReadOnlySpan<Byte>, IFormatProvider)	Анализирует диапазон символов UTF-8 в значение.
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)	Анализирует диапазон символов UTF-8 в значение.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Анализирует диапазон символов в значение.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Преобразует диапазон символов, содержащий строковое представление числа в заданном стиле и формате языка и региональных параметров, в эквивалент числа с плавающей запятой с одной точностью.
Parse(String, IFormatProvider)	Преобразует строковое представление числа в указанном формате языка и региональных параметров в эквивалент числа с плавающей запятой с одной точностью.
Parse(String, NumberStyles, IFormatProvider)	Преобразует строковое представление числа в указанном стиле и формате языка и региональных параметров в эквивалентное число с плавающей запятой с одной точностью.
Parse(String, NumberStyles)	Преобразует строковое представление числа в указанном стиле в эквивалент числа с плавающей запятой с одной точностью.
Parse(String)	Преобразует строковое представление числа в эквивалент числа с плавающей запятой с одной точностью.
Pow(Single, Single)	Вычисляет значение, возвращаемое заданной мощностью.
RadiansToDegrees(Single)	Преобразует заданное значение из радианов в градусы.
ReciprocalEstimate(Single)	Вычисляет оценку взаимности значения.
ReciprocalSqrtEstimate(Single)	Вычисляет оценку обратного квадратного корня значения.
RootN(Single, Int32)	Вычисляет корень n-го значения.
Round(Single, Int32, MidpointRounding)	Округляет значение до указанного числа дробных цифр с помощью режима округления по умолчанию (ToEven).
Round(Single, Int32)	Округляет значение до указанного числа дробных цифр с помощью режима округления по умолчанию (ToEven).
Round(Single, MidpointRounding)	Округляет значение до ближайшего целого числа с помощью указанного режима округления.
Round(Single)	Округляет значение до ближайшего целого числа с помощью режима округления по умолчанию (ToEven).
ScaleB(Single, Int32)	Вычисляет продукт значения и его базовый радикс, поднятый на указанную мощность.
Sign(Single)	Вычисляет знак значения.
Sin(Single)	Вычисляет синус значения.
SinCos(Single)	Вычисляет синус и косинус значения.
SinCosPi(Single)	Вычисляет синус и косинус значения.
Sinh(Single)	Вычисляет гиперболический синус значения.
SinPi(Single)	Вычисляет синус значения, умноженного на pi.
Sqrt(Single)	Вычисляет квадратный корень значения.
Tan(Single)	Вычисляет тангенс значения.
Tanh(Single)	Вычисляет гиперболический тангенс значения.
TanPi(Single)	Вычисляет тангенс значения, которое было несколько.pi
ToString()	Преобразует числовое значение этого экземпляра в эквивалентное строковое представление.
ToString(IFormatProvider)	Преобразует числовое значение этого экземпляра в эквивалентное строковое представление, используя указанные сведения о формате, зависящее от языка и региональных параметров.
ToString(String, IFormatProvider)	Преобразует числовое значение этого экземпляра в эквивалентное строковое представление, используя указанный формат и сведения о формате, зависящее от языка и региональных параметров.
ToString(String)	Преобразует числовое значение этого экземпляра в эквивалентное строковое представление, используя указанный формат.
Truncate(Single)	Усечение значения.
TryFormat(Span<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Пытается отформатировать значение текущего экземпляра как UTF-8 в предоставленный диапазон байтов.
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Пытается отформатировать значение текущего экземпляра числа с плавающей запятой в предоставленный диапазон символов.
TryParse(ReadOnlySpan<Byte>, IFormatProvider, Single)	Пытается проанализировать диапазон символов UTF-8 в значение.
TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, Single)	Пытается проанализировать диапазон символов UTF-8 в значение.
TryParse(ReadOnlySpan<Byte>, Single)	Пытается преобразовать диапазон символов UTF-8, содержащий строковое представление числа в эквивалент числа с плавающей запятой с одной точностью.
TryParse(ReadOnlySpan<Char>, IFormatProvider, Single)	Пытается проанализировать диапазон символов в значение.
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Single)	Преобразует представление диапазона числа в указанном стиле и формате языка и региональных параметров в эквивалентное число с плавающей запятой с одной точностью. Возвращаемое значение указывает, выполнено ли преобразование успешно или завершилось сбоем.
TryParse(ReadOnlySpan<Char>, Single)	Преобразует строковое представление числа в диапазоне символов в эквивалентное число с плавающей запятой с одной точностью. Возвращаемое значение указывает, выполнено ли преобразование успешно или завершилось сбоем.
TryParse(String, IFormatProvider, Single)	Пытается проанализировать строку в значение.
TryParse(String, NumberStyles, IFormatProvider, Single)	Преобразует строковое представление числа в указанном стиле и формате языка и региональных параметров в эквивалентное число с плавающей запятой с одной точностью. Возвращаемое значение указывает, выполнено ли преобразование успешно или завершилось сбоем.
TryParse(String, Single)	Преобразует строковое представление числа в эквивалент числа с плавающей запятой с одной точностью. Возвращаемое значение указывает, выполнено ли преобразование успешно или завершилось сбоем.

Операторы

Имя	Описание
Equality(Single, Single)	Возвращает значение, указывающее, равны ли два указанных Single значения.
GreaterThan(Single, Single)	Возвращает значение, указывающее, больше ли указанное Single значение, чем другое указанное Single значение.
GreaterThanOrEqual(Single, Single)	Возвращает значение, указывающее, больше ли указанное Single значение или равно другому указанному Single значению.
Inequality(Single, Single)	Возвращает значение, указывающее, равны ли два указанных Single значения.
LessThan(Single, Single)	Возвращает значение, указывающее, меньше ли указанное Single значение, чем другое указанное Single значение.
LessThanOrEqual(Single, Single)	Возвращает значение, указывающее, меньше ли указанное Single значение или равно другому указанному Single значению.

Явные реализации интерфейса

Имя	Описание
IAdditionOperators<Single,Single,Single>.Addition(Single, Single)	Добавляет два значения вместе для вычисления суммы.
IAdditiveIdentity<Single,Single>.AdditiveIdentity	Возвращает аддитивное удостоверение текущего типа.
IBinaryNumber<Single>.AllBitsSet	Возвращает экземпляр двоичного типа, в котором заданы все биты.
IBitwiseOperators<Single,Single,Single>.BitwiseAnd(Single, Single)	Вычисляет битовое и два значения.
IBitwiseOperators<Single,Single,Single>.BitwiseOr(Single, Single)	Вычисляет битовое или два значения.
IBitwiseOperators<Single,Single,Single>.ExclusiveOr(Single, Single)	Вычисляет монопольные или два значения.
IBitwiseOperators<Single,Single,Single>.OnesComplement(Single)	Вычисляет представление заданного значения с дополнением.
IConvertible.ToBoolean(IFormatProvider)	Описание этого элемента см. в разделе ToBoolean(IFormatProvider).
IConvertible.ToByte(IFormatProvider)	Описание этого элемента см. в разделе ToByte(IFormatProvider).
IConvertible.ToChar(IFormatProvider)	Это преобразование не поддерживается. Попытка использовать этот метод вызывает InvalidCastExceptionисключение.
IConvertible.ToDateTime(IFormatProvider)	Это преобразование не поддерживается. Попытка использовать этот метод вызывает InvalidCastExceptionисключение.
IConvertible.ToDecimal(IFormatProvider)	Описание этого элемента см. в разделе ToDecimal(IFormatProvider).
IConvertible.ToDouble(IFormatProvider)	Описание этого элемента см. в разделе ToDouble(IFormatProvider).
IConvertible.ToInt16(IFormatProvider)	Описание этого элемента см. в разделе ToInt16(IFormatProvider).
IConvertible.ToInt32(IFormatProvider)	Описание этого элемента см. в разделе ToInt32(IFormatProvider).
IConvertible.ToInt64(IFormatProvider)	Описание этого элемента см. в разделе ToInt64(IFormatProvider).
IConvertible.ToSByte(IFormatProvider)	Описание этого элемента см. в разделе ToSByte(IFormatProvider).
IConvertible.ToSingle(IFormatProvider)	Описание этого элемента см. в разделе ToSingle(IFormatProvider).
IConvertible.ToType(Type, IFormatProvider)	Описание этого элемента см. в разделе ToType(Type, IFormatProvider).
IConvertible.ToUInt16(IFormatProvider)	Описание этого элемента см. в разделе ToUInt16(IFormatProvider).
IConvertible.ToUInt32(IFormatProvider)	Описание этого элемента см. в разделе ToUInt32(IFormatProvider).
IConvertible.ToUInt64(IFormatProvider)	Описание этого элемента см. в разделе ToUInt64(IFormatProvider).
IDecrementOperators<Single>.Decrement(Single)	Уменьшает значение.
IDivisionOperators<Single,Single,Single>.Division(Single, Single)	Делит одно значение на другое, чтобы вычислить их кворот.
IFloatingPoint<Single>.GetExponentByteCount()	Возвращает количество байтов, которые будут записываться в составе TryWriteExponentLittleEndian(Span<Byte>, Int32).
IFloatingPoint<Single>.GetExponentShortestBitLength()	Возвращает длину (в битах) в кратчайшем представлении двух дополнений текущего экспонента.
IFloatingPoint<Single>.GetSignificandBitLength()	Возвращает длину (в битах) текущего знака.
IFloatingPoint<Single>.GetSignificandByteCount()	Возвращает количество байтов, которые будут записываться в составе TryWriteSignificandLittleEndian(Span<Byte>, Int32).
IFloatingPoint<Single>.TryWriteExponentBigEndian(Span<Byte>, Int32)	Пытается написать текущую экспоненту в формате big-endian в заданном диапазоне.
IFloatingPoint<Single>.TryWriteExponentLittleEndian(Span<Byte>, Int32)	Пытается написать текущий экспонент в малоконечном формате в заданном диапазоне.
IFloatingPoint<Single>.TryWriteSignificandBigEndian(Span<Byte>, Int32)	Пытается написать текущий знак в формате big-endian в заданном диапазоне.
IFloatingPoint<Single>.TryWriteSignificandLittleEndian(Span<Byte>, Int32)	Пытается написать текущий знак, в маленьком формате, в заданном диапазоне.
IFloatingPointConstants<Single>.E	Возвращает математическую константу e.
IFloatingPointConstants<Single>.Pi	Возвращает математическую константу pi.
IFloatingPointConstants<Single>.Tau	Возвращает математическую константу tau.
IFloatingPointIeee754<Single>.Epsilon	Получает наименьшее значение, которое может быть добавлено в 0 нее, не приводит к 0.
IFloatingPointIeee754<Single>.NaN	Возвращает значение, представляющее NaN.
IFloatingPointIeee754<Single>.NegativeInfinity	Возвращает значение, представляющее отрицательное infinityзначение.
IFloatingPointIeee754<Single>.NegativeZero	Возвращает значение, представляющее отрицательное zeroзначение.
IFloatingPointIeee754<Single>.PositiveInfinity	Возвращает значение, представляющее положительное infinityзначение.
IIncrementOperators<Single>.Increment(Single)	Увеличивает значение.
IMinMaxValue<Single>.MaxValue	Возвращает максимальное значение текущего типа.
IMinMaxValue<Single>.MinValue	Возвращает минимальное значение текущего типа.
IModulusOperators<Single,Single,Single>.Modulus(Single, Single)	Делит два значения вместе, чтобы вычислить их модулу или оставшуюся часть.
IMultiplicativeIdentity<Single,Single>.MultiplicativeIdentity	Возвращает умножающее удостоверение текущего типа.
IMultiplyOperators<Single,Single,Single>.Multiply(Single, Single)	Умножает два значения вместе, чтобы вычислить свой продукт.
INumberBase<Single>.IsCanonical(Single)	Определяет, находится ли значение в его каноническом представлении.
INumberBase<Single>.IsComplexNumber(Single)	Определяет, представляет ли значение сложное число.
INumberBase<Single>.IsImaginaryNumber(Single)	Определяет, представляет ли значение чистое мнимое число.
INumberBase<Single>.IsZero(Single)	Определяет, равно ли значение нулю.
INumberBase<Single>.One	Возвращает значение 1 типа.
INumberBase<Single>.Radix	Возвращает радикс или базу для типа.
INumberBase<Single>.TryConvertFromChecked<TOther>(TOther, Single)	Представляет одноточное число с плавающей запятой.
INumberBase<Single>.TryConvertFromSaturating<TOther>(TOther, Single)	Представляет одноточное число с плавающей запятой.
INumberBase<Single>.TryConvertFromTruncating<TOther>(TOther, Single)	Представляет одноточное число с плавающей запятой.
INumberBase<Single>.TryConvertToChecked<TOther>(Single, TOther)	Пытается преобразовать экземпляр текущего типа в другой тип, вызывая исключение переполнения для любых значений, которые выходят за пределы представляющего диапазона текущего типа.
INumberBase<Single>.TryConvertToSaturating<TOther>(Single, TOther)	Пытается преобразовать экземпляр текущего типа в другой тип, насыщая все значения, которые выходят за пределы представляющего диапазона текущего типа.
INumberBase<Single>.TryConvertToTruncating<TOther>(Single, TOther)	Пытается преобразовать экземпляр текущего типа в другой тип, усечение любых значений, которые выходят за пределы представляющего диапазона текущего типа.
INumberBase<Single>.Zero	Возвращает значение 0 типа.
ISignedNumber<Single>.NegativeOne	Возвращает значение -1 типа.
ISubtractionOperators<Single,Single,Single>.Subtraction(Single, Single)	Вычитает два значения, чтобы вычислить их разницу.
IUnaryNegationOperators<Single,Single>.UnaryNegation(Single)	Вычисляет унарное отрицание значения.
IUnaryPlusOperators<Single,Single>.UnaryPlus(Single)	Вычисляет унарный плюс значения.

Потокобезопасность

Все члены этого типа являются потокобезопасны. Элементы, которые, как представляется, изменяют состояние экземпляра, фактически возвращают новый экземпляр, инициализированный с новым значением. Как и в случае с любым другим типом, чтение и запись в общую переменную, которая содержит экземпляр этого типа, должна быть защищена блокировкой, чтобы гарантировать безопасность потока.

См. также раздел

• Decimal
• Double