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

定义

表示大于零的最小正 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 是大于零的最小正 @no__t 值,它表示指数为-1022 的 @no__t 的最小可能值和可能的最小增量。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 的 @no__t 2 实例。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.

备注

@No__t-0 属性的值不等效于计算机 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.

适用于