Single.Epsilon 필드

정의

0보다 큰 양의 최소 Single 값을 나타냅니다.Represents the smallest positive Single value that is greater than zero. 이 필드는 상수입니다.This field is constant.

public: float Epsilon = 1.401298E-45;
public const float Epsilon = 1.401298E-45;
val mutable Epsilon : single
Public Const Epsilon As Single  = 1.401298E-45

필드 값

설명

값을 Epsilon 속성은 가장 작은 양수를 반영 Single 수치 연산 또는 비교에서 중요 한 값 때 값을 Single 인스턴스가 0.The value of the Epsilon property reflects the smallest positive Single value that is significant in numeric operations or comparisons when the value of the Single instance is zero. 예를 들어, 다음 코드와 0 및 Epsilon 반면 같지 않은 값으로 간주 됩니다 및 절반 값 Epsilon 것으로 간주 됩니다.For example, the following code shows that zero and Epsilon are considered to be unequal values, whereas zero and half the value of Epsilon are considered to be equal.

using System;

public class Example
{
   public static void Main()
   {
      float[] values = { 0f, Single.Epsilon, Single.Epsilon * .5f };
      
      for (int ctr = 0; ctr <= values.Length - 2; ctr++)
      {
         for (int ctr2 = ctr + 1; ctr2 <= values.Length - 1; ctr2++)
         {
            Console.WriteLine("{0:r} = {1:r}: {2}", 
                              values[ctr], values[ctr2],  
                              values[ctr].Equals(values[ctr2]));
         }
         Console.WriteLine();
      }      
   }
}
// The example displays the following output:
//       0 = 1.401298E-45: False
//       0 = 0: True
//       
//       1.401298E-45 = 0: False
Module Example
   Public Sub Main()
      Dim values() As Single = { 0, Single.Epsilon, Single.Epsilon * .5 }
      
      For ctr As Integer = 0 To values.Length - 2
         For ctr2 As Integer = ctr + 1 To values.Length - 1
            Console.WriteLine("{0:r} = {1:r}: {2}", _
                              values(ctr), values(ctr2), _ 
                              values(ctr).Equals(values(ctr2)))
         Next
         Console.WriteLine()
      Next      
   End Sub
End Module
' The example displays the following output:
'       0 = 1.401298E-45: False
'       0 = 0: True
'       
'       1.401298E-45 = 0: False

보다 정확 하 게 단 정밀도 부동 소수점 형식 기호를가 수 23 비트 significand, 및 8 비트 지 수 구성 됩니다.More precisely, the single-precision floating-point format consists of a sign, a 23-bit mantissa or significand, and an 8-bit exponent. 다음 예제와 같이 0에-126의 지 수 및 0의가 수 있습니다.As the following example shows, zero has an exponent of -126 and a mantissa of 0. Epsilon -126의 지 수에 1의가 수 있습니다.Epsilon has an exponent of -126 and a mantissa of 1. 따라서 Single.Epsilon 는 가장 작은 양수 Single 값의 최소값을 나타내고 가능한 가장 작은 증가값으로 0 보다 큰를 Single 인 지 수는-126 합니다.This means that Single.Epsilon is the smallest positive Single value that is greater than zero and represents the smallest possible value and the smallest possible increment for a Single whose exponent is -126.

using System;

public class Example
{
   public static void Main()
   {
      float[] values = { 0.0f, Single.Epsilon };
      foreach (var value in values) {
         Console.WriteLine(GetComponentParts(value));
         Console.WriteLine();
      }   
   }

   private static string GetComponentParts(float value)
   {
      string result = String.Format("{0:R}: ", value);
      int indent = result.Length;

      // Convert the single to a 4-byte array.
      byte[] bytes = BitConverter.GetBytes(value);
      int formattedSingle = BitConverter.ToInt32(bytes, 0);
      
      // Get the sign bit (byte 3, bit 7).
      result += String.Format("Sign: {0}\n", 
                              (formattedSingle >> 31) != 0 ? "1 (-)" : "0 (+)");

      // Get the exponent (byte 2 bit 7 to byte 3, bits 6)
      int exponent =  (formattedSingle >> 23) & 0x000000FF;
      int adjustment = (exponent != 0) ? 127 : 126;
      result += String.Format("{0}Exponent: 0x{1:X4} ({1})\n", new String(' ', indent), exponent - adjustment);

      // Get the significand (bits 0-22)
      long significand = exponent != 0 ? 
                         ((formattedSingle & 0x007FFFFF) | 0x800000) : 
                         (formattedSingle & 0x007FFFFF); 
      result += String.Format("{0}Mantissa: 0x{1:X13}\n", new String(' ', indent), significand);    
      return result;   
   }
}
//       // The example displays the following output:
//       0: Sign: 0 (+)
//          Exponent: 0xFFFFFF82 (-126)
//          Mantissa: 0x0000000000000
//       
//       
//       1.401298E-45: Sign: 0 (+)
//                     Exponent: 0xFFFFFF82 (-126)
//                     Mantissa: 0x0000000000001
Module Example
   Public Sub Main()
      Dim values() As Single = { 0.0, Single.Epsilon }
      For Each value In values
         Console.WriteLine(GetComponentParts(value))
         Console.WriteLine()
      Next   
   End Sub

   Private Function GetComponentParts(value As Single) As String
      Dim result As String =  String.Format("{0:R}: ", value)
      Dim indent As Integer =  result.Length

      ' Convert the single to an 8-byte array.
      Dim bytes() As Byte = BitConverter.GetBytes(value)
      Dim formattedSingle As Integer = BitConverter.ToInt32(bytes, 0)

      ' Get the sign bit (byte 3, bit 7).
      result += String.Format("Sign: {0}{1}", 
                              If(formattedSingle >> 31 <> 0, "1 (-)", "0 (+)"),
                              vbCrLf)

      ' Get the exponent (byte 2 bit 7 to byte 3, bits 6)
      Dim exponent As Integer =  (formattedSingle >> 23) And &h000000FF
      Dim adjustment As Integer = If(exponent <> 0, 127, 126)
      result += String.Format("{0}Exponent: 0x{1:X4} ({1}){2}", 
                              New String(" "c, indent), exponent - adjustment,
                              vbCrLf)

      ' Get the significand (bits 0-22)
      Dim significand As Long =  If(exponent <> 0, 
                         (formattedSingle And &h007FFFFF) Or &h800000, 
                         formattedSingle And &h007FFFFF) 
      result += String.Format("{0}Mantissa: 0x{1:X13}{2}", 
                              New String(" "c, indent), significand, vbCrLf)    

      Return result   
   End Function
End Module
' The example displays the following output:
'       0: Sign: 0 (+)
'          Exponent: 0xFFFFFF82 (-126)
'          Mantissa: 0x0000000000000
'       
'       
'       1.401298E-45: Sign: 0 (+)
'                     Exponent: 0xFFFFFF82 (-126)
'                     Mantissa: 0x0000000000001

그러나 합니다 Epsilon 속성의 전체 자릿수의 일반 측정값이 아닌 합니다 Single 형식에 적용 됩니다 Single 0의 값이 있는 인스턴스.However, the Epsilon property is not a general measure of precision of the Single type; it applies only to Single instances that have a value of zero.

참고

값을 Epsilon 속성 부동 소수점 산술 연산에서 반올림으로 인해 상대 오차의 상한을 나타내는 컴퓨터 엡실론 동일 하지 않습니다.The value of the Epsilon property is not equivalent to machine epsilon, which represents the upper bound of the relative error due to rounding in floating-point arithmetic.

이 상수의 값은 1.4 e-45.The value of this constant is 1.4e-45.

두 명백히 같은 부동 소수점 숫자 수 비교 하 여 같지 최소 유효 자릿수가에 차이가 있기 때문입니다.Two apparently equivalent floating-point numbers might not compare equal because of differences in their least significant digits. 예를 들어 C# 식 (float)1/3 == (float)0.33333를 비교 하지는 않습니다 동일한 나누기 연산의 왼쪽에서 오른쪽에 있는 상수는 지정 된 자릿수로 정확 하 게 하는 동안 최대 전체 자릿수에 있으므로.For example, the C# expression, (float)1/3 == (float)0.33333, does not compare equal because the division operation on the left side has maximum precision while the constant on the right side is precise only to the specified digits. 보다 큰 값을 사용 해야 하는지 여부를 두 부동 소수점 숫자가 취급 될 수 있습니다를 결정 하는 사용자 지정 알고리즘을 만드는 경우는 Epsilon 소수점 되도록 두 값에 대 한 차분 차수를 설정 하는 상수 같은 것으로 간주 합니다.If you create a custom algorithm that determines whether two floating-point numbers can be considered equal, you must use a value that is greater than the Epsilon constant to establish the acceptable absolute margin of difference for the two values to be considered equal. (일반적으로 차이의 여백이 보다 많이 Epsilon.)(Typically, that margin of difference is many times greater than Epsilon.)

플랫폼 참고 사항Platform Notes

ARM 시스템에서는 값을 Epsilon 상수 감지 너무 작아서 이므로 0과 같습니다.On ARM systems, the value of the Epsilon constant is too small to be detected, so it equates to zero. 1.175494351E equals는 대체 엡실론 값을 정의할 수 있습니다-38 대신 합니다.You can define an alternative epsilon value that equals 1.175494351E-38 instead.

적용 대상