Single 구조체

정의

단정밀도 부동 소수점 숫자를 나타냅니다.

public value class float : IComparable, IComparable<float>, IConvertible, IEquatable<float>, IFormattable
public value class float : IComparable, IComparable<float>, IConvertible, IEquatable<float>, ISpanFormattable
public value class float : IComparable, IConvertible, IFormattable
public value class float : IComparable, IComparable<float>, IEquatable<float>, IFormattable
public struct Single : IComparable, IComparable<float>, IConvertible, IEquatable<float>, IFormattable
public struct Single : IComparable, IComparable<float>, IConvertible, IEquatable<float>, ISpanFormattable
[System.Serializable]
public struct Single : IComparable, IConvertible, IFormattable
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public struct Single : IComparable, IComparable<float>, IConvertible, IEquatable<float>, IFormattable
public struct Single : IComparable, IComparable<float>, IEquatable<float>, IFormattable
type single = struct
    interface IConvertible
    interface IFormattable
type single = struct
    interface IConvertible
    interface ISpanFormattable
    interface IFormattable
[<System.Serializable>]
type single = struct
    interface IFormattable
    interface IConvertible
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type single = struct
    interface IFormattable
    interface IConvertible
type single = struct
    interface IFormattable
Public Structure Single
Implements IComparable, IComparable(Of Single), IConvertible, IEquatable(Of Single), IFormattable
Public Structure Single
Implements IComparable, IComparable(Of Single), IConvertible, IEquatable(Of Single), ISpanFormattable
Public Structure Single
Implements IComparable, IConvertible, IFormattable
Public Structure Single
Implements IComparable, IComparable(Of Single), IEquatable(Of Single), IFormattable
상속
Single
특성
구현

설명

Single값 형식은 음수 3.402823e38에서 양수 3.402823e38까지의 값이 있는 단정밀도 32비트 PositiveInfinity NegativeInfinity 숫자와 숫자( )가 아닌 양수 또는 음수 0, , 를 NaN 나타냅니다. 이 값은 매우 크거나(예: 행성 또는 난소 간 거리) 매우 작거나(예: 간에 있는 양의 분자량) 종종 부정확한 값(예: 지구와 다른 태양 시스템 간 거리)을 나타내기 위한 것입니다. Single이 형식은 이진 부동 소수점 산술 연산에 대한 IEC 60559:1989(IEEE 754) 표준을 준수합니다.

이 문서는 다음 섹션으로 구성됩니다.

System.Single 에서는 이 형식의 인스턴스를 비교하고, 인스턴스 값을 해당 문자열 표현으로 변환하고, 숫자의 문자열 표현을 이 형식의 인스턴스로 변환하는 메서드를 제공합니다. 형식 사양 코드가 값 형식의 문자열 표현을 제어하는방법에 대한 자세한 내용은 형식 서식 지정, 표준 숫자 형식 문자열및 사용자 지정 숫자 형식 문자열을 참조하세요.

부동 소수점 표현 및 정밀도

Single데이터 형식은 다음 표와 같이 단정밀도 부동 소수점 값을 32비트 이진 형식으로 저장합니다.

파트 비트
Significand 또는 mantissa 0-22
지수 23-30
부호(0 = 양수, 1 = 음수) 31

소수 부분이 일부 소수 값(예: 1/3 또는 )을 정확하게 나타낼 수 없는 것처럼 Math.PI 이진 분수는 일부 소수 값을 나타낼 수 없습니다. 예를 들어 .2로 정확하게 .2로 표현되는 2/10은 .0011111001001100 이진 분수로 표현되고 패턴 "1100"은 무한대로 반복됩니다. 이 경우 부동 소수점 값은 나타내는 숫자의 부정확한 표현을 제공합니다. 원래 부동 소수점 값에 대해 추가 수학 연산을 수행하면 정밀도 부족이 증가하는 경우가 많습니다. 예를 들어 .3을 10으로 곱하고 .3을 .3에 9번 추가하는 결과를 비교하면 곱하기보다 8개 더 많은 연산이 포함되므로 더하기는 덜 정확한 결과를 생성합니다. 이 차이는 "R" 표준 숫자 서식 문자열 를 사용하여 두 값을 표시하는 경우에만 분명합니다. Single 필요한 경우 형식에서 지원하는 전체 자릿수의 9자리를 모두 표시합니다. Single

using System;

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

      Console.WriteLine(".2 * 10:           {0:R}", result1);
      Console.WriteLine(".2 Added 10 times: {0:R}", result2);
   }
}
// The example displays the following output:
//       .2 * 10:           2
//       .2 Added 10 times: 2.00000024
Module Example
   Public Sub Main()
      Dim value As Single = .2
      Dim result1 As Single = value * 10
      Dim result2 As Single
      For ctr As Integer = 1 To 10
         result2 += value
      Next
      Console.WriteLine(".2 * 10:           {0:R}", result1)
      Console.WriteLine(".2 Added 10 times: {0:R}", result2)
   End Sub
End Module
' The example displays the following output:
'       .2 * 10:           2
'       .2 Added 10 times: 2.00000024

일부 숫자는 소수 부분 이진 값으로 정확하게 나타낼 수 없으므로 부동 소수점 숫자는 근사값 실수만 가능합니다.

모든 부동 소수점 숫자에는 제한된 수의 유의 자릿수가 있으며, 이는 부동 소수점 값이 실수에 얼마나 정확하게 해당하는지도 결정합니다. Single값에는 최대 9자리의 자릿수가 내부적으로 유지되지만 최대 7자리의 정밀도가 있습니다. 즉, 일부 부동 소수점 연산에는 부동 소수점 값을 변경하는 전체 자릿수가 부족할 수 있습니다. 다음 예제에서는 큰 단정밀도 부동 소수점 값을 정의한 다음 의 Single.Epsilon 곱과 1분면을 추가합니다. 그러나 제품이 너무 작아서 원래 부동 소수점 값을 수정할 수 없는 경우 가장 적은 자릿수는 10/30인 반면, 제품에서 가장 중요한 숫자는10-30입니다.

using System;

public class Example
{
   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
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 Example
    {
       public static void Main()
       {
          Single[] values = { 10.01f, 2.88f, 2.88f, 2.88f, 9.0f };
          Single result = 27.65f;
          Single total = 0f;
          foreach (var value in values)
             total += value;
    
          if (total.Equals(result))
             Console.WriteLine("The sum of the values equals the total.");
          else
             Console.WriteLine("The sum of the values ({0}) does not equal the total ({1}).",
                               total, result); 
       }
    }
    // The example displays the following output:
    //      The sum of the values (27.65) does not equal the total (27.65).   
    //
    // If the index items in the Console.WriteLine statement are changed to {0:R},
    // the example displays the following output:
    //       The sum of the values (27.6500015) does not equal the total (27.65).
    
    Module Example
       Public Sub Main()
          Dim values() As Single = { 10.01, 2.88, 2.88, 2.88, 9.0 }
          Dim result As Single = 27.65
          Dim total As Single
          For Each value In values
             total += value
          Next
          If total.Equals(result) Then
             Console.WriteLine("The sum of the values equals the total.")
          Else
             Console.WriteLine("The sum of the values ({0}) does not equal the total ({1}).",
                               total, result) 
          End If     
       End Sub
    End Module
    ' The example displays the following output:
    '      The sum of the values (27.65) does not equal the total (27.65).   
    '
    ' If the index items in the Console.WriteLine statement are changed to {0:R},
    ' the example displays the following output:
    '       The sum of the values (27.639999999999997) does not equal the total (27.64).
    

    두 값의 모든 중요 자릿수를 표시하기 위해 문에서 형식 항목을 및 로 변경하는 경우 Console.WriteLine(String, Object, Object) {0} {1} {0:R} {1:R} Single 더하기 작업 중에 전체 자릿수가 손실되어 두 값이 같지 않은 것이 분명합니다. 이 경우 Math.Round(Double, Int32) 비교를 수행하기 전에 메서드를 호출하여 Single 값을 원하는 전체 자릿수로 반올림하여 문제를 해결할 수 있습니다.

  • 부동 소수점 숫자를 사용하는 수학 또는 비교 연산은 10진수를 사용하는 경우 이진 부동 소수점 숫자가 10진수와 같지 않을 수 있으므로 동일한 결과를 생성하지 못할 수 있습니다. 이전 예제에서는 .3을 10으로 곱한 결과를 표시하고 .3을 .3에 9번 추가하여 이를 설명했습니다.

    소수 값이 있는 숫자 연산의 정확도가 중요한 경우 Decimal 형식 대신 형식을 Single 사용합니다. 정수 계열 값이 또는 형식의 범위를 벗어나는 숫자 연산의 정확도가 Int64 UInt64 중요한 경우 BigInteger 형식을 사용합니다.

  • 부동 소수점 숫자가 관련된 경우 값이 라운드트립되지 않을 수 있습니다. 연산이 원래 부동 소수점 숫자를 다른 형식으로 변환하고, 역 연산이 변환된 폼을 다시 부동 소수점 숫자로 변환하고, 최종 부동 소수점 숫자가 원래 부동 소수점 숫자와 같으면 값을 라운드트립이라고 합니다. 변환에서 하나 이상의 최소 중요 자릿수가 손실되거나 변경되어 라운드트립이 실패할 수 있습니다. 다음 예제에서는 세 Single 개의 값이 문자열로 변환되어 파일에 저장됩니다. 출력에서와 같이 값이 동일해 보이지만 복원된 값은 원래 값과 같지 않습니다.

    using System;
    using System.IO;
    
    public class Example
    {
       public static void Main()
       {
          StreamWriter sw = new StreamWriter(@".\Singles.dat");
          Single[] values = { 3.2f/1.11f, 1.0f/3f, (float) Math.PI };
          for (int ctr = 0; ctr < values.Length; ctr++) {
             sw.Write(values[ctr].ToString());
             if (ctr != values.Length - 1)
                sw.Write("|");
          }      
          sw.Close();
          
          Single[] restoredValues = new Single[values.Length];
          StreamReader sr = new StreamReader(@".\Singles.dat");
          string temp = sr.ReadToEnd();
          string[] tempStrings = temp.Split('|');
          for (int ctr = 0; ctr < tempStrings.Length; ctr++)
             restoredValues[ctr] = Single.Parse(tempStrings[ctr]);   
    
          for (int ctr = 0; ctr < values.Length; ctr++)
             Console.WriteLine("{0} {2} {1}", values[ctr], 
                               restoredValues[ctr],
                               values[ctr].Equals(restoredValues[ctr]) ? "=" : "<>");
       }
    }
    // The example displays the following output:
    //       2.882883 <> 2.882883
    //       0.3333333 <> 0.3333333
    //       3.141593 <> 3.141593
    
    Imports System.IO
    
    Module Example
       Public Sub Main()
          Dim sw As New StreamWriter(".\Singles.dat")
          Dim values() As Single = { 3.2/1.11, 1.0/3, CSng(Math.PI)  }
          For ctr As Integer = 0 To values.Length - 1
             sw.Write(values(ctr).ToString())
             If ctr <> values.Length - 1 Then sw.Write("|")
          Next      
          sw.Close()
          
          Dim restoredValues(values.Length - 1) As Single
          Dim sr As New StreamReader(".\Singles.dat")
          Dim temp As String = sr.ReadToEnd()
          Dim tempStrings() As String = temp.Split("|"c)
          For ctr As Integer = 0 To tempStrings.Length - 1
             restoredValues(ctr) = Single.Parse(tempStrings(ctr))   
          Next 
    
          For ctr As Integer = 0 To values.Length - 1
             Console.WriteLine("{0} {2} {1}", values(ctr), 
                               restoredValues(ctr),
                               If(values(ctr).Equals(restoredValues(ctr)), "=", "<>"))
          Next
       End Sub
    End Module
    ' The example displays the following output:
    '        2.882883 <> 2.882883
    '        0.3333333 <> 0.3333333
    '        3.141593 <> 3.141593
    

    이 경우 다음 예제와 같이 값의 전체 전체 자릿수를 유지하기 위해 "G9" 표준 숫자 서식 문자열을 사용하여 값을 성공적으로 라운드트립할 수 Single 있습니다.

    using System;
    using System.IO;
    
    public class Example
    {
       public static void Main()
       {
          StreamWriter sw = new StreamWriter(@".\Singles.dat");
          Single[] values = { 3.2f/1.11f, 1.0f/3f, (float) Math.PI };
          for (int ctr = 0; ctr < values.Length; ctr++) 
             sw.Write("{0:G9}{1}", values[ctr], ctr < values.Length - 1 ? "|" : "" );
          
          sw.Close();
          
          Single[] restoredValues = new Single[values.Length];
          StreamReader sr = new StreamReader(@".\Singles.dat");
          string temp = sr.ReadToEnd();
          string[] tempStrings = temp.Split('|');
          for (int ctr = 0; ctr < tempStrings.Length; ctr++)
             restoredValues[ctr] = Single.Parse(tempStrings[ctr]);   
    
          for (int ctr = 0; ctr < values.Length; ctr++)
             Console.WriteLine("{0} {2} {1}", values[ctr], 
                               restoredValues[ctr],
                               values[ctr].Equals(restoredValues[ctr]) ? "=" : "<>");
       }
    }
    // The example displays the following output:
    //       2.882883 = 2.882883
    //       0.3333333 = 0.3333333
    //       3.141593 = 3.141593
    
    Imports System.IO
    
    Module Example
       Public Sub Main()
          Dim sw As New StreamWriter(".\Singles.dat")
          Dim values() As Single = { 3.2/1.11, 1.0/3, CSng(Math.PI)  }
          For ctr As Integer = 0 To values.Length - 1
             sw.Write("{0:G9}{1}", values(ctr), 
                      If(ctr < values.Length - 1, "|", ""))
          Next      
          sw.Close()
          
          Dim restoredValues(values.Length - 1) As Single
          Dim sr As New StreamReader(".\Singles.dat")
          Dim temp As String = sr.ReadToEnd()
          Dim tempStrings() As String = temp.Split("|"c)
          For ctr As Integer = 0 To tempStrings.Length - 1
             restoredValues(ctr) = Single.Parse(tempStrings(ctr))   
          Next 
    
          For ctr As Integer = 0 To values.Length - 1
             Console.WriteLine("{0} {2} {1}", values(ctr), 
                               restoredValues(ctr),
                               If(values(ctr).Equals(restoredValues(ctr)), "=", "<>"))
          Next
       End Sub
    End Module
    ' The example displays the following output:
    '       2.882883 = 2.882883
    '       0.3333333 = 0.3333333
    '       3.141593 = 3.141593
    
  • Single 값은 값보다 정밀도가 Double 낮습니다. Single거의 동일한 값으로 변환되는 Double Double 값은 정밀도 차이로 인해 값과 같지 않은 경우가 많습니다. 다음 예제에서는 동일한 나누기 연산의 결과가 Double 값과 Single 값에 할당됩니다. 값이 로 캐스팅된 후 두 값을 비교하면 같지 Single 않은 것으로 Double 표시됩니다.

    using System;
    
    public class Example
    {
       public static void Main()
       {
          Double value1 = 1/3.0;
          Single sValue2 = 1/3.0f;
          Double value2 = (Double) sValue2;
          Console.WriteLine("{0:R} = {1:R}: {2}", value1, value2,
                                              value1.Equals(value2));
       }
    }
    // The example displays the following output:
    //        0.33333333333333331 = 0.3333333432674408: False
    
    Module Example
       Public Sub Main()
          Dim value1 As Double = 1/3
          Dim sValue2 As Single = 1/3
          Dim value2 As Double = CDbl(sValue2)
          Console.WriteLine("{0} = {1}: {2}", value1, value2, value1.Equals(value2))
       End Sub
    End Module
    ' The example displays the following output:
    '       0.33333333333333331 = 0.3333333432674408: False
    

    이 문제를 방지하려면 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("{0:R} = {1:R}: {2}", value1, value2, value1.Equals(value2));
   }
}
// The example displays the following output:
//        0.3333333 = 0.333333343: False
Module Example
   Public Sub Main()
      Dim value1 As Single = .3333333
      Dim value2 As Single = 1/3
      Console.WriteLine("{0:R} = {1:R}: {2}", value1, value2, value1.Equals(value2))
   End Sub
End Module
' The example displays the following output:
'       0.3333333 = 0.333333343: False

서로 다른 코드 경로를 따르고 다양한 방식으로 조작되는 계산된 값은 종종 같지 않은 것으로 입증됩니다. 다음 예제에서는 값 하나를 Single 제곱한 다음 제곱근을 계산하여 원래 값을 복원합니다. Single1초는 3.51을 곱한 다음 결과의 제곱근을 3.51로 나누어 원래 값을 복원합니다. 두 값이 동일한 것처럼 보이지만 Equals(Single) 메서드를 호출하면 같지 않음을 나타냅니다. "G9" 표준 서식 문자열을 사용하여 각 값의 모든 중요 자릿수를 표시하는 결과 문자열을 반환하면 Single 두 번째 값이 .0000000000001 첫 번째 값보다 작은 것으로 표시됩니다.

using System;

public class Example
{
   public static void Main()
   {
      float value1 = 10.201438f;
      value1 = (float) Math.Sqrt((float) Math.Pow(value1, 2));
      float value2 = (float) Math.Pow((float) value1 * 3.51f, 2);
      value2 = ((float) Math.Sqrt(value2)) / 3.51f;
      Console.WriteLine("{0} = {1}: {2}\n", 
                        value1, value2, value1.Equals(value2)); 
      Console.WriteLine("{0:G9} = {1:G9}", value1, value2); 
   }
}
// The example displays the following output:
//       10.20144 = 10.20144: False
//       
//       10.201438 = 10.2014389
Module Example
   Public Sub Main()
      Dim value1 As Single = 10.201438
      value1 = CSng(Math.Sqrt(CSng(Math.Pow(value1, 2))))
      Dim value2 As Single = CSng(Math.Pow(value1 * CSng(3.51), 2))
      value2 = CSng(Math.Sqrt(value2) / CSng(3.51))
      Console.WriteLine("{0} = {1}: {2}", 
                        value1, value2, value1.Equals(value2)) 
      Console.WriteLine()
      Console.WriteLine("{0:G9} = {1:G9}", value1, value2) 
   End Sub
End Module
' The example displays the following output:
'       10.20144 = 10.20144: False
'       
'       10.201438 = 10.2014389

정밀도 손실이 비교 결과에 영향을 줄 수 있는 경우 Equals 또는 메서드를 호출하는 대신 다음 기술을 사용할 수 있습니다. CompareTo

  • Math.Round메서드를 호출하여 두 값의 전체 자릿수가 같은지 확인합니다. 다음 예제에서는 두 개의 소수 값이 동일하도록 이 방법을 사용하도록 이전 예제를 수정합니다.

    using System;
    
    public class Example
    {
       public static void Main()
       {
          float value1 = .3333333f;
          float value2 = 1.0f/3;
          int precision = 7;
          value1 = (float) Math.Round(value1, precision);
          value2 = (float) Math.Round(value2, precision);
          Console.WriteLine("{0:R} = {1:R}: {2}", value1, value2, value1.Equals(value2));
       }
    }
    // The example displays the following output:
    //        0.3333333 = 0.3333333: True
    
    Module Example
       Public Sub Main()
          Dim value1 As Single = .3333333
          Dim value2 As Single = 1/3
          Dim precision As Integer = 7
          value1 = CSng(Math.Round(value1, precision))
          value2 = CSng(Math.Round(value2, precision))
          Console.WriteLine("{0:R} = {1:R}: {2}", value1, value2, value1.Equals(value2))
       End Sub
    End Module
    ' The example displays the following output:
    '       0.3333333 = 0.3333333: True
    

    정밀도 문제는 중간점 값의 반올림에도 계속 적용됩니다. 자세한 내용은 Math.Round(Double, Int32, MidpointRounding) 메서드를 참조하세요.

  • 같음 대신 대략적인 같음 테스트 이 기술을 사용하려면 두 값이 다를 수 있지만 여전히 같을 수 있는 절대 양을 정의하거나 더 작은 값이 더 큰 값과 다를 수 있는 상대 양을 정의해야 합니다.

    경고

    Single.Epsilon 는 같은지 테스트할 때 두 값 사이의 거리를 절대 측정값으로 사용하는 경우가 Single 있습니다. 그러나 는 Single.Epsilon 값이 0인 에 추가하거나 뺄 수 있는 가능한 가장 작은 Single 값을 측정합니다. 대부분의 양수 및 Single 음수 값의 경우 의 Single.Epsilon 값이 너무 작아서 검색할 수 없습니다. 따라서 0인 값을 제외하고 같음 테스트에는 사용하지 않는 것이 좋습니다.

    다음 예제에서는 후자의 방법을 사용하여 IsApproximatelyEqual 두 값 간의 상대적 차이를 테스트하는 메서드를 정의합니다. 또한 메서드 및 메서드 호출의 IsApproximatelyEqual 결과와 Equals(Single) 대조됩니다.

    using System;
    
    public class Example
    {
       public static void Main()
       {
          float one1 = .1f * 10;
          float one2 = 0f;
          for (int ctr = 1; ctr <= 10; ctr++)
             one2 += .1f;
    
          Console.WriteLine("{0:R} = {1:R}: {2}", one1, one2, one1.Equals(one2));
          Console.WriteLine("{0:R} is approximately equal to {1:R}: {2}", 
                            one1, one2, 
                            IsApproximatelyEqual(one1, one2, .000001f));   
       }
    
       static bool IsApproximatelyEqual(float value1, float value2, float epsilon)
       {
          // If they are equal anyway, just return True.
          if (value1.Equals(value2))
             return true;
    
          // Handle NaN, Infinity.
          if (Double.IsInfinity(value1) | Double.IsNaN(value1))
             return value1.Equals(value2);
          else if (Double.IsInfinity(value2) | Double.IsNaN(value2))
             return value1.Equals(value2);
    
          // Handle zero to avoid division by zero
          double divisor = Math.Max(value1, value2);
          if (divisor.Equals(0)) 
             divisor = Math.Min(value1, value2);
          
          return Math.Abs(value1 - value2)/divisor <= epsilon;           
       } 
    }
    // The example displays the following output:
    //       1 = 1.00000012: False
    //       1 is approximately equal to 1.00000012: True
    
    Module Example
       Public Sub Main()
          Dim one1 As Single = .1 * 10
          Dim one2 As Single = 0
          For ctr As Integer = 1 To 10
             one2 += CSng(.1)
          Next
          Console.WriteLine("{0:R} = {1:R}: {2}", one1, one2, one1.Equals(one2))
          Console.WriteLine("{0:R} is approximately equal to {1:R}: {2}", 
                            one1, one2, 
                            IsApproximatelyEqual(one1, one2, .000001))   
       End Sub
    
       Function IsApproximatelyEqual(value1 As Single, value2 As Single, 
                                     epsilon As Single) As Boolean
          ' If they are equal anyway, just return True.
          If value1.Equals(value2) Then Return True
          
          ' Handle NaN, Infinity.
          If Single.IsInfinity(value1) Or Single.IsNaN(value1) Then
             Return value1.Equals(value2)
          Else If Single.IsInfinity(value2) Or Single.IsNaN(value2)
             Return value1.Equals(value2)
          End If
          
          ' Handle zero to avoid division by zero
          Dim divisor As Single = Math.Max(value1, value2)
          If divisor.Equals(0) Then
             divisor = Math.Min(value1, value2)
          End If 
          
          Return Math.Abs(value1 - value2)/divisor <= epsilon           
       End Function
    End Module
    ' The example displays the following output:
    '       1 = 1.00000012: False
    '       1 is approximately equal to 1.00000012: True
    

부동 소수점 값 및 예외

부동 소수점 값이 있는 연산은 0으로 나누기 또는 오버플로와 같은 잘못된 작업의 경우 예외를 throw하는 계열 형식의 연산과 달리 예외를 throw하지 않습니다. 대신 이러한 상황에서 부동 소수점 연산의 결과는 0, 양의 무한대, 음의 무한대 또는 NaN(숫자가 아닙니다)입니다.

  • 부동 소수점 연산의 결과가 대상 형식에 대해 너무 작으면 결과는 0입니다. 이 문제는 다음 예제와 같이 두 개의 매우 작은 부동 소수점 숫자를 곱할 때 발생할 수 있습니다.

    using System;
    
    public class Example
    {
       public static void Main()
       {
          float value1 = 1.163287e-36f;
          float value2 = 9.164234e-25f;
          float result = value1 * value2;
          Console.WriteLine("{0} * {1} = {2}", value1, value2, result);
          Console.WriteLine("{0} = 0: {1}", result, result.Equals(0.0f));
       }
    }
    // The example displays the following output:
    //       1.163287E-36 * 9.164234E-25 = 0
    //       0 = 0: True
    
    Module Example
       Public Sub Main()
          Dim value1 As Single = 1.163287e-36
          Dim value2 As Single = 9.164234e-25
          Dim result As Single = value1 * value2
          Console.WriteLine("{0} * {1} = {2:R}", value1, value2, result)
          Console.WriteLine("{0} = 0: {1}", result, result.Equals(0))
       End Sub
    End Module
    ' The example displays the following output:
    '       1.163287E-36 * 9.164234E-25 = 0
    '       0 = 0: True
    
  • 부동 소수점 연산 결과의 크기가 대상 형식의 범위를 초과하면 작업의 결과는 PositiveInfinity NegativeInfinity 결과의 부호에 적합한 또는 입니다. 오버플로되는 작업의 결과는 Single.MaxValue PositiveInfinity 이고 오버플로되는 작업의 결과는 Single.MinValue NegativeInfinity 다음 예제와 같이 입니다.

    using System;
    
    public class Example
    {
       public static void Main()
       {
          float value1 = 3.065e35f;
          float value2 = 6.9375e32f;
          float result = value1 * value2;
          Console.WriteLine("PositiveInfinity: {0}", 
                             Single.IsPositiveInfinity(result));
          Console.WriteLine("NegativeInfinity: {0}\n", 
                            Single.IsNegativeInfinity(result));
    
          value1 = -value1;
          result = value1 * value2;
          Console.WriteLine("PositiveInfinity: {0}", 
                             Single.IsPositiveInfinity(result));
          Console.WriteLine("NegativeInfinity: {0}", 
                            Single.IsNegativeInfinity(result));
       }
    }                                                                 
    
    // The example displays the following output:
    //       PositiveInfinity: True
    //       NegativeInfinity: False
    //       
    //       PositiveInfinity: False
    //       NegativeInfinity: True
    
    Module Example
       Public Sub Main()
          Dim value1 As Single = 3.065e35
          Dim value2 As Single = 6.9375e32
          Dim result As Single = value1 * value2
          Console.WriteLine("PositiveInfinity: {0}", 
                             Single.IsPositiveInfinity(result))
          Console.WriteLine("NegativeInfinity: {0}", 
                            Single.IsNegativeInfinity(result))
          Console.WriteLine()                  
          value1 = -value1
          result = value1 * value2
          Console.WriteLine("PositiveInfinity: {0}", 
                             Single.IsPositiveInfinity(result))
          Console.WriteLine("NegativeInfinity: {0}", 
                            Single.IsNegativeInfinity(result))
       End Sub
    End Module
    ' The example displays the following output:
    '       PositiveInfinity: True
    '       NegativeInfinity: False
    '       
    '       PositiveInfinity: False
    '       NegativeInfinity: True
    

    PositiveInfinity 은 양수로 0으로 나누기 NegativeInfinity 때문에 발생하며, 음의 배당을 가진 0으로 나누기 결과도 발생합니다.

  • 부동 소수점 연산이 잘못된 경우 연산의 결과는 NaN 입니다. 예를 들어 NaN 다음 작업의 결과는 다음과 같습니다.

    • 0으로 나눠서 0으로 나눠 집니다. 다른 경우를 0으로 나누면 또는 가 PositiveInfinity NegativeInfinity 발생합니다.

    • 잘못된 입력을 가진 부동 소수점 연산입니다. 예를 들어 음수 값의 제곱근을 찾으려고 시도하면 가 NaN 반환됩니다.

    • 값이 인 인수가 있는 모든 Single.NaN 작업입니다.

형식 변환 및 단일 구조체

Single구조체는 명시적 또는 암시적 변환 연산자를 정의하지 않습니다. 대신 컴파일러에서 변환을 구현합니다.

다음 표에서는 다른 기본 숫자 형식의 값을 값으로 변환할 수 있는 변환을 나열합니다. 변환이 확대 또는 축소되는지 여부와 결과 전체 자릿수가 Single 원래 값보다 적을 수 있는지 여부도 Single 나타냅니다.

B에서 A로의 변환이 확대/축소 정밀도 손실 가능성
Byte Widening 아니요
Decimal Widening

C #에는 캐스트 연산자가 필요 합니다.
예. Decimal 는 10 진수의 전체 자릿수를 지원 합니다. 는 Single 9를 지원 합니다.
Double 축소 범위를 벗어난 값은 또는로 변환 됩니다 Double.NegativeInfinity Double.PositiveInfinity . 예. Double 에서는 17 자리의 전체 자릿수를 지원 합니다. 는 Single 9를 지원 합니다.
Int16 Widening 아니요
Int32 Widening 예. Int32 10 진수 전체 자릿수를 지원 합니다. 는 Single 9를 지원 합니다.
Int64 Widening 예. Int64 는 전체 자릿수의 19 진수를 지원 합니다. 는 Single 9를 지원 합니다.
SByte Widening 아니요
UInt16 Widening 아니요
UInt32 Widening 예. UInt32 10 진수 전체 자릿수를 지원 합니다. 는 Single 9를 지원 합니다.
UInt64 Widening 예. Int64 는 전체 자릿수의 10 진수를 지원 합니다. 는 Single 9를 지원 합니다.

다음 예에서는 다른 기본 숫자 형식의 최소값 또는 최대값을 값으로 변환 합니다 Single .

using System;

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

또한, Double 및 값은 Double.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 다음 표에 나와 있는 것 처럼 동작 합니다.

대상 형식 결과
모든 정수 계열 형식 OverflowException확인 된 컨텍스트에서 변환이 발생 하면 예외가 발생 합니다.

확인 되지 않은 컨텍스트 (c #의 기본값)에서 변환이 발생 하는 경우 변환 작업은 성공 하지만 값은 오버플로 됩니다.
Decimal OverflowException예외,

또한, Single.NaN 및는 Single.PositiveInfinity Single.NegativeInfinity OverflowException 확인 된 컨텍스트에서 정수로 변환 하기 위해를 throw 하지만, 이러한 값은 unchecked 컨텍스트에서 정수로 변환 될 때 오버플로 됩니다. 로 변환 하는 경우 Decimal 항상을 throw OverflowException 합니다. 로의 변환에는 Double Double.NaN 각각, 및로 변환 Double.PositiveInfinity Double.NegativeInfinity 됩니다.

Single값을 다른 숫자 형식으로 변환 하면 전체 자릿수 손실이 발생할 수 있습니다. 정수 값이 아닌 값을 변환 하는 경우 Single 예제의 출력에 표시 된 것 처럼 Single 값이 반올림 (Visual Basic) 하거나 잘린 경우 (c #의 경우) 소수 구성 요소가 손실 됩니다. 값으로 변환 하는 경우 Decimal Single 대상 데이터 형식에 값이 정확 하 게 표시 되지 않을 수 있습니다.

다음 예에서는 여러 Single 값을 다른 숫자 형식으로 변환 합니다. 변환은 Visual Basic (기본값) 및 c # ( checked 키워드로 인해)에서 확인 된 컨텍스트에서 발생 합니다. 예제의 출력에는 확인 되지 않은 컨텍스트를 모두 변환 하는 결과가 나와 있습니다. /removeintchecks+문을 주석으로 처리 하 여 컴파일러 스위치 및 c #으로 컴파일하여 Visual Basic의 unchecked 컨텍스트에서 변환을 수행할 수 있습니다 checked .

using System;

public class Example
{
   public static void Main()
   {
      float[] values = { Single.MinValue, -67890.1234f, -12345.6789f,
                         12345.6789f, 67890.1234f, Single.MaxValue,
                         Single.NaN, Single.PositiveInfinity,
                         Single.NegativeInfinity };
      checked {
         foreach (var value in values) {
            try {
                Int64 lValue = (long) value;
                Console.WriteLine("{0} ({1}) --> {2} (0x{2:X16}) ({3})",
                                  value, value.GetType().Name,
                                  lValue, lValue.GetType().Name);
            }
            catch (OverflowException) {
               Console.WriteLine("Unable to convert {0} to Int64.", value);
            }
            try {
                UInt64 ulValue = (ulong) value;
                Console.WriteLine("{0} ({1}) --> {2} (0x{2:X16}) ({3})",
                                  value, value.GetType().Name,
                                  ulValue, ulValue.GetType().Name);
            }
            catch (OverflowException) {
               Console.WriteLine("Unable to convert {0} to UInt64.", value);
            }
            try {
                Decimal dValue = (decimal) value;
                Console.WriteLine("{0} ({1}) --> {2} ({3})",
                                  value, value.GetType().Name,
                                  dValue, dValue.GetType().Name);
            }
            catch (OverflowException) {
               Console.WriteLine("Unable to convert {0} to Decimal.", value);
            }

            Double dblValue = value;
            Console.WriteLine("{0} ({1}) --> {2} ({3})",
                              value, value.GetType().Name,
                              dblValue, dblValue.GetType().Name);
            Console.WriteLine();
         }
      }
   }
}
// The example displays the following output for conversions performed
// in a checked context:
//       Unable to convert -3.402823E+38 to Int64.
//       Unable to convert -3.402823E+38 to UInt64.
//       Unable to convert -3.402823E+38 to Decimal.
//       -3.402823E+38 (Single) --> -3.40282346638529E+38 (Double)
//
//       -67890.13 (Single) --> -67890 (0xFFFFFFFFFFFEF6CE) (Int64)
//       Unable to convert -67890.13 to UInt64.
//       -67890.13 (Single) --> -67890.12 (Decimal)
//       -67890.13 (Single) --> -67890.125 (Double)
//
//       -12345.68 (Single) --> -12345 (0xFFFFFFFFFFFFCFC7) (Int64)
//       Unable to convert -12345.68 to UInt64.
//       -12345.68 (Single) --> -12345.68 (Decimal)
//       -12345.68 (Single) --> -12345.6787109375 (Double)
//
//       12345.68 (Single) --> 12345 (0x0000000000003039) (Int64)
//       12345.68 (Single) --> 12345 (0x0000000000003039) (UInt64)
//       12345.68 (Single) --> 12345.68 (Decimal)
//       12345.68 (Single) --> 12345.6787109375 (Double)
//
//       67890.13 (Single) --> 67890 (0x0000000000010932) (Int64)
//       67890.13 (Single) --> 67890 (0x0000000000010932) (UInt64)
//       67890.13 (Single) --> 67890.12 (Decimal)
//       67890.13 (Single) --> 67890.125 (Double)
//
//       Unable to convert 3.402823E+38 to Int64.
//       Unable to convert 3.402823E+38 to UInt64.
//       Unable to convert 3.402823E+38 to Decimal.
//       3.402823E+38 (Single) --> 3.40282346638529E+38 (Double)
//
//       Unable to convert NaN to Int64.
//       Unable to convert NaN to UInt64.
//       Unable to convert NaN to Decimal.
//       NaN (Single) --> NaN (Double)
//
//       Unable to convert Infinity to Int64.
//       Unable to convert Infinity to UInt64.
//       Unable to convert Infinity to Decimal.
//       Infinity (Single) --> Infinity (Double)
//
//       Unable to convert -Infinity to Int64.
//       Unable to convert -Infinity to UInt64.
//       Unable to convert -Infinity to Decimal.
//       -Infinity (Single) --> -Infinity (Double)
// The example displays the following output for conversions performed
// in an unchecked context:
//       -3.402823E+38 (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       -3.402823E+38 (Single) --> 9223372036854775808 (0x8000000000000000) (UInt64)
//       Unable to convert -3.402823E+38 to Decimal.
//       -3.402823E+38 (Single) --> -3.40282346638529E+38 (Double)
//
//       -67890.13 (Single) --> -67890 (0xFFFFFFFFFFFEF6CE) (Int64)
//       -67890.13 (Single) --> 18446744073709483726 (0xFFFFFFFFFFFEF6CE) (UInt64)
//       -67890.13 (Single) --> -67890.12 (Decimal)
//       -67890.13 (Single) --> -67890.125 (Double)
//
//       -12345.68 (Single) --> -12345 (0xFFFFFFFFFFFFCFC7) (Int64)
//       -12345.68 (Single) --> 18446744073709539271 (0xFFFFFFFFFFFFCFC7) (UInt64)
//       -12345.68 (Single) --> -12345.68 (Decimal)
//       -12345.68 (Single) --> -12345.6787109375 (Double)
//
//       12345.68 (Single) --> 12345 (0x0000000000003039) (Int64)
//       12345.68 (Single) --> 12345 (0x0000000000003039) (UInt64)
//       12345.68 (Single) --> 12345.68 (Decimal)
//       12345.68 (Single) --> 12345.6787109375 (Double)
//
//       67890.13 (Single) --> 67890 (0x0000000000010932) (Int64)
//       67890.13 (Single) --> 67890 (0x0000000000010932) (UInt64)
//       67890.13 (Single) --> 67890.12 (Decimal)
//       67890.13 (Single) --> 67890.125 (Double)
//
//       3.402823E+38 (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       3.402823E+38 (Single) --> 0 (0x0000000000000000) (UInt64)
//       Unable to convert 3.402823E+38 to Decimal.
//       3.402823E+38 (Single) --> 3.40282346638529E+38 (Double)
//
//       NaN (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       NaN (Single) --> 0 (0x0000000000000000) (UInt64)
//       Unable to convert NaN to Decimal.
//       NaN (Single) --> NaN (Double)
//
//       Infinity (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       Infinity (Single) --> 0 (0x0000000000000000) (UInt64)
//       Unable to convert Infinity to Decimal.
//       Infinity (Single) --> Infinity (Double)
//
//       -Infinity (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       -Infinity (Single) --> 9223372036854775808 (0x8000000000000000) (UInt64)
//       Unable to convert -Infinity to Decimal.
//       -Infinity (Single) --> -Infinity (Double)
Module Example
   Public Sub Main()
      Dim values() As Single = { Single.MinValue, -67890.1234, -12345.6789,
                                 12345.6789, 67890.1234, Single.MaxValue,
                                 Single.NaN, Single.PositiveInfinity,
                                 Single.NegativeInfinity }
      For Each value In values
         Try
             Dim lValue As Long = CLng(value)
             Console.WriteLine("{0} ({1}) --> {2} (0x{2:X16}) ({3})",
                               value, value.GetType().Name,
                               lValue, lValue.GetType().Name)
         Catch e As OverflowException
            Console.WriteLine("Unable to convert {0} to Int64.", value)
         End Try
         Try
             Dim ulValue As UInt64 = CULng(value)
             Console.WriteLine("{0} ({1}) --> {2} (0x{2:X16}) ({3})",
                               value, value.GetType().Name,
                               ulValue, ulValue.GetType().Name)
         Catch e As OverflowException
            Console.WriteLine("Unable to convert {0} to UInt64.", value)
         End Try
         Try
             Dim dValue As Decimal = CDec(value)
             Console.WriteLine("{0} ({1}) --> {2} ({3})",
                               value, value.GetType().Name,
                               dValue, dValue.GetType().Name)
         Catch e As OverflowException
            Console.WriteLine("Unable to convert {0} to Decimal.", value)
         End Try

         Dim dblValue As Double = value
         Console.WriteLine("{0} ({1}) --> {2} ({3})",
                           value, value.GetType().Name,
                           dblValue, dblValue.GetType().Name)
         Console.WriteLine()
      Next
   End Sub
End Module
' The example displays the following output for conversions performed
' in a checked context:
'       Unable to convert -3.402823E+38 to Int64.
'       Unable to convert -3.402823E+38 to UInt64.
'       Unable to convert -3.402823E+38 to Decimal.
'       -3.402823E+38 (Single) --> -3.40282346638529E+38 (Double)
'
'       -67890.13 (Single) --> -67890 (0xFFFFFFFFFFFEF6CE) (Int64)
'       Unable to convert -67890.13 to UInt64.
'       -67890.13 (Single) --> -67890.12 (Decimal)
'       -67890.13 (Single) --> -67890.125 (Double)
'
'       -12345.68 (Single) --> -12346 (0xFFFFFFFFFFFFCFC6) (Int64)
'       Unable to convert -12345.68 to UInt64.
'       -12345.68 (Single) --> -12345.68 (Decimal)
'       -12345.68 (Single) --> -12345.6787109375 (Double)
'
'       12345.68 (Single) --> 12346 (0x000000000000303A) (Int64)
'       12345.68 (Single) --> 12346 (0x000000000000303A) (UInt64)
'       12345.68 (Single) --> 12345.68 (Decimal)
'       12345.68 (Single) --> 12345.6787109375 (Double)
'
'       67890.13 (Single) --> 67890 (0x0000000000010932) (Int64)
'       67890.13 (Single) --> 67890 (0x0000000000010932) (UInt64)
'       67890.13 (Single) --> 67890.12 (Decimal)
'       67890.13 (Single) --> 67890.125 (Double)
'
'       Unable to convert 3.402823E+38 to Int64.
'       Unable to convert 3.402823E+38 to UInt64.
'       Unable to convert 3.402823E+38 to Decimal.
'       3.402823E+38 (Single) --> 3.40282346638529E+38 (Double)
'
'       Unable to convert NaN to Int64.
'       Unable to convert NaN to UInt64.
'       Unable to convert NaN to Decimal.
'       NaN (Single) --> NaN (Double)
'
'       Unable to convert Infinity to Int64.
'       Unable to convert Infinity to UInt64.
'       Unable to convert Infinity to Decimal.
'       Infinity (Single) --> Infinity (Double)
'
'       Unable to convert -Infinity to Int64.
'       Unable to convert -Infinity to UInt64.
'       Unable to convert -Infinity to Decimal.
'       -Infinity (Single) --> -Infinity (Double)
' The example displays the following output for conversions performed
' in an unchecked context:
'       -3.402823E+38 (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
'       -3.402823E+38 (Single) --> 9223372036854775808 (0x8000000000000000) (UInt64)
'       Unable to convert -3.402823E+38 to Decimal.
'       -3.402823E+38 (Single) --> -3.40282346638529E+38 (Double)
'
'       -67890.13 (Single) --> -67890 (0xFFFFFFFFFFFEF6CE) (Int64)
'       -67890.13 (Single) --> 18446744073709483726 (0xFFFFFFFFFFFEF6CE) (UInt64)
'       -67890.13 (Single) --> -67890.12 (Decimal)
'       -67890.13 (Single) --> -67890.125 (Double)
'
'       -12345.68 (Single) --> -12346 (0xFFFFFFFFFFFFCFC6) (Int64)
'       -12345.68 (Single) --> 18446744073709539270 (0xFFFFFFFFFFFFCFC6) (UInt64)
'       -12345.68 (Single) --> -12345.68 (Decimal)
'       -12345.68 (Single) --> -12345.6787109375 (Double)
'
'       12345.68 (Single) --> 12346 (0x000000000000303A) (Int64)
'       12345.68 (Single) --> 12346 (0x000000000000303A) (UInt64)
'       12345.68 (Single) --> 12345.68 (Decimal)
'       12345.68 (Single) --> 12345.6787109375 (Double)
'
'       67890.13 (Single) --> 67890 (0x0000000000010932) (Int64)
'       67890.13 (Single) --> 67890 (0x0000000000010932) (UInt64)
'       67890.13 (Single) --> 67890.12 (Decimal)
'       67890.13 (Single) --> 67890.125 (Double)
'
'       3.402823E+38 (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
'       3.402823E+38 (Single) --> 0 (0x0000000000000000) (UInt64)
'       Unable to convert 3.402823E+38 to Decimal.
'       3.402823E+38 (Single) --> 3.40282346638529E+38 (Double)
'
'       NaN (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
'       NaN (Single) --> 0 (0x0000000000000000) (UInt64)
'       Unable to convert NaN to Decimal.
'       NaN (Single) --> NaN (Double)
'
'       Infinity (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
'       Infinity (Single) --> 0 (0x0000000000000000) (UInt64)
'       Unable to convert Infinity to Decimal.
'       Infinity (Single) --> Infinity (Double)
'
'       -Infinity (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
'       -Infinity (Single) --> 9223372036854775808 (0x8000000000000000) (UInt64)
'       Unable to convert -Infinity to Decimal.
'       -Infinity (Single) --> -Infinity (Double)

숫자 형식의 변환에 대 한 자세한 내용은 .NET Framework의 형식 변환형식 변환 표를 참조 하세요.

부동 소수점 기능

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.SignMath.Sqrt ), 기 하 도형 (예: Math.CosMath.Sin ), 미적분학 (예:) Math.Log 에 일반적으로 사용 되는 추가 메서드가 포함 됩니다. 모든 경우에 Single 값이로 변환 됩니다 Double .

    값에서 개별 비트를 조작할 수도 있습니다 Single . BitConverter.GetBytes(Single)메서드는 바이트 배열에서 비트 패턴을 반환 합니다. 바이트 배열을 메서드에 전달 하 여 BitConverter.ToInt32 Single 값의 비트 패턴을 32 비트 정수로 유지할 수도 있습니다.

  • 반올림. 반올림은 부동 소수점 표현 및 정밀도 문제로 인해 발생 하는 값 간의 차이를 줄이기 위한 기술로 사용 되는 경우가 많습니다. Single메서드를 호출 하 여 값을 반올림할 수 있습니다 Math.Round . 그러나 Single 메서드를 호출 하기 전에 값이로 변환 되 Double 고 변환의 정밀도가 떨어질 수 있습니다.

  • 서식 지정. Single메서드를 호출 ToString 하거나 복합 서식 지정 기능을 사용 하 여 값을 문자열 표현으로 변환할 수 있습니다. 형식 문자열이 부동 소수점 값의 문자열 표현을 제어 하는 방법에 대 한 자세한 내용은 표준 숫자 형식 문자열사용자 지정 숫자 형식 문자열 항목을 참조 하세요.

  • 문자열을 구문 분석 합니다. Single또는 메서드를 호출 하 여 부동 소수점 값의 문자열 표현을 값으로 변환할 수 있습니다 Parse TryParse . 구문 분석 작업이 실패 하면 메서드는 Parse 예외를 throw 하지만 메서드는를 TryParse 반환 합니다 false .

  • 형식 변환 입니다. Single구조체는 IConvertible 두 표준 .NET Framework 데이터 형식 간의 변환을 지 원하는 인터페이스에 대 한 명시적 인터페이스 구현을 제공 합니다. 언어 컴파일러는를 값으로 변환 하는 경우를 제외 하 고 다른 모든 표준 숫자 형식에 대 한 값의 암시적 변환도 지원 합니다 Double Single . 이외의 표준 숫자 형식 값을으로 변환 Double 하는 Single 것은 확대 변환 이며 캐스팅 연산자 또는 변환 메서드를 사용 하지 않아도 됩니다.

    그러나 32 비트 및 64 비트 정수 값의 변환은 전체 자릿수가 손실 될 수 있습니다. 다음 표에서는 32 비트, 64 비트 및 형식에 대 한 전체 자릿수 차이를 보여 줍니다 Double .

    형식 최대 전체 자릿수 (10 진수) 내부 전체 자릿수 (10 진수)
    Double 15 17
    Int32UInt32 10 10
    Int64UInt64 19 19
    Single 7 9

    정밀도 문제는 값으로 변환되는 값에 가장 자주 영향을 Single Double 줍니다. 다음 예제에서는 값 중 하나가 로 변환되는 단정밀도 부동 소수점 값이므로 동일한 나누기 연산에서 생성된 두 값이 같지 Double 않습니다.

    using System;
    
    public class Example
    {
       public static void Main()
       {
          Double value1 = 1/3.0;
          Single sValue2 = 1/3.0f;
          Double value2 = (Double) sValue2;
          Console.WriteLine("{0:R} = {1:R}: {2}", value1, value2, 
                                              value1.Equals(value2));
       }
    }
    // The example displays the following output:
    //        0.33333333333333331 = 0.3333333432674408: False
    
    Module Example
       Public Sub Main()
          Dim value1 As Double = 1/3
          Dim sValue2 As Single = 1/3
          Dim value2 As Double = CDbl(sValue2)
          Console.WriteLine("{0} = {1}: {2}", value1, value2, value1.Equals(value2))
       End Sub
    End Module
    ' The example displays the following output:
    '       0.33333333333333331 = 0.3333333432674408: False
    

필드

Epsilon

0보다 큰 양의 최소 Single 값을 나타냅니다. 이 필드는 상수입니다.

MaxValue

Single의 가능한 최대값을 나타냅니다. 이 필드는 상수입니다.

MinValue

Single의 가능한 최소값을 나타냅니다. 이 필드는 상수입니다.

NaN

Not-a-Number(NaN)를 나타냅니다. 이 필드는 상수입니다.

NegativeInfinity

음의 무한대를 나타냅니다. 이 필드는 상수입니다.

PositiveInfinity

양의 무한대를 나타냅니다. 이 필드는 상수입니다.

메서드

CompareTo(Object)

이 인스턴스를 지정된 개체와 비교하고 이 인스턴스의 값이 지정된 개체의 값보다 작은지, 같은지 또는 큰지를 나타내는 정수를 반환합니다.

CompareTo(Single)

이 인스턴스를 지정된 단정밀도 부동 소수점 숫자와 비교하고 이 인스턴스의 값이 지정된 단정밀도 부동 소수점 숫자 값보다 작은지, 같은지 또는 큰지를 나타내는 정수를 반환합니다.

Equals(Object)

이 인스턴스가 지정된 개체와 같은지를 표시하는 값을 반환합니다.

Equals(Single)

이 인스턴스의 값과 지정된 Single 개체의 값이 같은지를 나타내는 값을 반환합니다.

GetHashCode()

이 인스턴스의 해시 코드를 반환합니다.

GetTypeCode()

TypeCode 값 형식에 대한 Single를 반환합니다.

IsFinite(Single)

지정된 값이 유한(0, 비정상 또는 정상)한지 확인합니다.

IsInfinity(Single)

지정된 숫자가 음의 무한대로 계산되는지 양의 무한대로 계산되는지를 나타내는 값을 반환합니다.

IsNaN(Single)

지정된 값이 숫자가 아닌지(NaN) 여부를 나타내는 값을 반환합니다.

IsNegative(Single)

지정된 값이 음수인지 확인합니다.

IsNegativeInfinity(Single)

지정된 숫자가 음의 무한대로 계산되는지를 나타내는 값을 반환합니다.

IsNormal(Single)

지정된 값이 정상인지 확인합니다.

IsPositiveInfinity(Single)

지정된 숫자가 양의 무한대로 계산되는지를 나타내는 값을 반환합니다.

IsSubnormal(Single)

지정된 값이 비정상인지 확인합니다.

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

지정된 스타일 및 문화권별 형식으로 된 숫자의 문자열 표현을포함하는 문자 범위를 해당하는 단정밀도 부동 소수점 숫자로 변환합니다.

Parse(String)

숫자의 문자열 표현을 해당하는 단정밀도 부동 소수점 숫자로 변환합니다.

Parse(String, IFormatProvider)

지정된 문화권별 형식의 숫자에 대한 문자열 표현을 해당하는 단정밀도 부동 소수점 숫자로 변환합니다.

Parse(String, NumberStyles)

지정된 스타일로 된 숫자의 문자열 표현을 해당하는 단정밀도 부동 소수점 숫자로 변환합니다.

Parse(String, NumberStyles, IFormatProvider)

지정된 스타일 및 문화권별 형식으로 된 숫자의 문자열 표현을 해당하는 단정밀도 부동 소수점 숫자로 변환합니다.

ToString()

이 인스턴스의 숫자 값을 해당하는 문자열 표현으로 변환합니다.

ToString(IFormatProvider)

지정된 문화권별 형식 정보를 사용하여 이 인스턴스의 숫자 값을 해당 문자열 표현으로 변환합니다.

ToString(String)

지정된 형식을 사용하여 이 인스턴스의 숫자 값을 해당 문자열 표현으로 변환합니다.

ToString(String, IFormatProvider)

지정된 형식 및 문화권별 형식 정보를 사용하여 이 인스턴스의 숫자 값을 해당 문자열 표현으로 변환합니다.

TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)

현재의 부동 숫자 인스턴스 값을 제공된 문자 범위의 형식으로 지정하도록 시도합니다.

TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Single)

지정된 스타일 및 문화권별 형식으로 된 숫자의 범위 표현을 해당하는 단정밀도 부동 소수점 숫자로 변환합니다. 반환 값은 변환이 성공했는지 아니면 실패했는지를 나타냅니다.

TryParse(ReadOnlySpan<Char>, 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 값보다 작거나 같은지 여부를 나타내는 값을 반환합니다.

명시적 인터페이스 구현

IComparable.CompareTo(Object)

현재 인스턴스와 동일한 형식의 다른 개체를 비교하고 정렬 순서에서 현재 인스턴스의 위치가 다른 개체보다 앞인지, 뒤인지 또는 동일한지를 나타내는 정수를 반환합니다.

IConvertible.GetTypeCode()

이 인스턴스에 대한 TypeCode를 반환합니다.

IConvertible.ToBoolean(IFormatProvider)

이 멤버에 대한 설명은 ToBoolean(IFormatProvider)를 참조하세요.

IConvertible.ToByte(IFormatProvider)

이 멤버에 대한 설명은 ToByte(IFormatProvider)를 참조하세요.

IConvertible.ToChar(IFormatProvider)

이 변환은 지원되지 않습니다. 이 메서드를 사용하려고 하면 InvalidCastException이 throw됩니다.

IConvertible.ToDateTime(IFormatProvider)

이 변환은 지원되지 않습니다. 이 메서드를 사용하려고 하면 InvalidCastException이 throw됩니다.

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)를 참조하세요.

적용 대상

스레드 보안

이 형식의 모든 멤버는 스레드 안전 합니다. 인스턴스 상태를 수정하는 것처럼 보이는 멤버는 실제로 새 값으로 초기화된 새 인스턴스를 반환합니다. 다른 형식과 마찬가지로 이 형식의 인스턴스를 포함하는 공유 변수에 대한 읽기 및 쓰기는 스레드 안전을 보장하기 위해 잠금으로 보호되어야 합니다.

추가 정보