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 (Estructura)

Representa un número de punto flotante de precisión doble.

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

[SerializableAttribute]
[ComVisibleAttribute(true)]
public struct Double : IComparable, IFormattable, 
	IConvertible, IComparable<double>, IEquatable<double>

El tipo Double expone los siguientes miembros.

  NombreDescripción
Método públicoCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsCompareTo(Double)Compara esta instancia con un número de punto flotante de precisión doble especificado y devuelve un entero que indica si el valor de esta instancia es mayor, menor o igual que el valor del número de punto flotante de precisión doble especificado.
Método públicoCompatible con XNA FrameworkCompareTo(Object)Compara esta instancia con un objeto especificado y devuelve un entero que indica si el valor de esta instancia es mayor, igual o menor que el valor del objeto especificado.
Método públicoCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsEquals(Double)Devuelve un valor que indica si esta instancia y un objeto Double especificado representan el mismo valor.
Método públicoCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsEquals(Object)Devuelve un valor que indica si esta instancia equivale a un objeto especificado. (Invalida a ValueType.Equals(Object)).
Método públicoCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsGetHashCodeDevuelve el código hash de esta instancia. (Invalida a ValueType.GetHashCode()).
Método públicoCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsGetType Obtiene el Type de la instancia actual. (Se hereda de Object).
Método públicoCompatible con XNA FrameworkGetTypeCodeDevuelve el TypeCode para el tipo de valor Double.
Método públicoMiembro estáticoCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsIsInfinityDevuelve un valor que indica si el número especificado se evalúa como infinito negativo o positivo.
Método públicoMiembro estáticoCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsIsNaNDevuelve un valor que indica si el valor especificado no es un número (NaN).
Método públicoMiembro estáticoCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsIsNegativeInfinityDevuelve un valor que indica si el número especificado se evalúa como infinito negativo.
Método públicoMiembro estáticoCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsIsPositiveInfinityDevuelve un valor que indica si el número especificado se evalúa como infinito positivo.
Método públicoMiembro estáticoCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsParse(String)Convierte la representación en forma de cadena de un número en el número de punto flotante de precisión doble equivalente.
Método públicoMiembro estáticoCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsParse(String, NumberStyles)Convierte la representación en forma de cadena de un número con un estilo especificado en el número de punto flotante de precisión doble equivalente.
Método públicoMiembro estáticoCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsParse(String, IFormatProvider)Convierte la representación en forma de cadena de un número con un formato específico de la referencia cultural especificado en el número de punto flotante de precisión doble equivalente.
Método públicoMiembro estáticoCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsParse(String, NumberStyles, IFormatProvider)Convierte la representación en forma de cadena de un número con un estilo y un formato específico de la referencia cultural especificados en el número de punto flotante de precisión doble equivalente.
Método públicoCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsToString()Convierte el valor numérico de esta instancia en la representación de cadena equivalente. (Invalida a ValueType.ToString()).
Método públicoCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsToString(IFormatProvider)Convierte el valor numérico de esta instancia en la representación de cadena equivalente utilizando la información de formato específica de la referencia cultural especificada.
Método públicoCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsToString(String)Convierte el valor numérico de esta instancia en la representación de cadena equivalente utilizando el formato especificado.
Método públicoCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsToString(String, IFormatProvider)Convierte el valor numérico de esta instancia en su representación de cadena equivalente mediante el formato y la información de formato específica de la referencia cultural que se hayan especificado.
Método públicoMiembro estáticoCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsTryParse(String, Double)Convierte la representación en forma de cadena de un número en el número de punto flotante de precisión doble equivalente. Un valor devuelto indica si la conversión se realizó correctamente o si se produjeron errores.
Método públicoMiembro estáticoCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsTryParse(String, NumberStyles, IFormatProvider, Double)Convierte la representación en forma de cadena de un número con un estilo y un formato específico de la referencia cultural especificados en el número de punto flotante de precisión doble equivalente. Un valor devuelto indica si la conversión se realizó correctamente o si se produjeron errores.
Arriba

  NombreDescripción
Operador públicoMiembro estáticoCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsEqualityDevuelve un valor que indica si dos valores Double especificados son iguales.
Operador públicoMiembro estáticoCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsGreaterThanDevuelve un valor que indica si un valor Double especificado es mayor que otro valor Double especificado.
Operador públicoMiembro estáticoCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsGreaterThanOrEqualDevuelve un valor que indica si un valor Double especificado es mayor o igual que otro valor Double especificado.
Operador públicoMiembro estáticoCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsInequalityDevuelve un valor que indica si dos valores Double especificados no son iguales.
Operador públicoMiembro estáticoCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsLessThanDevuelve un valor que indica si un valor Double especificado es menor que otro valor Double especificado.
Operador públicoMiembro estáticoCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsLessThanOrEqualDevuelve un valor que indica si un valor Double especificado es menor o igual que otro valor Double especificado.
Arriba

  NombreDescripción
Campo públicoMiembro estáticoCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsEpsilonRepresenta el menor valor Double positivo mayor que cero. Este campo es constante.
Campo públicoMiembro estáticoCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsMaxValueRepresenta el mayor valor posible de un objeto Double. Este campo es constante.
Campo públicoMiembro estáticoCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsMinValueRepresenta el menor valor posible de Double. Este campo es constante.
Campo públicoMiembro estáticoCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsNaNRepresenta un valor no numérico (NaN). Este campo es constante.
Campo públicoMiembro estáticoCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsNegativeInfinityRepresenta infinito negativo. Este campo es constante.
Campo públicoMiembro estáticoCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsPositiveInfinityRepresenta infinito positivo. Este campo es constante.
Arriba

  NombreDescripción
Implementación explícita de interfacesMétodo privadoCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsIComparable.CompareToCompara la instancia actual con otro objeto del mismo tipo y devuelve un entero que indica si la posición de la instancia actual es anterior, posterior o igual que la del otro objeto en el criterio de ordenación.
Implementación explícita de interfacesMétodo privadoCompatible con XNA FrameworkIConvertible.ToBooleanInfraestructura. Para obtener una descripción de este miembro, vea el método IConvertible.ToBoolean.
Implementación explícita de interfacesMétodo privadoCompatible con XNA FrameworkIConvertible.ToByteInfraestructura. Para obtener una descripción de este miembro, vea IConvertible.ToByte.
Implementación explícita de interfacesMétodo privadoCompatible con XNA FrameworkIConvertible.ToCharInfraestructura. No se admite esta conversión. Cualquier intento de utilizar este método produce una excepción InvalidCastException.
Implementación explícita de interfacesMétodo privadoCompatible con XNA FrameworkIConvertible.ToDateTimeInfraestructura. No se admite esta conversión. Cualquier intento de utilizar este método produce una excepción InvalidCastException.
Implementación explícita de interfacesMétodo privadoCompatible con XNA FrameworkIConvertible.ToDecimalInfraestructura. Para obtener una descripción de este miembro, vea IConvertible.ToDecimal.
Implementación explícita de interfacesMétodo privadoCompatible con XNA FrameworkIConvertible.ToDoubleInfraestructura. Para obtener una descripción de este miembro, vea IConvertible.ToDouble.
Implementación explícita de interfacesMétodo privadoCompatible con XNA FrameworkIConvertible.ToInt16Infraestructura. Para obtener una descripción de este miembro, vea IConvertible.ToInt16.
Implementación explícita de interfacesMétodo privadoCompatible con XNA FrameworkIConvertible.ToInt32Infraestructura. Para obtener una descripción de este miembro, vea IConvertible.ToInt32.
Implementación explícita de interfacesMétodo privadoCompatible con XNA FrameworkIConvertible.ToInt64Infraestructura. Para obtener una descripción de este miembro, vea IConvertible.ToInt64.
Implementación explícita de interfacesMétodo privadoCompatible con XNA FrameworkIConvertible.ToSByteInfraestructura. Para obtener una descripción de este miembro, vea IConvertible.ToSByte.
Implementación explícita de interfacesMétodo privadoCompatible con XNA FrameworkIConvertible.ToSingleInfraestructura. Para obtener una descripción de este miembro, vea IConvertible.ToSingle.
Implementación explícita de interfacesMétodo privadoCompatible con XNA FrameworkIConvertible.ToTypeInfraestructura. Para obtener una descripción de este miembro, vea IConvertible.ToType.
Implementación explícita de interfacesMétodo privadoCompatible con XNA FrameworkIConvertible.ToUInt16Infraestructura. Para obtener una descripción de este miembro, vea IConvertible.ToUInt16.
Implementación explícita de interfacesMétodo privadoCompatible con XNA FrameworkIConvertible.ToUInt32Infraestructura. Para obtener una descripción de este miembro, vea IConvertible.ToUInt32.
Implementación explícita de interfacesMétodo privadoCompatible con XNA FrameworkIConvertible.ToUInt64Infraestructura. Para obtener una descripción de este miembro, vea IConvertible.ToUInt64.
Arriba

El tipo de valor de Double representa un número de 64 bits de precisión doble con los valores que van de 1.79769313486232e308 negativo a 1.79769313486232e308 positivo, así como positivo o negativo cero, PositiveInfinity, NegativeInfinity, y no un número (NaN). Está pensado para representar los valores que son muy grandes (por ejemplo distancias entre los planetas o las galaxias) o sumamente pequeño (la masa molecular de una sustancia en kilogramos) y que son a menudo imprecisos (como la distancia de la tierra a otro Sistema luz), tipo de El Double cumple el estándar 60559:1989 de CEI (IEEE 754) para la aritmética flotante binaria.

Este tema consta de las siguientes secciones:

Representación y Precisión flotante

El tipo de datos de Double almacena valores de punto flotante de doble precisión en un formato binario 64 bits, tal y como se muestra en la tabla siguiente:

Parte

Bits

Significand o mantisa

0-51

Exponente

52-62

Signo (0 = positivo, 1 = negativa)

63

Simplemente como fracciones decimales no pueden representar exacto algunos valores fraccionarios (como 1/3 o Math.PI), fracciones binarias no pueden representar algunos valores fraccionarios. Por ejemplo, 1/10, que se representa exacto por .1 como una fracción decimal, representa el .001100110011 como fracción binaria, con el modelo “0011 " repitiendo el infinito. En este caso, el valor de punto flotante proporciona una representación imprecisa de número que representa. Realizar operaciones matemáticas adicionales en el valor de punto flotante original tiende a aumentar la falta de precisión. Por ejemplo, si comparamos el resultado de multiplicar .1 por 10 y agregar .1 a .1 nueve veces, consultamos esa suma, porque ha implicado ocho más operaciones, hemos generado el resultado menos exacto. Observe que esta disparidad resulta evidente sólo si se muestra los dos valores de Double usando “r” cadena de formato numérico estándarque, en caso necesario muestra los 17 dígitos de precisión que admite el tipo de Double .


using System;

public class Example
{
   public static void Main()
   {
      Double value = .1;
      Double result1 = value * 10;
      Double result2 = 0;
      for (int ctr = 1; ctr <= 10; ctr++)
         result2 += value;

      Console.WriteLine(".1 * 10:           {0:R}", result1);
      Console.WriteLine(".1 Added 10 times: {0:R}", result2);
   }
}
// The example displays the following output:
//       .1 * 10:           1
//       .1 Added 10 times: 0.99999999999999989


Porque algunos números no pueden representarse exactamente como valores binarios fraccionarios, números de punto flotante pueden aproximar sólo números reales.

Todos los números de punto flotante también tienen un número limitado de dígitos significativos, que también determina cómo un valor de punto flotante aproxima exactamente un número real. Un valor de Double tiene hasta 15 dígitos decimales de precisión, aunque un máximo de 17 dígitos se mantiene internamente. Esto significa que algunas operaciones de punto flotante pueden falta la precisión cambiar un valor de punto flotante. Esto se muestra en el ejemplo siguiente. Define un valor de punto flotante muy grande y, a continuación el producto de Double.Epsilon y un cuatrillón al. El producto, sin embargo, es demasiado pequeño modificar el valor de punto flotante original. El menos dígito significativo es diezmilésimas, mientras que el dígito más significativo de producto es 1.-312


using System;

public class Example
{
   public static void Main()
   {
      Double value = 123456789012.34567;
      Double additional = Double.Epsilon * 1e12;
      Console.WriteLine("{0} + {1} = {2}", value, additional, 
                                           value + additional);
   }
}
// The example displays the following output:
//    123456789012.346 + 4.94065645841247E-312 = 123456789012.346


La precisión limitada de un número de punto flotante tiene varias consecuencias:

  • Dos números en punto flotante que parezcan iguales para una precisión en concreto quizás no resulten iguales al compararlos porque que sus dígitos menos significativos sean diferentes. En el ejemplo siguiente, una serie de números se suma, y el total se compara con el total esperado. Aunque los dos valores parezcan ser igual, una llamada al método de Equals indica que no son.

    
    using System;
    
    public class Example
    {
       public static void Main()
       {
          Double[] values = { 10.0, 2.88, 2.88, 2.88, 9.0 };
          Double result = 27.64;
          Double total = 0;
          foreach (var value in values)
             total += value;
    
          if (total.Equals(result))
             Console.WriteLine("The sum of the values equals the total.");
          else
             Console.WriteLine("The sum of the values ({0}) does not equal the total ({1}).",
                               total, result); 
       }
    }
    // The example displays the following output:
    //      The sum of the values (36.64) does not equal the total (36.64).   
    //
    // If the index items in the Console.WriteLine statement are changed to {0:R},
    // the example displays the following output:
    //       The sum of the values (27.639999999999997) does not equal the total (27.64).   
    
    
    

    Si cambia los elementos de formato en la instrucción de Console.WriteLine(String, Object, Object) de {0} y de {1} a {0:R} y a {1:R} para mostrar todos los dígitos significativos de los dos valores de Double , es evidente que los dos valores no coinciden debido a una pérdida de precisión durante las operaciones de suma. En este caso, el problema se puede resolver llamando al método de Math.Round(Double, Int32) para redondear los valores de Double de precisión deseada antes de realizar la comparación.

  • Una operación matemática o de comparación que utiliza un número de punto flotante no puede provocar el mismo resultado si se utiliza un número decimal, porque el número de punto flotante binario podría no ser igual al número decimal. Un ejemplo anterior ilustra esto muestra el resultado de multiplicar .1 por 10 y agregar .1 nuevo.

    Cuando la exactitud en operaciones numéricas con valores fraccionarios es importante, puede utilizar Decimal en lugar del tipo de Double . Cuando la exactitud en operaciones numéricas con valores enteros más allá del intervalo de los tipos de Int64 o de UInt64 es importante, utilice el tipo de BigInteger .

  • Un valor podría no de ida y vuelta si un número de punto flotante implicado. Un valor se indica a la operación de ida y vuelta si una operación convierte un número en punto flotante original a otro formulario, una operación inversa transforma el formulario convertido a un número de punto flotante, y el número de punto flotante final no es igual al número de punto flotante original. Si uno o varios de los dígitos menos significativos se pierden o cambian durante una conversión, puede que se produzca un error en la acción de ida y vuelta. En el ejemplo siguiente, tres valores de Double se convierten en cadenas y guardados en un archivo. Como muestra el resultado, sin embargo, aunque los valores parecen ser idénticos, los valores se restauran no son iguales a los valores originales.

    
    using System;
    using System.IO;
    
    public class Example
    {
       public static void Main()
       {
          StreamWriter sw = new StreamWriter(@".\Doubles.dat");
          Double[] values = { 2.2/1.01, 1.0/3, Math.PI };
          for (int ctr = 0; ctr < values.Length; ctr++) {
             sw.Write(values[ctr].ToString());
             if (ctr != values.Length - 1)
                sw.Write("|");
          }      
          sw.Close();
    
          Double[] restoredValues = new Double[values.Length];
          StreamReader sr = new StreamReader(@".\Doubles.dat");
          string temp = sr.ReadToEnd();
          string[] tempStrings = temp.Split('|');
          for (int ctr = 0; ctr < tempStrings.Length; ctr++)
             restoredValues[ctr] = Double.Parse(tempStrings[ctr]);   
    
    
          for (int ctr = 0; ctr < values.Length; ctr++)
             Console.WriteLine("{0} {2} {1}", values[ctr], 
                               restoredValues[ctr],
                               values[ctr].Equals(restoredValues[ctr]) ? "=" : "<>");
       }
    }
    // The example displays the following output:
    //       2.17821782178218 <> 2.17821782178218
    //       0.333333333333333 <> 0.333333333333333
    //       3.14159265358979 <> 3.14159265358979
    
    
    

    En este caso, los valores se pueden redondo- disparar correctamente usando “r” cadena de formato numérico estándar para conservar la precisión completa de los valores de Double , como se muestra en el ejemplo siguiente.

    
    using System;
    using System.IO;
    
    public class Example
    {
       public static void Main()
       {
          StreamWriter sw = new StreamWriter(@".\Doubles.dat");
          Double[] values = { 2.2/1.01, 1.0/3, Math.PI };
          for (int ctr = 0; ctr < values.Length; ctr++) 
             sw.Write("{0:R}{1}", values[ctr], ctr < values.Length - 1 ? "|" : "" );
    
          sw.Close();
    
          Double[] restoredValues = new Double[values.Length];
          StreamReader sr = new StreamReader(@".\Doubles.dat");
          string temp = sr.ReadToEnd();
          string[] tempStrings = temp.Split('|');
          for (int ctr = 0; ctr < tempStrings.Length; ctr++)
             restoredValues[ctr] = Double.Parse(tempStrings[ctr]);   
    
    
          for (int ctr = 0; ctr < values.Length; ctr++)
             Console.WriteLine("{0} {2} {1}", values[ctr], 
                               restoredValues[ctr],
                               values[ctr].Equals(restoredValues[ctr]) ? "=" : "<>");
       }
    }
    // The example displays the following output:
    //       2.17821782178218 = 2.17821782178218
    //       0.333333333333333 = 0.333333333333333
    //       3.14159265358979 = 3.14159265358979
    
    
    
  • los valores deSingle tienen menos precisión que los valores de Double . Un valor de Single que se convierte en Double aparentemente equivalente no es a menudo el valor de Double debido a las diferencias en la precisión. En el ejemplo siguiente, el resultado de las operaciones idénticas de división se asigna a Double y un valor de Single . Después de que el valor de Single se convierta en Double, una comparación de los dos valores muestra que son iguales.

    
    using System;
    
    public class Example
    {
       public static void Main()
       {
          Double value1 = 1/3.0;
          Single sValue2 = 1/3.0f;
          Double value2 = (Double) sValue2;
          Console.WriteLine("{0:R} = {1:R}: {2}", value1, value2, 
                                              value1.Equals(value2));
       }
    }
    // The example displays the following output:
    //        0.33333333333333331 = 0.3333333432674408: False
    
    
    

    Para evitar este problema, use Double en lugar del tipo de datos de Single , o utilice el método de Round de modo que ambos valores tienen la misma precisión.

Asimismo, el resultado de las operaciones aritméticas y de asignación con valores Double puede diferir ligeramente según la plataforma debido a la pérdida de precisión del tipo Double. Por ejemplo, el resultado de asignar un valor Double literal puede diferir en las versiones de 32 bits y de 64 bits de .NET Framework. En el siguiente ejemplo se muestra esta diferencia cuando el valor literal -4.42330604244772E-305 y una variable cuyo valor es -4.42330604244772E-305 están asignados a una variable Double. Observe que el resultado del método Parse(String) en este caso no padece ninguna pérdida de precisión.


double value = -4.42330604244772E-305;

double fromLiteral = -4.42330604244772E-305;
double fromVariable = value;
double fromParse = Double.Parse("-4.42330604244772E-305");

Console.WriteLine("Double value from literal: {0,29:R}", fromLiteral);
Console.WriteLine("Double value from variable: {0,28:R}", fromVariable);
Console.WriteLine("Double value from Parse method: {0,24:R}", fromParse);      
// On 32-bit versions of the .NET Framework, the output is:
//    Double value from literal:        -4.42330604244772E-305
//    Double value from variable:       -4.42330604244772E-305
//    Double value from Parse method:   -4.42330604244772E-305
//
// On other versions of the .NET Framework, the output is:
//    Double value from literal:      -4.4233060424477198E-305
//    Double value from variable:     -4.4233060424477198E-305
//    Double value from Parse method:   -4.42330604244772E-305      


Comprobar la igualdad

Para considerarse igual, dos valores de Double deben representar valores idénticos. Sin embargo, debido a las diferencias en la precisión entre los valores, o debido a una pérdida de precisión por uno o ambos valores, valores de punto flotante que se espera que son a menudo producción idéntica a ser desigual debido a las diferencias en los menos dígitos significativos. Como resultado, las llamadas al método de Equals para determinar si dos valores son iguales, o las llamadas al método de CompareTo para determinar la relación entre dos valores de Double , deben a menudo resultados inesperados. Esto resulta patente en el ejemplo siguiente, donde dos valores aparentemente iguales de Double resultan ser desiguales porque los primeros tienen 15 dígitos de precisión, mientras que los segundos tienen 17.


using System;

public class Example
{
   public static void Main()
   {
      double value1 = .333333333333333;
      double value2 = 1.0/3;
      Console.WriteLine("{0:R} = {1:R}: {2}", value1, value2, value1.Equals(value2));
   }
}
// The example displays the following output:
//        0.333333333333333 = 0.33333333333333331: False


Valores calculados que siguen diferentes rutas de acceso de código y se manipulan de maneras diferentes muestran una presenten distintos. En el ejemplo siguiente, se eleva un valor de Double y, a continuación la raíz cuadrada se calcula para restablecer el valor original. Un segundo Double se multiplica por 3,51 y cuadrado antes de que la raíz cuadrada del resultado esté dividido por 3,51 para restablecer el valor original. Aunque los dos valores parezcan ser idénticos, una llamada al método de Equals(Double) indica que no son iguales. Mediante la cadena de formato estándar “r” devolver una cadena de resultado que muestra todos los dígitos significativos de cada valor double muestra que el segundo valor es .0000000000001 menos que el primero.


using System;

public class Example
{
   public static void Main()
   {
      double value1 = 100.10142;
      value1 = Math.Sqrt(Math.Pow(value1, 2));
      double value2 = Math.Pow(value1 * 3.51, 2);
      value2 = Math.Sqrt(value2) / 3.51;
      Console.WriteLine("{0} = {1}: {2}\n", 
                        value1, value2, value1.Equals(value2)); 
      Console.WriteLine("{0:R} = {1:R}", value1, value2); 
   }
}
// The example displays the following output:
//    100.10142 = 100.10142: False
//    
//    100.10142 = 100.10141999999999


En caso de que una pérdida de precisión es probable que el resultado de una comparación, puede adoptar cualquiera de las alternativas a llamar al método de Equals o de CompareTo :

  • Llame al método de Math.Round para asegurarse de que ambos valores tienen la misma precisión. El ejemplo siguiente se modifica un ejemplo anterior para utilizar este enfoque para que dos valores fraccionarios son equivalentes.

    
    using System;
    
    public class Example
    {
       public static void Main()
       {
          double value1 = .333333333333333;
          double value2 = 1.0/3;
          int precision = 7;
          value1 = Math.Round(value1, precision);
          value2 = Math.Round(value2, precision);
          Console.WriteLine("{0:R} = {1:R}: {2}", value1, value2, value1.Equals(value2));
       }
    }
    // The example displays the following output:
    //        0.3333333 = 0.3333333: True
    
    
    

    Observe, sin embargo, que el problema de precisión sigue aplicándose a redondeo de valores de punto medio. Para obtener más información, vea el método Math.Round(Double, Int32, MidpointRounding).

  • Prueba de igualdad aproximada en lugar de igualdad. Esto requiere que se defina un importe absoluto por el que los dos valores pueden diferir pero ser igual, o que define un cantidad relativa por el que el valor más pequeño puede distinguir de valor más grande.

    Nota de precauciónPrecaución

    Double.Epsilon se utiliza a veces como medida absoluta de la distancia entre dos valores de Double al comprobar la igualdad. Sin embargo, Double.Epsilon mide el valor posible más pequeño al que se puede agregar, o se resta de, Double cuyo valor sea cero. Por valores más positivos y negativos más de Double , el valor de Double.Epsilon es demasiado pequeño para ser detectado. Por consiguiente, a excepción de los valores que son cero, no se recomienda su uso en las pruebas de igualdad.

    El ejemplo siguiente utiliza el último enfoque para definir un método de IsApproximatelyEqual que pruebe la diferencia relativa entre dos valores. También contrasta el resultado de llamadas con el método de IsApproximatelyEqual y el método de Equals(Double) .

    
    using System;
    
    public class Example
    {
       public static void Main()
       {
          double one1 = .1 * 10;
          double one2 = 0;
          for (int ctr = 1; ctr <= 10; ctr++)
             one2 += .1;
    
          Console.WriteLine("{0:R} = {1:R}: {2}", one1, one2, one1.Equals(one2));
          Console.WriteLine("{0:R} is approximately equal to {1:R}: {2}", 
                            one1, one2, 
                            IsApproximatelyEqual(one1, one2, .000000001));   
       }
    
       static bool IsApproximatelyEqual(double value1, double value2, double epsilon)
       {
          // If they are equal anyway, just return True.
          if (value1.Equals(value2))
             return true;
    
          // Handle NaN, Infinity.
          if (Double.IsInfinity(value1) | Double.IsNaN(value1))
             return value1.Equals(value2);
          else if (Double.IsInfinity(value2) | Double.IsNaN(value2))
             return value1.Equals(value2);
    
          // Handle zero to avoid division by zero
          double divisor = Math.Max(value1, value2);
          if (divisor.Equals(0)) 
             divisor = Math.Min(value1, value2);
    
          return Math.Abs(value1 - value2)/divisor <= epsilon;           
       } 
    }
    // The example displays the following output:
    //       1 = 0.99999999999999989: False
    //       1 is approximately equal to 0.99999999999999989: True
    
    
    

Valores de punto flotante y Excepciones

A diferencia de operaciones con los tipos enteros, que producen excepciones en casos de desbordamiento o de operaciones no válidas como división por cero, las operaciones con valores de punto flotante no producen excepciones. En su lugar, en situaciones excepcionales, el resultado de una operación de coma flotante es infinito cero, positivo, infinito negativo, o no un número (NaN):

  • Si el resultado de una operación de coma flotante es demasiado pequeño para el formato de destino, el resultado es cero. Esto puede ocurrir cuando se multiplican dos números muy pequeños, como en el ejemplo siguiente.

    
    using System;
    
    public class Example
    {
       public static void Main()
       {
          Double value1 = 1.1632875981534209e-225;
          Double value2 = 9.1642346778e-175;
          Double result = value1 * value2;
          Console.WriteLine("{0} * {1} = {2}", value1, value2, result);
          Console.WriteLine("{0} = 0: {1}", result, result.Equals(0.0));
       }
    }
    // The example displays the following output:
    //       1.16328759815342E-225 * 9.1642346778E-175 = 0
    //       0 = 0: True
    
    
    
  • Si la magnitud del resultado de una operación de coma flotante supera el intervalo de formato de destino, el resultado de la operación PositiveInfinity o NegativeInfinity, según corresponda al signo del resultado. El resultado de una operación que desborde Double.MaxValue es PositiveInfinity, y el resultado de una operación que los desbordamientos Double.MinValue son NegativeInfinity, como se muestra en el ejemplo siguiente.

    
    using System;
    
    public class Example
    {
       public static void Main()
       {
          Double value1 = 4.565e153;
          Double value2 = 6.9375e172;
          Double result = value1 * value2;
          Console.WriteLine("PositiveInfinity: {0}", 
                             Double.IsPositiveInfinity(result));
          Console.WriteLine("NegativeInfinity: {0}\n", 
                            Double.IsNegativeInfinity(result));
    
          value1 = -value1;
          result = value1 * value2;
          Console.WriteLine("PositiveInfinity: {0}", 
                             Double.IsPositiveInfinity(result));
          Console.WriteLine("NegativeInfinity: {0}", 
                            Double.IsNegativeInfinity(result));
       }
    }                                                                 
    
    // The example displays the following output:
    //       PositiveInfinity: True
    //       NegativeInfinity: False
    //       
    //       PositiveInfinity: False
    //       NegativeInfinity: True
    
    
    

    PositiveInfinity también resulta de una división por cero con un dividendo positivo, y los resultados de NegativeInfinity de una división por cero con un dividendo negativo.

  • Si una operación de punto flotante no es válida, el resultado de la operación es NaN. Por ejemplo, NaN resultados de las operaciones siguientes:

  • Cualquier operación de punto flotante con una entrada no válida. Por ejemplo, llamando al método de Math.Sqrt con un valor negativo devuelve NaN, al igual que llamar al método de Math.Acos con un valor mayor que uno o menor que la negativa una.

  • Cualquier operación con un argumento cuyo valor es Double.NaN.

Funcionalidad flotante

La estructura de Double y tipos relacionados proporcionan métodos para realizar operaciones en las áreas siguientes:

  • Comparación de valores. Se puede llamar al método de Equals para determinar si dos valores de Double son iguales, o un método de CompareTo para determinar la relación entre dos valores.

    La estructura de Double también admite un conjunto completo de operadores de comparación. Por ejemplo, puede probar la igualdad o desigualdad, o determinar si un valor es mayor o igual que otro. Si uno de los operandos es un tipo numérico distinto de Double, se convierte en Double antes de realizar la comparación.

    Nota de precauciónPrecaución

    Debido a las diferencias en la precisión, dos valores de Double que espera que son el igual pueden producir ser desigual, que afecta al resultado de la comparación. Vea la sección de Prueba para Equality para obtener más información sobre cómo comparar dos valores de Double .

    También puede llamar IsNaN, IsInfinity, IsPositiveInfinity, y los métodos de IsNegativeInfinity para probar a estos valores especiales.

  • Operaciones matemáticas. Las operaciones aritméticas comunes, como suma, resta, multiplicación, y división, se implementan mediante los compiladores de lenguaje y las instrucciones comunes de (CIL) de lenguaje intermedio, no por los métodos de Double . Si uno de los operandos de una operación matemática es un tipo numérico distinto de Double, se convierte en Double antes de realizar la operación. El resultado de la operación también un valor de Double .

    Otras operaciones matemáticas pueden realizar llamando a los métodos de static (Shared en Visual Basic) en la clase de System.Math . Incluye métodos adicionales de uso general para la aritmética (como Math.Abs, Math.Sign, y Math.Sqrt), la geometría (como Math.Cos y Math.Sin), y el cálculo (como Math.Log).

    También puede manipular los bits individuales en un valor de Double . El método de BitConverter.DoubleToInt64Bits mantiene la configuración de bits de un valor de Double en un entero de 64 bits. El método de BitConverter.GetBytes(Double) devuelve su configuración de bits en una matriz de bytes.

  • Redondeo. El redondeo se utiliza a menudo como una técnica para reducir el impacto de diferencias entre los valores generados por problemas de representación de coma flotante y precisión. Puede redondea un valor de Double llamando al método de Math.Round .

  • Formato. Puede convertir un valor de Double en su representación de cadena llamando al método de ToString o utilizando la característica de formato compuesto. Para obtener información sobre cómo las cadenas de formato controlan la representación de cadena de valores de punto flotante, vea los temas de Cadenas con formato numérico estándar y de Cadenas con formato numérico personalizado .

  • Cadenas de análisis. Puede convertir la representación de cadena de un valor de punto flotante a un valor de Double llamando a Parse o el método de TryParse . Si se produce un error en la operación de análisis, el método de Parse produce una excepción, mientras que el método de TryParse devuelve false.

  • Conversión de tipos. La estructura de Double proporciona una implementación de interfaz explícita para la interfaz de IConvertible , que admite la conversión entre los dos tipos de datos estándar de .NET Framework. Los compiladores de lenguaje también admiten la conversión implícita de valores de los demás tipos numéricos estándar a los valores de Double . La conversión de un valor de cualquier tipo numérico estándar a Double es una conversión de ampliación y no requiere que el usuario de un método de operador de conversión o de conversión,

    Sin embargo, la conversión de Int64 y los valores de Single puede implicar una pérdida de precisión. La tabla siguiente se enumeran las diferencias de precisión para cada uno de estos tipos:

    Tipo

    Precisión máxima

    Precisión interna

    Double

    15

    17

    Int64

    19 dígitos decimales

    19 dígitos decimales

    Single

    7 dígitos decimales

    9 dígitos decimales

    El problema de precisión frecuentemente afecta a los valores de Single que se convierten a los valores de Double . En el ejemplo siguiente, dos valores generados por operaciones idénticas de división son iguales porque uno de los valores es un valor de punto flotante de precisión sencilla convertido a Double.

    
    using System;
    
    public class Example
    {
       public static void Main()
       {
          Double value = .1;
          Double result1 = value * 10;
          Double result2 = 0;
          for (int ctr = 1; ctr <= 10; ctr++)
             result2 += value;
    
          Console.WriteLine(".1 * 10:           {0:R}", result1);
          Console.WriteLine(".1 Added 10 times: {0:R}", result2);
       }
    }
    // The example displays the following output:
    //       .1 * 10:           1
    //       .1 Added 10 times: 0.99999999999999989
    
    
    

En el siguiente ejemplo de código se muestra el uso de Double.


	// The Temperature class stores the temperature as a Double
	// and delegates most of the functionality to the Double
	// implementation.
	public class Temperature : IComparable, IFormattable 
    {
		// IComparable.CompareTo implementation.
		public int CompareTo(object obj) {
            if (obj == null) return 1;

			Temperature temp = obj as Temperature;
            if (obj != null) 
				return m_value.CompareTo(temp.m_value);
			else
     			throw new ArgumentException("object is not a Temperature");	
		}

		// IFormattable.ToString implementation.
		public string ToString(string format, IFormatProvider provider) {
			if( format != null ) {
				if( format.Equals("F") ) {
					return String.Format("{0}'F", this.Value.ToString());
				}
				if( format.Equals("C") ) {
					return String.Format("{0}'C", this.Celsius.ToString());
				}
			}

			return m_value.ToString(format, provider);
		}

		// Parses the temperature from a string in the form
		// [ws][sign]digits['F|'C][ws]
		public static Temperature Parse(string s, NumberStyles styles, IFormatProvider provider) {
			Temperature temp = new Temperature();

			if( s.TrimEnd(null).EndsWith("'F") ) {
				temp.Value = Double.Parse( s.Remove(s.LastIndexOf('\''), 2), styles, provider);
			}
			else if( s.TrimEnd(null).EndsWith("'C") ) {
				temp.Celsius = Double.Parse( s.Remove(s.LastIndexOf('\''), 2), styles, provider);
			}
			else {
				temp.Value = Double.Parse(s, styles, provider);
			}

			return temp;
		}

		// The value holder
		protected double m_value;

		public double Value {
			get {
				return m_value;
			}
			set {
				m_value = value;
			}
		}

		public double Celsius {
			get {
				return (m_value-32.0)/1.8;
			}
			set {
				m_value = 1.8*value+32.0;
			}
		}
	}


.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.

Todos los miembros de este tipo son seguros para la ejecución de subprocesos. Los miembros que aparecen para modificar el estado de la instancia devuelven una nueva instancia inicializada con el nuevo valor. Al igual que con cualquier otro tipo, la lectura y escritura en una variable compartida que contiene una instancia de este tipo deben protegerse mediante un bloqueo para garantizar la seguridad para subprocesos.

Nota de precauciónPrecaución

La asignación de una instancia de este tipo no es segura para subprocesos en todas las plataformas de hardware, porque la representación binaria de esta instancia puede ser demasiado grande para la asignación en una sola operación atómica.

Adiciones de comunidad

AGREGAR
Mostrar:
© 2014 Microsoft