Double.Epsilon Double.Epsilon Double.Epsilon Double.Epsilon Field

정의

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

public: double Epsilon = 4.94065645841247E-324;
public const double Epsilon = 4.94065645841247E-324;
val mutable Epsilon : double
Public Const Epsilon As Double  = 4.94065645841247E-324

필드 값

설명

Epsilon 속성의 값은 Double 인스턴스의 값이 0 일 Double 때 숫자 연산 또는 비교에서 중요 한 가장 작은 양의 값을 반영 합니다.The value of the Epsilon property reflects the smallest positive Double value that is significant in numeric operations or comparisons when the value of the Double instance is zero. 예를 들어 다음 코드에서는 0과 Epsilon 이 동일 하지 않은 것으로 간주 되는 반면 Epsilon 값이 0과 절반이 같다고 간주 되는 경우를 보여 줍니다.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()
   {
      double[] values = { 0, Double.Epsilon, Double.Epsilon * .5 };
      
      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 = 4.94065645841247E-324: False
//       0 = 0: True
//       
//       4.94065645841247E-324 = 0: False
Module Example
   Public Sub Main()
      Dim values() As Double = { 0, Double.Epsilon, Double.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 = 4.94065645841247E-324: False
'       0 = 0: True
'       
'       4.94065645841247E-324 = 0: False

보다 정확 하 게, 부동 소수점 형식은 부호, 52 비트가 수 또는 significand 및 11 비트 지 수로 구성 됩니다.More precisely, the floating point format consists of a sign, a 52-bit mantissa or significand, and an 11-bit exponent. 다음 예제에서 볼 수 있듯이 0의 지 수는-1022이 고가 수는 0입니다.As the following example shows, zero has an exponent of -1022 and a mantissa of 0. Epsilon 의 지 수는-1022이 고가 수는 1입니다.Epsilon has an exponent of -1022 and a mantissa of 1. 즉,가 Epsilon 0 보다 큰 가장 Double 작은 양수 값이 고, 해당 지수가-1022 인에 대해 Double 가능한 최소값 및 가장 작은 증가값을 나타냅니다.This means that Epsilon is the smallest positive Double value greater than zero and represents the smallest possible value and the smallest possible increment for a Double whose exponent is -1022.

using System;

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

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

      // Convert the double to an 8-byte array.
      byte[] bytes = BitConverter.GetBytes(value);
      // Get the sign bit (byte 7, bit 7).
      result += String.Format("Sign: {0}\n", 
                              (bytes[7] & 0x80) == 0x80 ? "1 (-)" : "0 (+)");

      // Get the exponent (byte 6 bits 4-7 to byte 7, bits 0-6)
      int exponent = (bytes[7] & 0x07F) << 4;
      exponent = exponent | ((bytes[6] & 0xF0) >> 4);  
      int adjustment = exponent != 0 ? 1023 : 1022;
      result += String.Format("{0}Exponent: 0x{1:X4} ({1})\n", new String(' ', indent), exponent - adjustment);

      // Get the significand (bits 0-51)
      long significand = ((bytes[6] & 0x0F) << 48); 
      significand = significand | ((long) bytes[5] << 40);
      significand = significand | ((long) bytes[4] << 32);
      significand = significand | ((long) bytes[3] << 24);
      significand = significand | ((long) bytes[2] << 16);
      significand = significand | ((long) bytes[1] << 8);
      significand = significand | bytes[0];    
      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: 0xFFFFFC02 (-1022)
//          Mantissa: 0x0000000000000
//       
//       
//       4.94065645841247E-324: Sign: 0 (+)
//                              Exponent: 0xFFFFFC02 (-1022)
//                              Mantissa: 0x0000000000001
Module Example
   Public Sub Main()
      Dim values() As Double = { 0.0, Double.Epsilon }
      For Each value In values
         Console.WriteLine(GetComponentParts(value))
         Console.WriteLine()
      Next   
   End Sub

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

      ' Convert the double to an 8-byte array.
      Dim bytes() As Byte = BitConverter.GetBytes(value)
      ' Get the sign bit (byte 7, bit 7).
      result += String.Format("Sign: {0}{1}", 
                              If((bytes(7) And &H80) = &H80, "1 (-)", "0 (+)"),
                              vbCrLf)

      ' Get the exponent (byte 6 bits 4-7 to byte 7, bits 0-6)
      Dim exponent As Integer =  (bytes(7) And &H07F) << 4
      exponent = exponent Or ((bytes(6) And &HF0) >> 4)  
      Dim adjustment As Integer = If(exponent <> 0, 1023, 1022)
      result += String.Format("{0}Exponent: 0x{1:X4} ({1}){2}", 
                              New String(" "c, indent), exponent - adjustment,
                              vbCrLf)

      ' Get the significand (bits 0-51)
      Dim significand As Long =  ((bytes(6) And &H0F) << 48) 
      significand = significand Or (bytes(5) << 40)
      significand = significand Or (bytes(4) << 32)
      significand = significand Or (bytes(3) << 24)
      significand = significand Or (bytes(2) << 16)
      significand = significand Or (bytes(1) << 8)
      significand = significand Or bytes(0)    
      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: 0xFFFFFC02 (-1022)
'          Mantissa: 0x0000000000000
'       
'       
'       4.94065645841247E-324: Sign: 0 (+)
'                              Exponent: 0xFFFFFC02 (-1022)
'                              Mantissa: 0x0000000000001

그러나 속성은 Epsilon Double 형식의 전체 자릿수에 대 한 일반적인 측정값이 아닙니다 Double .이 속성은 값이 0 이거나 지수가-1022 인 인스턴스에서만 적용 됩니다.However, the Epsilon property is not a general measure of precision of the Double type; it applies only to Double instances that have a value of zero or an exponent of -1022.

참고

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.

이 상수의 값은 4.94065645841247 e-324입니다.The value of this constant is 4.94065645841247e-324.

매우 중요 한 숫자의 차이 때문에 동일한 두 부동 소수점 숫자가 같지 않을 수 있습니다.Two apparently equivalent floating-point numbers might not compare equal because of differences in their least significant digits. 예를 들어, C# 식은 (double)1/3 == (double)0.33333왼쪽에 있는 나누기 연산에 최대 전체 자릿수가 있지만 오른쪽의 상수는 지정 된 숫자에만 정확 하 게 일치 하기 때문에 동일한 비교를 수행 하지 않습니다.For example, the C# expression, (double)1/3 == (double)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, we do not recommend that you base your algorithm on the value of the Epsilon constant to establish the acceptable absolute margin of difference for the two values to be considered equal. 일반적으로 차이의 각 여백은 보다 Epsilon많은 시간입니다. 두 개의 배정밀도 부동 소수점 값을 비교 하는 방법에 대 DoubleEquals(Double)자세한 내용은 및을 참조 하십시오.(Typically, that margin of difference is many times greater than Epsilon.) For information about comparing two double-precision floating-point values, see Double and Equals(Double).

플랫폼 참고 사항: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. 대신 2.2250738585072014 E-308과 같은 대체 엡실론 값을 정의할 수 있습니다.You can define an alternative epsilon value that equals 2.2250738585072014E-308 instead.

적용 대상