Double.Epsilon Feld

Definition

Stellt den kleinsten positiven Double-Wert dar, der größer als 0 (null) ist. Dieses Feld ist konstant.

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

Feldwert

Double

Hinweise

Der Wert der -Eigenschaft spiegelt den kleinsten positiven Wert wider, der bei numerischen Vorgängen oder Vergleichen von Bedeutung ist, wenn der Wert der Instanz Epsilon Double Double 0 (null) ist. Der folgende Code zeigt beispielsweise, dass 0 und als ungleiche Werte betrachtet werden, während 0 und die Hälfte des Werts von als Epsilon Epsilon gleich betrachtet werden.

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

Genauer gesagt besteht das Gleitkommaformat aus einem Vorzeichen, einer 52-Bit-Mantisse oder Mantisse und einem 11-Bit-Exponenten. Wie das folgende Beispiel zeigt, weist 0 (null) einen Exponenten von -1022 und eine Mantisse von 0 auf. Epsilon hat einen Exponenten von -1022 und eine Mantisse von 1. Dies bedeutet, dass der kleinste positive Wert größer als 0 (null) ist und den kleinsten möglichen Wert und das kleinste mögliche Inkrement für einen darstellt, dessen Epsilon Double Double Exponent -1022 ist.

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

Die -Eigenschaft ist jedoch kein allgemeines Maß für die Genauigkeit des Typs. Sie gilt nur für Instanzen mit einem Wert von 0 oder einem Epsilon Double Double Exponenten von -1022.

Hinweis

Der Wert der -Eigenschaft entspricht nicht dem Computer epsilon, der die Obergrenze des relativen Fehlers darstellt, der aufgrund einer Rundung in der Epsilon Gleitkommaarithmetik auftritt.

Der Wert dieser Konstante ist 4,94065645841247e-324.

Zwei scheinbar äquivalente Gleitkommazahlen sind aufgrund von Unterschieden in ihren am wenigsten signifikanten Ziffern möglicherweise nicht gleich. Der C#-Ausdruck , , vergleicht z. B. nicht gleich, da der Divisionsvorgang auf der linken Seite die maximale Genauigkeit hat, während die Konstante auf der rechten Seite nur auf die angegebenen (double)1/3 == (double)0.33333 Ziffern genau ist. Wenn Sie einen benutzerdefinierten Algorithmus erstellen, der bestimmt, ob zwei Gleitkommazahlen als gleich betrachtet werden können, empfiehlt es sich nicht, den Algorithmus auf dem Wert der Konstante zu erstellen, um die akzeptable absolute Differenzspanne für die beiden Werte als gleich zu Epsilon bestimmen. (In der Regel ist dieser Unterschiedsrand um ein Vielfaches größer als Epsilon .) Informationen zum Vergleichen von zwei Gleitkommawerten mit doppelter Genauigkeit finden Sie unter Double und Equals(Double) .

Hinweise zur Plattform

Auf ARM-Systemen ist der Wert der Konstante zu klein, um erkannt zu Epsilon werden, sodass er null entspricht. Sie können stattdessen einen alternativen epsilon-Wert definieren, der 2,2250738585072014E-308 entspricht.

Gilt für