Double.Epsilon 欄位

定義

代表大於零的最小正 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

欄位值

備註

Double 實例的值為零時,Epsilon 屬性的值會反映數值作業或比較中很重要的最小正 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. 例如,下列程式碼顯示零和 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()
   {
      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位尾數或有效位數,以及11位指數所組成。More precisely, the floating point format consists of a sign, a 52-bit mantissa or significand, and an 11-bit exponent. 如下列範例所示,零的指數為-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 是大於零的最小正 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 類型之有效位數的一般量值;它只適用于值為零或指數為-1022 的 Double 實例。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 屬性的值不等於機器的 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 常數的值太小,無法偵測到,所以等於零。On ARM systems, the value of the Epsilon constant is too small to be detected, so it equates to zero. 您可以改為定義等於 2.2250738585072014 E-308 的替代 epsilon 值。You can define an alternative epsilon value that equals 2.2250738585072014E-308 instead.

適用於