¿Le resultó útil esta página?
Sus comentarios sobre este contenido son muy importantes. Háganos saber su opinión.
¿Tiene comentarios adicionales?
Caracteres restantes: 1500
Exportar (0) Imprimir
Expandir todo
Este artículo proviene de un motor de traducción automática. Mueva el puntero sobre las frases del artículo para ver el texto original. Más información.
Traducción
Original

Double.Epsilon (Campo)

Representa el menor valor Double positivo mayor que cero. Este campo es constante.

Espacio de nombres:  System
Ensamblado:  mscorlib (en mscorlib.dll)

public const double Epsilon

El valor de la propiedad Epsilon refleja el menor valor positivo de Double que es importante en operaciones numéricas o comparaciones cuando el valor de la instancia de Double es cero. Por ejemplo, en el siguientes código se muestra que cero y Epsilon se consideran valores desiguales, mientras que cero y la mitad del valor de Epsilon se consideran iguales.


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


Más concretamente, el formato de punto flotante consta de un signo, una mantisa o significand de 52 bits, y un exponente de 11 bits. Como se muestra en el ejemplo siguiente, cero tiene un exponente de -1022 y la mantisa de 0. Epsilon tiene un exponente de -1022 y la mantisa de 1. Esto significa que Epsilon es el mayor que cero de valor positivo menor de Double y representa el valor posible menor y el incremento posible más pequeño para Double cuyo exponente es -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


Sin embargo, la propiedad de Epsilon no es una medida general de precisión del tipo de Double ; sólo se aplica a las instancias de Double que tienen un valor de cero o un exponente de -1022.

NotaNota

El valor de la propiedad Epsilon no es equivalente al épsilon del equipo, que representa el límite superior del error relativo debido al redondeo en aritmética de punto flotante.

El valor de esta constante es 4.94065645841247e-324.

Dos números de punto flotante aparentemente iguales no resultarán equivalentes al compararse debido a las diferencias en sus últimos dígitos significativos. Por ejemplo, la expresión de C# (double)1/3 == (double)0.33333 no es equivalente al compararse porque la operación de división del lado izquierdo tiene precisión máxima, mientras que la constante del lado derecho sólo es precisa en los dígitos especificados. Si crea un algoritmo personalizado que determina si dos números de punto flotante pueden considerarse iguales, no se recomienda basado en el algoritmo en el valor constante de Epsilon para establecer el margen aceptable absoluto de la diferencia por los dos valores que se considerarán iguales. (Normalmente, ese margen de diferencia es muchas veces mayor que Epsilon.) Para obtener información sobre cómo comparar dos valores de punto flotante de precisión doble, vea Double y Equals(Double).

Notas sobre la plataforma

En los sistemas de armas, el valor constante de Epsilon es demasiado pequeño para ser detectado, lo que equivale a cero. Puede definir un valor epsilon alternativo que iguale 2.2250738585072014E-308 en su lugar.

.NET Framework

Compatible con: 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Compatible con: 4, 3.5 SP1

Biblioteca de clases portable

Compatible con: Biblioteca de clases portable

.NET para aplicaciones de la Tienda Windows

Compatible con: Windows 8

.NET para aplicaciones de Windows Phone

Compatible con: Windows Phone 8, Silverlight 8.1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (no se admite el rol Server Core), Windows Server 2008 R2 (se admite el rol Server Core con SP1 o versiones posteriores; no se admite Itanium)

.NET Framework no admite todas las versiones de todas las plataformas. Para obtener una lista de las versiones compatibles, vea Requisitos de sistema de .NET Framework.

Adiciones de comunidad

AGREGAR
Mostrar:
© 2015 Microsoft