Single.Epsilon Single.Epsilon Single.Epsilon Single.Epsilon Field

定义

表示大于零的最小正 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实例是零。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. 例如,以下代码所示的零和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 位尾数或有效位数和一个 8 位指数。More precisely, the single-precision floating-point format consists of a sign, a 23-bit mantissa or significand, and an 8-bit exponent. 如下面的示例所示,零具有-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值,该值大于零并表示可能的最小值和可能的最小增量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具有零值的实例。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属性并不等同于机 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常量是太小,无法检测到,因此它相当于零。On ARM systems, the value of the Epsilon constant is too small to be detected, so it equates to zero. 可以定义一个备用 epsilon 值,等于 1.175494351E-38 相反。You can define an alternative epsilon value that equals 1.175494351E-38 instead.

适用于