Single Yapı

Tanım

Ad Alanı:

System

Bütünleştirilmiş Kodlar:

netstandard.dll, System.Runtime.dll

Kaynak:

Single.cs

Tek hassasiyetli kayan nokta sayısını temsil eder.

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)

Devralma

Object

ValueType

Single

Uygulamalar

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>

Açıklamalar

Single değer türü, negatif 3.402823e38'den pozitif 3.402823e38'e kadar olan değeriyle birlikte pozitif veya negatif sıfır, PositiveInfinity, NegativeInfinity ve sayı olmayan (NaN) bir tek duyarlıklı 32-bit sayıyı temsil eder. Son derece büyük (gezegenler veya galaksiler arasındaki mesafeler gibi) veya son derece küçük (kilogram cinsinden bir maddenin moleküler kütlesi gibi) ve genellikle belirsiz olan (örneğin, dünyadan başka bir güneş sistemine olan uzaklık) değerleri temsil etmeye yöneliktir. Single türü, ikili kayan nokta aritmetiği için IEC 60559:1989 (IEEE 754) standardına uygundur.

System.Single bu türün örneklerini karşılaştırmak, bir örneğin değerini string temsilcisine dönüştürmek ve bir sayının string temsilcisini bu türün bir örneğine dönüştürmek için yöntemler sağlar. Değer türlerinin dize temsillerini kontrol etmek için biçim belirtim kodlarının nasıl kullanılacağı hakkında bilgi için Biçim Türleri, Standart Sayısal Biçim Dizeleri ve Özel Sayısal Biçim Dizeleri konularına bakın.

Kayan nokta gösterimi ve hassasiyet

Single veri türü, aşağıdaki tabloda gösterildiği gibi, 32 bitlik ikili formatta tek duyarlıklı kayan nokta değerlerini depolar.

Bölüm	Bitler
İşaret veya mantis	0-22
Exponent	23-30
İşaret (0 = pozitif, 1 = negatif)	31

Ondalık kesirlerin bazı kesirli değerleri (1/3 veya Math.PIgibi) tam olarak temsil edemediği gibi, ikili kesirler de bazı kesirli değerleri temsil edemez. Örneğin, 2/10, ondalık kesir olarak tam olarak .2 ile temsil edilirken, ikili kesir olarak .0011111001001100 ile temsil edilir ve "1100" kalıbı sonsuza kadar tekrarlar. Bu durumda kayan nokta değeri, temsil ettiği sayının kesin olmayan bir gösterimini sağlar. Orijinal kayan nokta değeri üzerinde ek matematiksel işlemler yapmak genellikle onun kesinlik eksikliğini artırır. Örneğin, .3'ü 10 ile çarpmak ve .3'ü dokuz kez .3'e eklemek işlemlerinin sonuçlarını karşılaştırırsanız, eklemenin daha az hassas bir sonuç ürettiğini görürsünüz, çünkü toplama, çarpma işleminden sekiz tane daha fazla işlem içerir. tr-TR: İki Single değeri, yalnızca "R" standart sayısal biçim dizesi kullanılarak görüntülenirse, bu tutarsızlığın belirgin olduğunu unutmayın. Gerekirse, Single türünün desteklediği tüm 9 basamaklı hassasiyeti görüntüler.

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

Bazı sayılar tam olarak kesirli ikili değerler olarak temsil edilemediği için kayan noktalı sayılar yalnızca gerçek sayılara yakın olabilir.

Tüm kayan noktalı sayılar sınırlı sayıda anlamlı basamağa sahiptir ve bu da kayan noktalı bir değerin gerçek bir sayıyı ne kadar doğru bir şekilde temsil ettiğini belirler. Bir Single değeri 7'ye kadar ondalık basamak hassasiyetine sahiptir, ancak dahili olarak en fazla 9 basamak tutulur. Bu, bazı kayan nokta işlemlerinin bir kayan nokta değerini değiştirmek için yeterli hassasiyete sahip olmayabileceği anlamına gelir. Aşağıdaki örnek, büyük bir tek hassasiyetli kayan nokta değerini tanımlar ve ardından Single.Epsilon ile bir katrilyonun çarpımını buna ekler. Ancak, ürün orijinal kayan nokta değerini değiştirmek için çok küçük. En az anlamlı basamağı binden bir, üründeki en anlamlı basamak ise 10^-30'dur.

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

Kayan noktalı bir sayının sınırlı duyarlığı çeşitli sonuçlara neden olur:

• Belirli bir kesinlik için eşit görünen iki kayan noktalı sayı, en az önemli basamakları farklı olduğundan eşit olarak değerlendirilmeyebilir. Aşağıdaki örnekte, bir dizi sayı bir araya eklenir ve bunların toplamı beklenen toplamlarıyla karşılaştırılır. yöntemine yapılan Equals çağrı, değerlerin eşit olmadığını gösterir.

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

  Toplama işlemleri sırasında kesinlik kaybı nedeniyle iki değer eşit değildir. Bu durumda sorun, karşılaştırmayı gerçekleştirmeden önce Math.Round(Double, Int32) değerlerini istenen duyarlıkta yuvarlamak için Single yöntemi çağrılarak çözülebilir.

• Kayan noktalı sayı kullanan bir matematik veya karşılaştırma işlemi, ondalık sayı kullanıldığında aynı sonucu vermeyebilir çünkü ikili kayan noktalı sayı ondalık sayıya eşit olmayabilir. Daha önceki bir örnek, 0.3'ü 10 ile çarpmanın sonucunu göstererek ve 0.3'ü dokuz kez 0.3'e ekleyerek bunu açıklamıştı.

  Sayısal işlemlerde kesirli değerlerle doğruluk önemli olduğunda, Decimal türü yerine Single türünü kullanın. Sayısal işlemlerde Int64 veya UInt64 türlerinin kapsamı dışındaki tam sayı değerlerinin doğruluğu önemli olduğunda, BigInteger türünü kullanın.

• Single değerlerin duyarlığı Double değerlerden daha azdır. Duyarlık farklılıkları nedeniyle genellikle Single'e dönüştürülen bir Double değeri, Double değerine eşit değildir. Aşağıdaki örnekte, aynı bölme işlemlerinin sonucu bir Double değeri ve bir Single değeri olarak atanmıştır. Single değeri bir Double'a atandıktan sonra, iki değerin karşılaştırması bunların eşit olmadığını gösterir.

  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
  

  Bu sorunu önlemek için, Double veri türü yerine Single veri türünü kullanın veya her iki değerin de aynı hassasiyete sahip olması için Round yöntemini kullanın.

Eşitlik testi

Eşit kabul edilmesi için iki Single değerin aynı değerleri temsil etmesi gerekir. Ancak, değerler arasındaki hassasiyet farkları veya bir ya da her iki değerin hassasiyet kaybı nedeniyle, aynı olması beklenen kayan nokta değerleri, en az anlamlı basamaklarındaki farklılıklar nedeniyle sıklıkla eşit olmamaktadır. Sonuç olarak, iki değerin eşit olup olmadığını belirlemek için Equals yöntemine çağrılar veya iki CompareTo değer arasındaki ilişkiyi belirlemek için Single yöntemine çağrılar, genellikle beklenmeyen sonuçlar verir. Bu, aşağıdaki örnekte belirgindir; burada iki görünürde eşit Single değeri, ilk değerin 7 basamaklı bir hassasiyete sahip olması, oysa ikinci değerin 9 basamaklı olması nedeniyle eşit olmayan hale gelir.

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

Farklı kod yollarını izleyen ve farklı şekillerde işlenen hesaplanan değerlerin genellikle eşit olmadığını kanıtlar. Aşağıdaki örnekte, bir Single değerinin karesi alınır ve ardından orijinal değeri geri yüklemek için karekök hesaplanır. İkinci bir Single, 3,51 ile çarpılır ve karesi alınır, ardından sonucun karekökü 3,51'e bölünerek özgün değer geri yüklenir. İki değer aynı gibi görünse de, Equals(Single) yöntemine yapılan bir çağrı bunların eşit olmadığını gösterir.

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

Hassasiyet kaybının bir karşılaştırmanın sonucunu etkileme olasılığı olan durumlarda, Equals veya CompareTo yöntemini çağırmak yerine aşağıdaki teknikleri kullanabilirsiniz:

• her iki değerin de aynı duyarlıkta sahip olduğundan emin olmak için Math.Round yöntemini çağırın. Aşağıdaki örnek, önceki bir örneği bu yaklaşımı kullanacak şekilde değiştirerek iki kesirli değerin eşdeğer olmasını sağlar.

  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
  

  Kesinlik sorunu orta nokta değerlerini yuvarlama için de geçerlidir. Daha fazla bilgi için bkz. Math.Round(Double, Int32, MidpointRounding) yöntemi.

• Yaklaşık eşitlik yerine eşitlik için test yapın. Bu teknik, iki değerin farklı olabileceği ancak yine de eşit olabileceği mutlak bir miktar tanımlamanızı veya daha küçük değerin daha büyük değerden sapabileceği göreceli bir miktar tanımlamanızı gerektirir.

  Warning

  Single.Epsilon bazen eşitlik testi sırasında iki Single değeri arasındaki uzaklığın mutlak bir ölçüsü olarak kullanılır. Ancak Single.Epsilon değeri sıfır olan bir Single eklenebilecek veya çıkarılabilen en küçük olası değeri ölçer. Çoğu pozitif ve negatif Single değeri için Single.Epsilon değeri algılanamaz kadar küçüktür. Bu nedenle, sıfır olan değerler dışında, eşitlik için testlerde kullanılmasını önermeyiz.

  Aşağıdaki örnek, iki değer arasındaki göreli farkı test eden bir IsApproximatelyEqual yöntemi tanımlamak için ikinci yaklaşımı kullanır. Ayrıca IsApproximatelyEqual yöntemine ve Equals(Single) yöntemine yapılan çağrıların sonucunu karşılaştırır.

  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
  

Kayan nokta değerleri ve özel durumları

Kayan nokta değerleriyle yapılan işlemler, sıfıra bölme veya taşma gibi yasadışı işlemlerde istisnalar fırlatan tamsayı türleriyle yapılan işlemlerin aksine, istisna fırlatmaz. Bu durumlarda, bunun yerine, kayan nokta işleminin sonucu sıfır, pozitif sonsuzluk, negatif sonsuzluk veya bir sayı değil (NaN) olur.

• Kayan nokta işleminin sonucu hedef biçim için çok küçükse, sonuç sıfır olur. Bu, aşağıdaki örnekte gösterildiği gibi, iki çok küçük kayan nokta sayısı çarpıldığında meydana gelebilir.

  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
  

• Kayan nokta işleminin sonucunun büyüklüğü hedef biçimin aralığını aşarsa, sonucun işaretine uygun olarak işlemin sonucu PositiveInfinity veya NegativeInfinityolur. Single.MaxValue taşan bir işlemin sonucu PositiveInfinityve aşağıdaki örnekte gösterildiği gibi Single.MinValue taşan bir işlemin sonucu NegativeInfinity' dir.

  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, pozitif bir bölünenin sıfıra bölünmesi sonucu elde edilir ve NegativeInfinity, negatif bir bölünenin sıfıra bölünmesi sonucu elde edilir.

• Kayan nokta işlemi geçersizse, işlemin sonucu NaNolur. Örneğin, NaN aşağıdaki işlemlerden elde edilir:

  • Sıfıra, sıfırla bölme. Sıfıra bölmenin diğer durumlarının PositiveInfinity veya NegativeInfinityile sonuçlandığını unutmayın.
  • Geçersiz girişlere sahip herhangi bir kayan nokta işlemi. Örneğin, negatif bir değerin karekökünü bulmaya çalışmak NaN döndürür.
  • Değeri Single.NaNolan bağımsız değişkenle yapılan herhangi bir işlem.

Tip dönüştürmeleri

Single yapısı herhangi bir açık veya örtük dönüştürme işleci tanımlamaz; bunun yerine, dönüştürmeler derleyici tarafından uygulanır.

Aşağıdaki tabloda, diğer ilkel sayısal türlerdeki bir değerin bir değere Single olası dönüştürmeleri listelenmiştir. Ayrıca, dönüştürmenin genişleyip genişlemediğini veya daralıp daralmadığını ve elde edilen Single sonuç değerinin özgün değerden daha az hassas olma olasılığını gösterir.

Dönüşümden	Genişleme/daralma	Kesinlik kaybı mümkün
Byte	Genişletme	Hayır
Decimal	Genişletme C#'ın bir cast operatörü gerektirdiğini unutmayın.	Yes. Decimal 29 ondalık basamak duyarlığını destekler; Single 9'u destekler.
Double	Daralma; aralık dışı değerler Double.NegativeInfinity veya Double.PositiveInfinity değerine dönüştürülür.	Yes. Double 17 ondalık basamak hassasiyetini destekler; Single 9 ondalık basamağını destekler.
Int16	Genişletme	Hayır
Int32	Genişletme	Yes. Int32 10 ondalık basamak hassasiyetini destekler; Single 9 basamağını destekler.
Int64	Genişletme	Yes. Int64, 19 ondalık basamak hassasiyetini destekler; Single, 9'unu destekler.
SByte	Genişletme	Hayır
UInt16	Genişletme	Hayır
UInt32	Genişletme	Yes. UInt32 10 ondalık basamak hassasiyetini destekler; Single 9 basamağını destekler.
UInt64	Genişletme	Yes. Int64 20 ondalık basamak hassasiyet destekler; Single 9 destekler.

Aşağıdaki örnek, diğer ilkel sayısal türlerin minimum veya maksimum değerlerini bir Single değerine dönüştürür.

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)

Ayrıca, Double değerleri sırasıyla Double.NaN, Double.PositiveInfinityve Double.NegativeInfinitySingle.NaN, Single.PositiveInfinityve Single.NegativeInfinitydönüştürülür.

Bazı sayısal türlerin değerinin Single bir değere dönüştürülmesinin doğruluk kaybına yol açabileceğini unutmayın. Örnek gösterildiği gibi, Decimal, Double, Int32, Int64, UInt32 ve UInt64 değerlerini Single değerlerine dönüştürürken hassasiyet kaybı mümkündür.

Bir Single değerinin Double'ye dönüştürülmesi, genişletme dönüşümüdür. Dönüşüm, Double türünün Single değeri için kesin bir temsil biçimi olmadığında hassasiyet kaybına neden olabilir.

Single değerinin Double haricinde herhangi bir ilkel sayısal veri türüne dönüştürülmesi daraltıcı bir dönüşüm olup C# dilinde bir dönüştürme operatörü veya Visual Basic dilinde bir dönüşüm yöntemi gerektirir. Hedef türün MinValue ve MaxValue özellikleri tarafından tanımlanan hedef veri türü aralığının dışında olan değerler, aşağıdaki tabloda gösterildiği gibi davranır.

Hedef türü	Result
Herhangi bir tam sayı türü	Dönüştürme denetlenen bir bağlamda gerçekleşirse bir OverflowException istisnası. Dönüştürme denetimsiz bir bağlamda gerçekleşirse (C# dilinde varsayılan), dönüştürme işlemi başarılı olur ancak değer taşması meydana gelir.
Decimal	Bir OverflowException istisnası.

Buna ek olarak, Single.NaN, Single.PositiveInfinityve Single.NegativeInfinity, denetlenmiş bağlamda tamsayı dönüştürmeleri için bir OverflowException istisnası fırlatır, ancak bu değerler kontrolsüz bir bağlamda tamsayılara dönüştürüldüğünde taşma meydana gelir. Decimaldönüştürmeleri için her zaman bir OverflowExceptionfırlatırlar. "Double'a dönüştürmeler için, sırasıyla, Double.NaN, Double.PositiveInfinityve Double.NegativeInfinity'e dönüştürülür."

Kesinlik kaybı, bir Single değerinin başka bir sayısal türe dönüştürülmesinden kaynaklanabilir. Büyük olmayan tam sayı Single değerlerini dönüştürme durumunda, örneğin çıktısında gösterildiği gibi, kesirli bileşen kaybolur; Single değeri ya (Visual Basic'te olduğu gibi) yuvarlandığında ya da (C# ve F#'ta olduğu gibi) kesildiğinde. Decimal değerlerine dönüşümler için, Single değerinin hedef veri türünde tam bir temsili olmayabilir.

Aşağıdaki örnek, bir dizi Single değerini diğer birkaç sayısal türe dönüştürür. Visual Basic (varsayılan), C# (çünkü checked anahtar kelimesi), ve F# (çünkü open Checked ifadesi) içinde dönüşümler denetimli bir bağlamda gerçekleşir. Örnekten elde edilen çıktı, hem işaretli hem de işaretsiz bağlamlarda yapılan dönüştürmelerin sonucunu gösterir. Visual Basic'te /removeintchecks+ derleyici anahtarıyla derleyerek, C# dilinde checked ifadesini yorum satırına alarak ve F# dilinde open Checked ifadesini yorum satırına alarak denetlenmeyen bir bağlamda dönüşüm gerçekleştirebilirsiniz.

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)

Sayısal türlerin dönüştürülmesi hakkında daha fazla bilgi için .NET'te Tür Dönüştürme ve Tür Dönüştürme Tabloları bölümlerine bakın.

Kayan nokta işlevselliği

Single yapısı ve ilgili türler, aşağıdaki işlem kategorilerini gerçekleştirmek için yöntemler sağlar:

• değerleri karşılaştırması. İki Equals değerin eşit olup olmadığını belirlemek için Single yöntemini veya iki değer arasındaki ilişkiyi belirlemek için CompareTo yöntemini çağırabilirsiniz.

  Single yapısı tam bir karşılaştırma işleçleri kümesini de destekler. Örneğin, eşitlik veya eşitsizlik için testler yapabilir ya da bir değerin diğer değere eşit ya da ondan büyük olup olmadığını belirleyebilirsiniz. Eğer işleçlerden biri Double ise, Single değeri karşılaştırma yapılmadan önce Double'ye dönüştürülür. Eğer işlemcilerden biri tamsayı tipindeyse, karşılaştırma yapılmadan önce Single'e dönüştürülür. Bunlar genişletme dönüştürmeleri olsa da, kesinlik kaybı içerebilir.

  Warning

  Duyarlık farklılıkları nedeniyle, eşit olmasını beklediğiniz iki Single değeri eşit olmayabilir ve bu da karşılaştırmanın sonucunu etkiler. İki değerini karşılaştırma hakkında daha fazla bilgi için Single bölümüne bakın.

  Ayrıca, bu özel değerleri test etmek için IsNaN, IsInfinity, IsPositiveInfinityve IsNegativeInfinity yöntemlerini çağırabilirsiniz.

• Matematiksel işlemler. Genel aritmetik işlemler, örneğin toplama, çıkarma, çarpma ve bölme, dil derleyicileri ve Ortak Ara Dil (CIL) talimatları tarafından Single yöntemler yerine uygulanır. Matematiksel bir işlemin diğer işleçlerinden biri bir Double ise, Single, işlemi gerçekleştirmeden önce bir Double'ye dönüştürülür ve işlemin sonucu da bir Double değeri olur. Eğer diğer işlenen bir tam sayı türündeyse, işleme başlamadan önce Single türüne dönüştürülür ve işlemin sonucu da bir Single değeridir.

  Diğer matematiksel işlemleri, static sınıfındaki Shared yöntemlerini (System.Math Visual Basic'te) çağırarak gerçekleştirebilirsiniz. Bunlar, aritmetik için yaygın olarak kullanılan ek yöntemleri (örneğin Math.Abs, Math.Sign, ve Math.Sqrt), geometri (örneğin Math.Cos ve Math.Sin) ve kalkülüs (örneğin Math.Log) içerir. Tüm durumlarda Single değeri Double değerine dönüştürülür.

  Ayrıca, Single bir değerdeki tek tek bitleri de işleyebilirsiniz. BitConverter.GetBytes(Single) yöntemi bit desenini bayt dizisinde döndürür. Bu bayt dizisini BitConverter.ToInt32 yöntemine geçirerek, 32 bitlik bir tamsayıda Single değerinin bit desenini de koruyabilirsiniz.

• Yuvarlama. Yuvarlama, genellikle, kayan nokta gösterimi ve kesinlik sorunlarının neden olduğu değerler arasındaki farkların etkisini azaltmak için bir teknik olarak kullanılır. Single yöntemini çağırarak Math.Round değeri yuvarlayabilirsiniz. Ancak, Single değeri, yöntem çağrılmadan önce Double olarak dönüştürüldüğünü ve dönüşümün hassasiyet kaybına yol açabileceğini unutmayın.

• Biçimlendirme. Bir Single değerini kendi string temsiline dönüştürmek için ToString metodunu çağırabilir veya bileşik biçimlendirme özelliğini kullanabilirsiniz. Biçim dizelerinin kayan nokta değerlerinin dize gösterimini nasıl denetlediğini öğrenmek için bkz. Standart Sayısal Biçim Dizeleri ve Özel Sayısal Biçim Dizeleri.

• Dizeleri ayrıştırma. Bir kayan nokta değerinin dize temsilini Single değerine dönüştürebilirsiniz, bunun için Parse veya TryParse yöntemini çağırabilirsiniz. Ayrıştırma işlemi başarısız olursa, Parse yöntemi bir özel durum oluştururken, TryParse yöntemi falsedöndürür.

• Tür dönüştürme. Single yapısı, iki standart .NET veri türü arasında dönüştürmeyi destekleyen IConvertible arabirimi için açık bir arabirim uygulaması sağlar. Dil derleyicileri, Double değerlerinin Single değerlerine dönüştürülmesi dışında, diğer tüm standart sayısal türler için değerlerin örtük dönüştürülmesini de destekler. Herhangi bir standart sayısal tür değeri, Double türünün dışında bir Single türüne dönüştürülmesi genişletici bir dönüşümdür ve buna bir dönüştürme operatörü veya dönüşüm yöntemi kullanımı gerekmez.

  Ancak, 32-bit ve 64-bit tamsayı değerlerinin dönüşümü hassasiyet kaybına neden olabilir. Aşağıdaki tabloda 32 bit, 64 bit ve Double türler için duyarlık farklılıkları listelenmiştir:

  Türü	En yüksek hassasiyet (ondalık basamaklar)	Dahili hassasiyet (ondalık basamaklar)
  Double	15	17
  Int32 ve UInt32	10	10
  Int64 ve UInt64	19	19
  Single	7	9

  Hassasiyet sorunu, en sık Single değerleri Double değerlere dönüştürüldüğünde etkiler. Aşağıdaki örnekte, aynı bölme işlemleriyle üretilen iki değer eşit değildir çünkü değerlerden biri tek-precision kayan nokta değeri olup bir Double değerine dönüştürülmüştür.

  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
  

Alanlar

Name	Description
E	e sabiti tarafından belirtilen doğal logaritmik tabanı temsil eder.
Epsilon	Sıfırdan büyük en küçük pozitif Single değeri temsil eder. Bu alan sabittir.
MaxValue	mümkün olan en büyük değerini Singletemsil eder. Bu alan sabittir.
MinValue	mümkün olan en küçük değerini Singletemsil eder. Bu alan sabittir.
NaN	Bir sayıyı (NaN) temsil etmemektedir. Bu alan sabittir.
NegativeInfinity	Negatif sonsuzluğu temsil eder. Bu alan sabittir.
NegativeZero	Negatif sıfır sayısını (-0) temsil eder.
Pi	Bir dairenin çevresinin, π sabiti tarafından belirtilen çapına oranını temsil eder.
PositiveInfinity	Pozitif sonsuzluğu temsil eder. Bu alan sabittir.
Tau	τ sabiti tarafından belirtilen radyan sayısını tek seferde temsil eder.

Yöntemler

Name	Description
Abs(Single)	Bir değerin mutlak değerini hesaplar.
Acos(Single)	Bir değerin ark kosinüsünü hesaplar.
Acosh(Single)	Bir değerin hiperbolik ark kosinüsünü hesaplar.
AcosPi(Single)	Bir değerin ark kosinüsünü hesaplar ve sonucu ile piböler.
Asin(Single)	Bir değerin ark sinüsünü hesaplar.
Asinh(Single)	Bir değerin hiperbolik ark sinüsünü hesaplar.
AsinPi(Single)	Bir değerin ark sinüsünü hesaplar ve sonucu ile piböler.
Atan(Single)	Bir değerin yay tanjantını hesaplar.
Atan2(Single, Single)	İki değerin bölümünün ark tanjantını hesaplar.
Atan2Pi(Single, Single)	İki değerin bölümünün arc tanjantını hesaplar ve sonucu ile piböler.
Atanh(Single)	Bir değerin hiperbolik ark tanjantını hesaplar.
AtanPi(Single)	Bir değerin yay tanjantını hesaplar ve sonucu pi'ye böler.
BitDecrement(Single)	Belirtilen değerden daha azını karşılaştıran en büyük değeri döndürür.
BitIncrement(Single)	Belirtilen değerden büyük olan en küçük değeri döndürür.
Cbrt(Single)	Bir değerin küp kökünü hesaplar.
Ceiling(Single)	Bir değerin tavanını hesaplar.
Clamp(Single, Single, Single)	Bir değeri kapsayıcı en düşük ve en yüksek değere kelepçeler.
ClampNative(Single, Single, Single)	ve NaNiçin platforma özgü davranışı kullanarak bir değeri kapsayıcı bir minimum ve maksimum değere NegativeZero bağlar.
CompareTo(Object)	Bu örneği belirtilen bir nesneyle karşılaştırır ve bu örneğin değerinin belirtilen nesnenin değerinden küçük, buna eşit veya ondan büyük olup olmadığını gösteren bir tamsayı döndürür.
CompareTo(Single)	Bu örneği belirtilen tek duyarlıklı kayan noktalı sayıyla karşılaştırır ve bu örneğin değerinin belirtilen tek duyarlıklı kayan nokta sayısının değerinden küçük, buna eşit veya ondan büyük olup olmadığını gösteren bir tamsayı döndürür.
ConvertToInteger<TInteger>(Single)	Taşmada doygunluk kullanarak bir değeri belirtilen tamsayı türüne dönüştürür
ConvertToIntegerNative<TInteger>(Single)	Taşmada platforma özgü davranışı kullanarak bir değeri belirtilen tamsayı türüne dönüştürür.
CopySign(Single, Single)	Bir değerin işaretini başka bir değerin işaretine kopyalar.
Cos(Single)	Bir değerin kosinüsünü hesaplar.
Cosh(Single)	Bir değerin hiperbolik kosinüsünü hesaplar.
CosPi(Single)	tarafından pikatlanmış bir değerin kosinüsünü hesaplar.
CreateChecked<TOther>(TOther)	Geçerli türün bir örneğini bir değerden oluşturur ve geçerli türün temsil edilebilir aralığının dışında kalan değerler için taşma özel durumu oluşturur.
CreateSaturating<TOther>(TOther)	Bir değerden geçerli türün bir örneğini oluşturur ve geçerli türün temsil edilebilir aralığının dışında kalan tüm değerleri doygun hale getirir.
CreateTruncating<TOther>(TOther)	Geçerli türün bir örneğini bir değerden oluşturur ve geçerli türün temsil edilebilir aralığının dışında kalan değerleri kesebilir.
DegreesToRadians(Single)	Verilen değeri derecelerden radyana dönüştürür.
Equals(Object)	Bu örneğin belirtilen bir nesneye eşit olup olmadığını gösteren bir değer döndürür.
Equals(Single)	Bu örneğin ve belirtilen Single nesnenin aynı değeri temsil edip etmediğini belirten bir değer döndürür.
Exp(Single)	Belirli bir güce yükseltilmiş hesaplamalar E .
Exp10(Single)	Belirli bir güce yükseltilmiş hesaplamalar 10 .
Exp10M1(Single)	10 Belirli bir güce yükseltilen ve çıkarılan hesaplamalar.
Exp2(Single)	Belirli bir güce yükseltilmiş hesaplamalar 2 .
Exp2M1(Single)	2 Belirli bir güce yükseltilen ve çıkarılan hesaplamalar.
ExpM1(Single)	E Belirli bir güce yükseltilen ve çıkarılan hesaplamalar.
Floor(Single)	Bir değerin tabanını hesaplar.
FusedMultiplyAdd(Single, Single, Single)	Üç değerin birleşik çarpımını hesaplar.
GetHashCode()	Bu örneğin karma kodunu döndürür.
GetTypeCode()	değer türü TypeCodeiçin değerini Single döndürür.
Hypot(Single, Single)	Dik açılı üçgendeki kısa kenarların uzunluklarını temsil eden iki değer verilen hipotenüs hesaplar.
Ieee754Remainder(Single, Single)	IEEE 754 tarafından belirtilen iki değerin geri kalanını hesaplar.
ILogB(Single)	Bir değerin tamsayı logaritmasını hesaplar.
IsEvenInteger(Single)	Bir değerin çift tamsayı sayıyı temsil eder olup olmadığını belirler.
IsFinite(Single)	Belirtilen değerin sonlu (sıfır, normal altı veya normal) olup olmadığını belirler.
IsInfinity(Single)	Belirtilen sayının negatif mi yoksa pozitif sonsuz mu olduğunu belirten bir değer döndürür.
IsInteger(Single)	Bir değerin bir tamser değeri temsil eder olup olmadığını belirler.
IsNaN(Single)	Belirtilen değerin sayı (NaN) olup olmadığını gösteren bir değer döndürür.
IsNegative(Single)	Belirtilen değerin negatif olup olmadığını belirler.
IsNegativeInfinity(Single)	Belirtilen sayının negatif sonsuz olarak değerlendirilip değerlendirilmediğini belirten bir değer döndürür.
IsNormal(Single)	Belirtilen değerin normal olup olmadığını belirler.
IsOddInteger(Single)	Bir değerin tek bir tamsayı sayısını temsil ediyor olup olmadığını belirler.
IsPositive(Single)	Bir değerin pozitif olup olmadığını belirler.
IsPositiveInfinity(Single)	Belirtilen sayının pozitif sonsuz olarak değerlendirilip değerlendirilmediğini belirten bir değer döndürür.
IsPow2(Single)	Bir değerin ikinin gücü olup olmadığını belirler.
IsRealNumber(Single)	Bir değerin gerçek bir sayıyı temsil ediyor olup olmadığını belirler.
IsSubnormal(Single)	Belirtilen değerin normalin altında olup olmadığını belirler.
Lerp(Single, Single, Single)	Verilen ağırlığa göre iki değer arasında doğrusal ilişkilendirme gerçekleştirir.
Log(Single, Single)	Belirtilen tabandaki bir değerin logaritması hesaplanır.
Log(Single)	Bir değerin doğal (base-E logaritması) hesaplar.
Log10(Single)	Bir değerin 10 tabanındaki logaritması hesaplar.
Log10P1(Single)	Bir değerin ve bir değerin 10 tabanındaki logaritması hesaplar.
Log2(Single)	Bir değerin 2. günlüğünü hesaplar.
Log2P1(Single)	Bir değerin ve bir değerin 2 tabanındaki logaritması hesaplar.
LogP1(Single)	Bir değerin ve bir değerin doğal (base-E) logaritması hesaplanır.
Max(Single, Single)	daha büyük olan iki değeri işlemle karşılaştırır.
MaxMagnitude(Single, Single)	daha büyük olan iki değeri işlemle karşılaştırır.
MaxMagnitudeNumber(Single, Single)	İki değeri, daha büyük bir büyüklüğe sahip olan ve giriş ise diğer değeri döndüren işlemle karşılaştırır NaN.
MaxNative(Single, Single)	ve NaNiçin platforma özgü davranış kullanılarak daha yüksek olan iki değeri işlemle NegativeZero karşılaştırır.
MaxNumber(Single, Single)	daha büyük olan ve giriş ise diğer değeri döndüren iki değeri işlemle karşılaştırır NaN.
Min(Single, Single)	daha az olan iki değeri işlemle karşılaştırır.
MinMagnitude(Single, Single)	daha az olan iki değeri işlemle karşılaştırır.
MinMagnitudeNumber(Single, Single)	daha az büyüklüğe sahip olan ve giriş ise diğer değeri döndüren iki değeri işlemle karşılaştırır NaN.
MinNative(Single, Single)	ve NaNiçin platforma özgü davranış kullanılarak daha az olan iki değeri işlemle NegativeZero karşılaştırır.
MinNumber(Single, Single)	daha küçük olan ve giriş ise diğer değeri döndüren iki değeri işlemle karşılaştırır NaN.
MultiplyAddEstimate(Single, Single, Single)	(left * right) + addendtahminini hesaplar.
Parse(ReadOnlySpan<Byte>, IFormatProvider)	UTF-8 karakterlik bir aralığı bir değere ayrıştırıyor.
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)	UTF-8 karakterlik bir aralığı bir değere ayrıştırıyor.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Bir karakter aralığını bir değere ayrıştırıyor.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Belirli bir stilde ve kültüre özgü biçimdeki bir sayının dize gösterimini içeren karakter aralığını tek duyarlıklı kayan noktalı sayı eşdeğerine dönüştürür.
Parse(String, IFormatProvider)	Belirli bir kültüre özgü biçimdeki bir sayının dize gösterimini tek duyarlıklı kayan noktalı sayı eşdeğerine dönüştürür.
Parse(String, NumberStyles, IFormatProvider)	Belirli bir stilde ve kültüre özgü biçimdeki bir sayının dize gösterimini tek duyarlıklı kayan noktalı sayı eşdeğerine dönüştürür.
Parse(String, NumberStyles)	Belirtilen stildeki bir sayının dize gösterimini tek duyarlıklı kayan noktalı sayı eşdeğerine dönüştürür.
Parse(String)	Bir sayının dize gösterimini tek duyarlıklı kayan noktalı sayı eşdeğerine dönüştürür.
Pow(Single, Single)	Belirli bir güce yükseltilmiş bir değeri hesaplar.
RadiansToDegrees(Single)	Verilen değeri radyandan dereceye dönüştürür.
ReciprocalEstimate(Single)	Bir değerin karşılıklı tahminini hesaplar.
ReciprocalSqrtEstimate(Single)	Bir değerin karşılıklı karekökünün tahminini hesaplar.
RootN(Single, Int32)	Bir değerin n. kökünü hesaplar.
Round(Single, Int32, MidpointRounding)	Varsayılan yuvarlama modunu (ToEven) kullanarak değeri belirtilen sayıda kesirli basamağı yuvarlar.
Round(Single, Int32)	Varsayılan yuvarlama modunu (ToEven) kullanarak değeri belirtilen sayıda kesirli basamağı yuvarlar.
Round(Single, MidpointRounding)	Belirtilen yuvarlama modunu kullanarak bir değeri en yakın tamsayıya yuvarlar.
Round(Single)	Varsayılan yuvarlama modunu (ToEven) kullanarak bir değeri en yakın tamsayıya yuvarlar.
ScaleB(Single, Int32)	Bir değerin çarpımını ve belirtilen güce yükseltilmiş taban-radiksini hesaplar.
Sign(Single)	Bir değerin işaretini hesaplar.
Sin(Single)	Bir değerin sinüsünü hesaplar.
SinCos(Single)	Bir değerin sinüsünü ve kosinüsünü hesaplar.
SinCosPi(Single)	Bir değerin sinüsünü ve kosinüsünü hesaplar.
Sinh(Single)	Bir değerin hiperbolik sinüsünü hesaplar.
SinPi(Single)	ile piçarpılmış bir değerin sinüsünü hesaplar.
Sqrt(Single)	Bir değerin karekökünü hesaplar.
Tan(Single)	Bir değerin tanjantını hesaplar.
Tanh(Single)	Bir değerin hiperbolik tanjantını hesaplar.
TanPi(Single)	tarafından pikatlanmış bir değerin tanjantını hesaplar.
ToString()	Bu örneğin sayısal değerini eşdeğer dize gösterimine dönüştürür.
ToString(IFormatProvider)	Belirtilen kültüre özgü biçim bilgilerini kullanarak bu örneğin sayısal değerini eşdeğer dize gösterimine dönüştürür.
ToString(String, IFormatProvider)	Belirtilen biçim ve kültüre özgü biçim bilgilerini kullanarak bu örneğin sayısal değerini eşdeğer dize gösterimine dönüştürür.
ToString(String)	Belirtilen biçimi kullanarak bu örneğin sayısal değerini eşdeğer dize gösterimine dönüştürür.
Truncate(Single)	Bir değeri kısaltılır.
TryFormat(Span<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Geçerli örneğin değerini UTF-8 olarak sağlanan bayt aralığına biçimlendirmeye çalışır.
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Geçerli kayan sayı örneğinin değerini sağlanan karakter aralığına biçimlendirmeye çalışır.
TryParse(ReadOnlySpan<Byte>, IFormatProvider, Single)	UTF-8 karakterlik bir aralığı bir değere ayrıştırmaya çalışır.
TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, Single)	UTF-8 karakterlik bir aralığı bir değere ayrıştırmaya çalışır.
TryParse(ReadOnlySpan<Byte>, Single)	Bir sayının dize gösterimini içeren UTF-8 karakter aralığını tek duyarlıklı kayan noktalı sayı eşdeğerine dönüştürmeye çalışır.
TryParse(ReadOnlySpan<Char>, IFormatProvider, Single)	Bir karakter aralığını bir değere ayrıştırmaya çalışır.
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Single)	Belirli bir stilde ve kültüre özgü biçimdeki bir sayının span gösterimini tek duyarlıklı kayan noktalı sayı eşdeğerine dönüştürür. Dönüş değeri, dönüştürmenin başarılı mı yoksa başarısız mı olduğunu gösterir.
TryParse(ReadOnlySpan<Char>, Single)	Karakter aralığındaki bir sayının dize gösterimini tek duyarlıklı kayan noktalı sayı eşdeğerine dönüştürür. Dönüş değeri, dönüştürmenin başarılı mı yoksa başarısız mı olduğunu gösterir.
TryParse(String, IFormatProvider, Single)	Bir dizeyi bir değere ayrıştırmaya çalışır.
TryParse(String, NumberStyles, IFormatProvider, Single)	Belirli bir stilde ve kültüre özgü biçimdeki bir sayının dize gösterimini tek duyarlıklı kayan noktalı sayı eşdeğerine dönüştürür. Dönüş değeri, dönüştürmenin başarılı mı yoksa başarısız mı olduğunu gösterir.
TryParse(String, Single)	Bir sayının dize gösterimini tek duyarlıklı kayan noktalı sayı eşdeğerine dönüştürür. Dönüş değeri, dönüştürmenin başarılı mı yoksa başarısız mı olduğunu gösterir.

İşleçler

Name	Description
Equality(Single, Single)	Belirtilen Single iki değerin eşit olup olmadığını gösteren bir değer döndürür.
GreaterThan(Single, Single)	Belirtilen değerin başka Single bir belirtilen Single değerden büyük olup olmadığını gösteren bir değer döndürür.
GreaterThanOrEqual(Single, Single)	Belirtilen değerin başka Single bir belirtilen Single değerden büyük veya buna eşit olup olmadığını gösteren bir değer döndürür.
Inequality(Single, Single)	Belirtilen Single iki değerin eşit olup olmadığını gösteren bir değer döndürür.
LessThan(Single, Single)	Belirtilen değerin başka Single bir belirtilen Single değerden küçük olup olmadığını gösteren bir değer döndürür.
LessThanOrEqual(Single, Single)	Belirtilen değerin başka Single bir belirtilen Single değerden küçük veya buna eşit olup olmadığını gösteren bir değer döndürür.

Belirtik Arabirim Kullanımları

Name	Description
IAdditionOperators<Single,Single,Single>.Addition(Single, Single)	Toplamlarını hesaplamak için iki değeri bir araya ekler.
IAdditiveIdentity<Single,Single>.AdditiveIdentity	Geçerli türün ek kimliğini alır.
IBinaryNumber<Single>.AllBitsSet	Tüm bitlerin ayarlandığı ikili türün bir örneğini alır.
IBitwiseOperators<Single,Single,Single>.BitwiseAnd(Single, Single)	İki değerin bit düzeyinde ve değerini hesaplar.
IBitwiseOperators<Single,Single,Single>.BitwiseOr(Single, Single)	bit düzeyinde veya iki değeri hesaplar.
IBitwiseOperators<Single,Single,Single>.ExclusiveOr(Single, Single)	İki değerin özel veya özel değerini hesaplar.
IBitwiseOperators<Single,Single,Single>.OnesComplement(Single)	Belirli bir değerin bire tamamlayan gösterimini hesaplar.
IConvertible.ToBoolean(IFormatProvider)	Bu üyenin açıklaması için bkz ToBoolean(IFormatProvider). .
IConvertible.ToByte(IFormatProvider)	Bu üyenin açıklaması için bkz ToByte(IFormatProvider). .
IConvertible.ToChar(IFormatProvider)	Bu dönüştürme desteklenmez. Bu yöntemi kullanmaya çalışmak bir InvalidCastExceptionoluşturur.
IConvertible.ToDateTime(IFormatProvider)	Bu dönüştürme desteklenmez. Bu yöntemi kullanmaya çalışmak bir InvalidCastExceptionoluşturur.
IConvertible.ToDecimal(IFormatProvider)	Bu üyenin açıklaması için bkz ToDecimal(IFormatProvider). .
IConvertible.ToDouble(IFormatProvider)	Bu üyenin açıklaması için bkz ToDouble(IFormatProvider). .
IConvertible.ToInt16(IFormatProvider)	Bu üyenin açıklaması için bkz ToInt16(IFormatProvider). .
IConvertible.ToInt32(IFormatProvider)	Bu üyenin açıklaması için bkz ToInt32(IFormatProvider). .
IConvertible.ToInt64(IFormatProvider)	Bu üyenin açıklaması için bkz ToInt64(IFormatProvider). .
IConvertible.ToSByte(IFormatProvider)	Bu üyenin açıklaması için bkz ToSByte(IFormatProvider). .
IConvertible.ToSingle(IFormatProvider)	Bu üyenin açıklaması için bkz ToSingle(IFormatProvider). .
IConvertible.ToType(Type, IFormatProvider)	Bu üyenin açıklaması için bkz ToType(Type, IFormatProvider). .
IConvertible.ToUInt16(IFormatProvider)	Bu üyenin açıklaması için bkz ToUInt16(IFormatProvider). .
IConvertible.ToUInt32(IFormatProvider)	Bu üyenin açıklaması için bkz ToUInt32(IFormatProvider). .
IConvertible.ToUInt64(IFormatProvider)	Bu üyenin açıklaması için bkz ToUInt64(IFormatProvider). .
IDecrementOperators<Single>.Decrement(Single)	Bir değeri azaltma.
IDivisionOperators<Single,Single,Single>.Division(Single, Single)	Kendi bölümünü hesaplamak için bir değeri diğerine böler.
IFloatingPoint<Single>.GetExponentByteCount()	bir parçası TryWriteExponentLittleEndian(Span<Byte>, Int32)olarak yazılacak bayt sayısını alır.
IFloatingPoint<Single>.GetExponentShortestBitLength()	Geçerli üssün en kısa iki tamamlayıcı gösteriminin uzunluğunu bit cinsinden alır.
IFloatingPoint<Single>.GetSignificandBitLength()	Geçerli işaret işaretinin bit cinsinden uzunluğunu alır.
IFloatingPoint<Single>.GetSignificandByteCount()	bir parçası TryWriteSignificandLittleEndian(Span<Byte>, Int32)olarak yazılacak bayt sayısını alır.
IFloatingPoint<Single>.TryWriteExponentBigEndian(Span<Byte>, Int32)	Geçerli üs büyük endian biçiminde belirli bir yayılmaya yazmaya çalışır.
IFloatingPoint<Single>.TryWriteExponentLittleEndian(Span<Byte>, Int32)	Geçerli üssü küçük endian biçiminde belirli bir süreye yazmaya çalışır.
IFloatingPoint<Single>.TryWriteSignificandBigEndian(Span<Byte>, Int32)	Geçerli işaret işaretini büyük endian biçiminde belirli bir span'a yazmaya çalışır.
IFloatingPoint<Single>.TryWriteSignificandLittleEndian(Span<Byte>, Int32)	Geçerli işaret işaretini küçük endian biçiminde belirli bir span'a yazmaya çalışır.
IFloatingPointConstants<Single>.E	matematiksel sabitini ealır.
IFloatingPointConstants<Single>.Pi	matematiksel sabitini pialır.
IFloatingPointConstants<Single>.Tau	matematiksel sabitini taualır.
IFloatingPointIeee754<Single>.Epsilon	ile sonuçlanmayan 0öğesine 0 eklenebilen en küçük değeri alır.
IFloatingPointIeee754<Single>.NaN	öğesini temsil NaNeden bir değer alır.
IFloatingPointIeee754<Single>.NegativeInfinity	Negatif infinitydeğerini temsil eden bir değer alır.
IFloatingPointIeee754<Single>.NegativeZero	Negatif zerodeğerini temsil eden bir değer alır.
IFloatingPointIeee754<Single>.PositiveInfinity	Pozitif infinitydeğerini temsil eden bir değer alır.
IIncrementOperators<Single>.Increment(Single)	Bir değeri artırır.
IMinMaxValue<Single>.MaxValue	Geçerli türün en büyük değerini alır.
IMinMaxValue<Single>.MinValue	Geçerli türün en düşük değerini alır.
IModulusOperators<Single,Single,Single>.Modulus(Single, Single)	Modüllerini veya kalan değerlerini hesaplamak için iki değeri birbirine böler.
IMultiplicativeIdentity<Single,Single>.MultiplicativeIdentity	Geçerli türün çarpımlı kimliğini alır.
IMultiplyOperators<Single,Single,Single>.Multiply(Single, Single)	Ürünlerini hesaplamak için iki değeri bir araya getiren.
INumberBase<Single>.IsCanonical(Single)	Bir değerin kurallı gösteriminde olup olmadığını belirler.
INumberBase<Single>.IsComplexNumber(Single)	Bir değerin karmaşık bir sayıyı temsil ediyor olup olmadığını belirler.
INumberBase<Single>.IsImaginaryNumber(Single)	Bir değerin saf bir sanal sayıyı temsil ediyor olup olmadığını belirler.
INumberBase<Single>.IsZero(Single)	Değerin sıfır olup olmadığını belirler.
INumberBase<Single>.One	Türün değerini 1 alır.
INumberBase<Single>.Radix	Türün radiksini veya tabanını alır.
INumberBase<Single>.TryConvertFromChecked<TOther>(TOther, Single)	Tek hassasiyetli kayan nokta sayısını temsil eder.
INumberBase<Single>.TryConvertFromSaturating<TOther>(TOther, Single)	Tek hassasiyetli kayan nokta sayısını temsil eder.
INumberBase<Single>.TryConvertFromTruncating<TOther>(TOther, Single)	Tek hassasiyetli kayan nokta sayısını temsil eder.
INumberBase<Single>.TryConvertToChecked<TOther>(Single, TOther)	Geçerli türün bir örneğini başka bir türe dönüştürmeyi dener ve geçerli türün temsil edilebilir aralığının dışında kalan değerler için bir taşma özel durumu oluşturur.
INumberBase<Single>.TryConvertToSaturating<TOther>(Single, TOther)	Geçerli türün bir örneğini başka bir türe dönüştürmeyi dener ve geçerli türün temsil edilebilir aralığının dışında kalan değerleri doygunluğa getirir.
INumberBase<Single>.TryConvertToTruncating<TOther>(Single, TOther)	Geçerli türün bir örneğini başka bir türe dönüştürmeye çalışır ve geçerli türün temsil edilebilir aralığının dışında kalan tüm değerleri kısaltır.
INumberBase<Single>.Zero	Türün değerini 0 alır.
ISignedNumber<Single>.NegativeOne	Türün değerini -1 alır.
ISubtractionOperators<Single,Single,Single>.Subtraction(Single, Single)	Farklarını hesaplamak için iki değeri çıkarır.
IUnaryNegationOperators<Single,Single>.UnaryNegation(Single)	Bir değerin tekli olumsuzlamasını hesaplar.
IUnaryPlusOperators<Single,Single>.UnaryPlus(Single)	Bir değerin birli artısını hesaplar.

İş Parçacığı Güvenliği

Bu türün tüm üyeleri iş parçacığı güvenlidir. Örnek durumunu değiştirmek için görünen üyeler aslında yeni değerle başlatılan yeni bir örnek döndürür. Diğer türlerde olduğu gibi, iş parçacığı güvenliğini garanti etmek için bu türün bir örneğini içeren paylaşılan bir değişkene okuma ve yazma bir kilit tarafından korunmalıdır.

Ayrıca bkz.

• Decimal
• Double