Double Estructura

Referencia

Definición

Espacio de nombres:: System

Ensamblado:: System.Runtime.dll

Ensamblado:: netstandard.dll

Ensamblado:: mscorlib.dll

Importante

Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.

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

public value class double : IComparable, IComparable<double>, IConvertible, IEquatable<double>, IFormattable

public value class double : IComparable, IComparable<double>, IConvertible, IEquatable<double>, ISpanFormattable

public value class double : IComparable, IConvertible, IFormattable

public value class double : IComparable, IComparable<double>, IEquatable<double>, IFormattable

public struct Double : IComparable, IComparable<double>, IConvertible, IEquatable<double>, IFormattable

public struct Double : IComparable, IComparable<double>, IConvertible, IEquatable<double>, ISpanFormattable

[System.Serializable]
public struct Double : IComparable, IConvertible, IFormattable

[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public struct Double : IComparable, IComparable<double>, IConvertible, IEquatable<double>, IFormattable

public struct Double : IComparable, IComparable<double>, IEquatable<double>, IFormattable

type double = struct
    interface IConvertible
    interface IFormattable

type double = struct
    interface IConvertible
    interface ISpanFormattable
    interface IFormattable

[<System.Serializable>]
type double = struct
    interface IFormattable
    interface IConvertible

[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type double = struct
    interface IFormattable
    interface IConvertible

type double = struct
    interface IFormattable

Public Structure Double
Implements IComparable, IComparable(Of Double), IConvertible, IEquatable(Of Double), IFormattable

Public Structure Double
Implements IComparable, IComparable(Of Double), IConvertible, IEquatable(Of Double), ISpanFormattable

Public Structure Double
Implements IComparable, IConvertible, IFormattable

Public Structure Double
Implements IComparable, IComparable(Of Double), IEquatable(Of Double), IFormattable

Herencia: Object

ValueType
Double

Atributos: SerializableAttribute ComVisibleAttribute

Implementaciones: IComparable IComparable<Double> IConvertible IEquatable<Double> IFormattable ISpanFormattable

Ejemplos

En el ejemplo de código siguiente 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 ref class Temperature: public IComparable, public IFormattable
{
   // IComparable.CompareTo implementation.
public:
   virtual int CompareTo( Object^ obj )
   {
      if (obj == nullptr) return 1;
      
      if (dynamic_cast<Temperature^>(obj) )
      {
         Temperature^ temp = (Temperature^)(obj);
         return m_value.CompareTo( temp->m_value );
      }
      throw gcnew ArgumentException( "object is not a Temperature" );
   }

   // IFormattable.ToString implementation.
   virtual String^ ToString( String^ format, IFormatProvider^ provider )
   {
      if ( format != nullptr )
      {
         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]
   static Temperature^ Parse( String^ s, NumberStyles styles, IFormatProvider^ provider )
   {
      Temperature^ temp = gcnew Temperature;

      if ( s->TrimEnd(nullptr)->EndsWith( "'F" ) )
      {
         temp->Value = Double::Parse( s->Remove( s->LastIndexOf( '\'' ), 2 ), styles, provider );
      }
      else
      if ( s->TrimEnd(nullptr)->EndsWith( "'C" ) )
      {
         temp->Celsius = Double::Parse( s->Remove( s->LastIndexOf( '\'' ), 2 ), styles, provider );
      }
      else
      {
         temp->Value = Double::Parse( s, styles, provider );
      }
      return temp;
   }

protected:
   double m_value;

public:
   property double Value 
   {
      double get()
      {
         return m_value;
      }

      void set( double value )
      {
         m_value = value;
      }
   }

   property double Celsius 
   {
      double get()
      {
         return (m_value - 32.0) / 1.8;
      }

      void set( double value )
      {
         m_value = 1.8 * value + 32.0;
      }
   }
};

// 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;
        }
    }
}

' Temperature class stores the value as Double
' and delegates most of the functionality 
' to the Double implementation.
Public Class Temperature
    Implements IComparable, IFormattable

    Public Overloads Function CompareTo(ByVal obj As Object) As Integer _
        Implements IComparable.CompareTo

        If TypeOf obj Is Temperature Then
            Dim temp As Temperature = CType(obj, Temperature)

            Return m_value.CompareTo(temp.m_value)
        End If

        Throw New ArgumentException("object is not a Temperature")
    End Function

    Public Overloads Function ToString(ByVal format As String, ByVal provider As IFormatProvider) As String _
        Implements IFormattable.ToString

        If Not (format Is Nothing) Then
            If format.Equals("F") Then
                Return [String].Format("{0}'F", Me.Value.ToString())
            End If
            If format.Equals("C") Then
                Return [String].Format("{0}'C", Me.Celsius.ToString())
            End If
        End If

        Return m_value.ToString(format, provider)
    End Function

    ' Parses the temperature from a string in form
    ' [ws][sign]digits['F|'C][ws]
    Public Shared Function Parse(ByVal s As String, ByVal styles As NumberStyles, ByVal provider As IFormatProvider) As Temperature
        Dim temp As New Temperature()

        If s.TrimEnd(Nothing).EndsWith("'F") Then
            temp.Value = Double.Parse(s.Remove(s.LastIndexOf("'"c), 2), styles, provider)
        Else
            If s.TrimEnd(Nothing).EndsWith("'C") Then
                temp.Celsius = Double.Parse(s.Remove(s.LastIndexOf("'"c), 2), styles, provider)
            Else
                temp.Value = Double.Parse(s, styles, provider)
            End If
        End If
        Return temp
    End Function

    ' The value holder
    Protected m_value As Double

    Public Property Value() As Double
        Get
            Return m_value
        End Get
        Set(ByVal Value As Double)
            m_value = Value
        End Set
    End Property

    Public Property Celsius() As Double
        Get
            Return (m_value - 32) / 1.8
        End Get
        Set(ByVal Value As Double)
            m_value = Value * 1.8 + 32
        End Set
    End Property
End Class

Comentarios

El tipo de valor representa un número de 64 bits de precisión doble con valores que van desde Double negativos 1,79769313486232e308 hasta positivos 1,79769313486232e308, así como cero positivo o negativo, , y no un número PositiveInfinity NegativeInfinity ( NaN ). Está diseñado para representar valores extremadamente grandes (como distancias entre planetas omentexies) o extremadamente pequeños (como la masa molecular de una plantas en losares) y que a menudo son imprecisos (por ejemplo, la distancia entre la tierra y otro sistema solar). El tipo cumple con el estándar Double IEC 60559:1989 (IEEE 754) para aritmética de punto flotante binario.

Este tema consta de las siguientes secciones:

Representación y precisión de punto flotante
Pruebas de igualdad
Excepciones y valores de punto flotante
Conversiones de tipos y la estructura Double
Funcionalidad de punto flotante

Floating-Point y precisión

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

Parte	Bits
Significando o mantisa	0-51
Exponente	52-62
Signo (0 = Positivo, 1 = Negativo)	63

Del mismo modo que las fracciones decimales no pueden representar con precisión algunos valores fraccionales (como 1/3 o ), las fracciones binarias no pueden representar Math.PI algunos valores fraccionales. Por ejemplo, 1/10, representado exactamente por .1 como una fracción decimal, se representa mediante .001100110011 como una fracción binaria, con el patrón "0011" repitiendo hasta infinito. En este caso, el valor de punto flotante proporciona una representación imprecisa del número que representa. La realización de operaciones matemáticas adicionales en el valor de punto flotante original suele aumentar su falta de precisión. Por ejemplo, si comparamos el resultado de multiplicar .1 por 10 y agregar .1 a .1 nueve veces, vemos que la suma, porque ha implicado ocho operaciones más, ha producido el resultado menos preciso. Tenga en cuenta que esta disparidad solo es evidente si se muestran los dos valores mediante la cadena de formato numérico estándar "R", que, si es necesario, muestra los 17 dígitos de precisión admitidos por el Double Double tipo.

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

Module Example
   Public Sub Main()
      Dim value As Double = .1
      Dim result1 As Double = value * 10
      Dim result2 As Double
      For ctr As Integer = 1 To 10
         result2 += value
      Next
      Console.WriteLine(".1 * 10:           {0:R}", result1)
      Console.WriteLine(".1 Added 10 times: {0:R}", result2)
   End Sub
End Module
' The example displays the following output:
'       .1 * 10:           1
'       .1 Added 10 times: 0.99999999999999989

Dado que algunos números no se pueden representar exactamente como valores binarios fraccionales, los números de punto flotante solo pueden aproximarse a 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 la precisión con la que un valor de punto flotante se aproxima a un número real. Un valor tiene hasta 15 dígitos decimales de precisión, aunque se mantiene internamente un máximo Double de 17 dígitos. Esto significa que algunas operaciones de punto flotante pueden carecer de precisión para 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, le agrega el producto de Double.Epsilon y un cuadrántor. Sin embargo, el producto es demasiado pequeño para modificar el valor de punto flotante original. Su dígito menos significativo es milésimas, mientras que el dígito más significativo del producto es 10^-309.

using System;

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

Module Example
   Public Sub Main()
      Dim value As Double = 123456789012.34567
      Dim additional As Double = Double.Epsilon * 1e15
      Console.WriteLine("{0} + {1} = {2}", value, additional, 
                                           value + additional)
   End Sub
End Module
' The example displays the following output:
'   123456789012.346 + 4.94065645841247E-309 = 123456789012.346

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

Dos números de coma flotante que parecen iguales para una precisión determinada podrían no compararse como iguales porque sus dígitos menos significativos sean diferentes. En el ejemplo siguiente, se agregan una serie de números y su total se compara con el total esperado. Aunque los dos valores parecen ser los mismos, una llamada al Equals método indica que no lo 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).

Module Example
   Public Sub Main()
      Dim values() As Double = { 10.0, 2.88, 2.88, 2.88, 9.0 }
      Dim result As Double = 27.64
      Dim total As Double
      For Each value In values
         total += value
      Next
      If total.Equals(result) Then
         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) 
      End If     
   End Sub
End Module
' 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 de la instrucción de y a y para mostrar todos los dígitos significativos de los dos valores, está claro que los dos valores no son iguales debido a una pérdida de precisión durante las operaciones de Console.WriteLine(String, Object, Object) {0} {1} {0:R} {1:R} Double suma. En este caso, el problema se puede resolver llamando al método para redondear los valores a la precisión Math.Round(Double, Int32) deseada antes de realizar la Double comparación.

Una operación matemática o de comparación que usa un número de punto flotante podría no producir el mismo resultado si se usa un número decimal, porque el número de punto flotante binario podría no ser igual al número decimal. En un ejemplo anterior se ilustraba esto mostrando el resultado de multiplicar .1 por 10 y agregar .1 veces.

Cuando es importante la precisión en las operaciones numéricas con valores fraccionales, puede usar en Decimal lugar del Double tipo . Cuando sea importante la precisión en operaciones numéricas con valores enteros más allá del intervalo de los tipos Int64 o , use el tipo UInt64 BigInteger .

Un valor podría no ser de ida y vuelta si se trata de un número de punto flotante. Se dice que un valor es de ida y vuelta si una operación convierte un número de punto flotante original en otro formulario, una operación inversa transforma el formulario convertido en un número de punto flotante y el número de punto flotante final no es igual al número de punto flotante original. El recorrido de ida y vuelta puede producir un error porque uno o varios dígitos menos significativos se pierden o cambian en una conversión. En el ejemplo siguiente, tres Double valores se convierten en cadenas y se guardan en un archivo. Sin embargo, como se muestra en la salida, aunque los valores parezcan idénticos, los valores restaurados 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

Imports System.IO

Module Example
   Public Sub Main()
      Dim sw As New StreamWriter(".\Doubles.dat")
      Dim values() As Double = { 2.2/1.01, 1.0/3, Math.PI }
      For ctr As Integer = 0 To values.Length - 1
         sw.Write(values(ctr).ToString())
         If ctr <> values.Length - 1 Then sw.Write("|")
      Next      
      sw.Close()
      
      Dim restoredValues(values.Length - 1) As Double
      Dim sr As New StreamReader(".\Doubles.dat")
      Dim temp As String = sr.ReadToEnd()
      Dim tempStrings() As String = temp.Split("|"c)
      For ctr As Integer = 0 To tempStrings.Length - 1
         restoredValues(ctr) = Double.Parse(tempStrings(ctr))   
      Next 

      For ctr As Integer = 0 To values.Length - 1
         Console.WriteLine("{0} {2} {1}", values(ctr), 
                           restoredValues(ctr),
                           If(values(ctr).Equals(restoredValues(ctr)), "=", "<>"))
      Next
   End Sub
End Module
' 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 redondear correctamente mediante la cadena de formato numérico estándar "G17" para conservar la precisión completa de los valores, como se muestra en el ejemplo Double 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:G17}{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

Imports System.IO

Module Example
   Public Sub Main()
      Dim sw As New StreamWriter(".\Doubles.dat")
      Dim values() As Double = { 2.2/1.01, 1.0/3, Math.PI }
      For ctr As Integer = 0 To values.Length - 1
         sw.Write("{0:G17}{1}", values(ctr), 
                  If(ctr < values.Length - 1, "|", ""))
      Next      
      sw.Close()
      
      Dim restoredValues(values.Length - 1) As Double
      Dim sr As New StreamReader(".\Doubles.dat")
      Dim temp As String = sr.ReadToEnd()
      Dim tempStrings() As String = temp.Split("|"c)
      For ctr As Integer = 0 To tempStrings.Length - 1
         restoredValues(ctr) = Double.Parse(tempStrings(ctr))   
      Next 

      For ctr As Integer = 0 To values.Length - 1
         Console.WriteLine("{0} {2} {1}", values(ctr), 
                           restoredValues(ctr),
                           If(values(ctr).Equals(restoredValues(ctr)), "=", "<>"))
      Next
   End Sub
End Module
' The example displays the following output:
'       2.17821782178218 = 2.17821782178218
'       0.333333333333333 = 0.333333333333333
'       3.14159265358979 = 3.14159265358979

Importante

Cuando se usa con un valor, el especificador de formato "R" en algunos casos no puede completar correctamente el recorrido de ida y vuelta Double del valor original. Para asegurarse de Double que los valores se redondee correctamente, use el especificador de formato "G17".

Single los valores tienen menos precisión que Double los valores de . Un valor que se convierte en un aparentemente equivalente a menudo no es igual al Single valor debido a las Double Double diferencias de precisión. En el ejemplo siguiente, el resultado de operaciones de división idénticas se asigna a Double un y un valor Single . Una vez que el valor se convierte en , una comparación de Single los dos valores muestra que no son Double 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

Module Example
   Public Sub Main()
      Dim value1 As Double = 1/3
      Dim sValue2 As Single = 1/3
      Dim value2 As Double = CDbl(sValue2)
      Console.WriteLine("{0} = {1}: {2}", value1, value2, value1.Equals(value2))
   End Sub
End Module
' The example displays the following output:
'       0.33333333333333331 = 0.3333333432674408: False

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

Además, el resultado de las operaciones aritméticas y de asignación con valores puede diferir ligeramente según la plataforma debido a la pérdida de Double precisión del Double tipo. Por ejemplo, el resultado de asignar un valor literal puede diferir en las versiones de 32 y 64 bits de Double la .NET Framework. En el ejemplo siguiente se muestra esta diferencia cuando el valor literal -4.42330604244772E-305 y una variable cuyo valor es -4.42330604244772E-305 se asignan a una Double variable. Tenga en cuenta que el resultado Parse(String) del método en este caso no sufre una 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

Dim value As Double = -4.42330604244772E-305

Dim fromLiteral As Double = -4.42330604244772E-305
Dim fromVariable As Double = value
Dim fromParse As Double = 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

Pruebas de igualdad

Para que se considere igual, Double dos valores deben representar valores idénticos. Sin embargo, debido a las diferencias de precisión entre los valores o a una pérdida de precisión de uno o ambos valores, los valores de punto flotante que se espera que sean idénticos suelen ser idénticos debido a las diferencias en sus dígitos menos significativos. Como resultado, las llamadas al método para determinar si dos valores son iguales o las llamadas al método para determinar la relación entre dos valores, a menudo producen Equals CompareTo Double resultados inesperados. Esto es evidente en el ejemplo siguiente, donde dos valores aparentemente iguales no son iguales porque el primero tiene 15 dígitos de precisión, mientras que el segundo tiene Double 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

Module Example
   Public Sub Main()
      Dim value1 As Double = .333333333333333
      Dim value2 As Double = 1/3
      Console.WriteLine("{0:R} = {1:R}: {2}", value1, value2, value1.Equals(value2))
   End Sub
End Module
' The example displays the following output:
'       0.333333333333333 = 0.33333333333333331: False

Los valores calculados que siguen rutas de acceso de código diferentes y que se manipulan de maneras diferentes suelen resultar distintos. En el ejemplo siguiente, un valor tiene un cuadrado y, a continuación, se calcula la raíz cuadrada Double para restaurar el valor original. Un segundo se multiplica por 3,51 y se al cuadrado antes de que la raíz cuadrada del resultado se divida entre Double 3,51 para restaurar el valor original. Aunque los dos valores parecen ser idénticos, una llamada al Equals(Double) método indica que no son iguales. El uso de la cadena de formato estándar "R" para devolver una cadena de resultado que muestra todos los dígitos significativos de cada valor Double muestra que el segundo valor es .0000000000001 menor 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

Module Example
   Public Sub Main()
      Dim value1 As Double = 100.10142
      value1 = Math.Sqrt(Math.Pow(value1, 2))
      Dim value2 As Double = Math.Pow(value1 * 3.51, 2)
      value2 = Math.Sqrt(value2) / 3.51
      Console.WriteLine("{0} = {1}: {2}", 
                        value1, value2, value1.Equals(value2)) 
      Console.WriteLine()
      Console.WriteLine("{0:R} = {1:R}", value1, value2) 
   End Sub
End Module
' The example displays the following output:
'    100.10142 = 100.10142: False
'    
'    100.10142 = 100.10141999999999

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

Llame al Math.Round método para asegurarse de que ambos valores tienen la misma precisión. En el ejemplo siguiente se modifica un ejemplo anterior para usar este enfoque de modo que dos valores fraccionarios sean 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

Module Example
   Public Sub Main()
      Dim value1 As Double = .333333333333333
      Dim value2 As Double = 1/3
      Dim precision As Integer = 7
      value1 = Math.Round(value1, precision)
      value2 = Math.Round(value2, precision)
      Console.WriteLine("{0:R} = {1:R}: {2}", value1, value2, value1.Equals(value2))
   End Sub
End Module
' The example displays the following output:
'       0.3333333 = 0.3333333: True

El problema de precisión se sigue aplicando al redondeo de valores de punto medio. Para obtener más información, vea el método Math.Round(Double, Int32, MidpointRounding).

Pruebe la igualdad aproximada en lugar de la igualdad. Esto requiere que defina una cantidad absoluta por la que los dos valores puedan diferir pero seguir siendo iguales, o que defina una cantidad relativa por la que el valor más pequeño pueda diferir del valor mayor.

Advertencia

Double.Epsilon a veces se usa como medida absoluta de la distancia entre dos Double valores al probar la igualdad. Sin embargo, mide el menor valor posible que se puede agregar o restar de un cuyo Double.Epsilon valor es Double cero. Para la mayoría de los valores Double positivos y negativos, el valor de Double.Epsilon es demasiado pequeño para detectarse. Por lo tanto, a excepción de los valores que son cero, no se recomienda su uso en las pruebas para la igualdad.

En el ejemplo siguiente se usa el último enfoque para definir un IsApproximatelyEqual método que prueba la diferencia relativa entre dos valores. También contrasta el resultado de las llamadas al IsApproximatelyEqual método y al método 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

Module Example
   Public Sub Main()
      Dim one1 As Double = .1 * 10
      Dim one2 As Double = 0
      For ctr As Integer = 1 To 10
         one2 += .1
      Next
      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))   
   End Sub

   Function IsApproximatelyEqual(value1 As Double, value2 As Double, 
                                 epsilon As Double) As Boolean
      ' If they are equal anyway, just return True.
      If value1.Equals(value2) Then Return True
      
      ' Handle NaN, Infinity.
      If Double.IsInfinity(value1) Or Double.IsNaN(value1) Then
         Return value1.Equals(value2)
      Else If Double.IsInfinity(value2) Or Double.IsNaN(value2)
         Return value1.Equals(value2)
      End If
      
      ' Handle zero to avoid division by zero
      Dim divisor As Double = Math.Max(value1, value2)
      If divisor.Equals(0) Then
         divisor = Math.Min(value1, value2)
      End If 
      
      Return Math.Abs((value1 - value2) / divisor) <= epsilon           
   End Function
End Module
' The example displays the following output:
'       1 = 0.99999999999999989: False
'       1 is approximately equal to 0.99999999999999989: True

Floating-Point valores y excepciones

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

Si el resultado de una operación de punto 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 se muestra 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

Module Example
   Public Sub Main()
      Dim value1 As Double = 1.1632875981534209e-225
      Dim value2 As Double = 9.1642346778e-175
      Dim result As Double = value1 * value2
      Console.WriteLine("{0} * {1} = {2}", value1, value2, result)
      Console.WriteLine("{0} = 0: {1}", result, result.Equals(0.0))
   End Sub
End Module
' 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 punto flotante supera el intervalo del formato de destino, el resultado de la operación es o , según corresponda para el signo PositiveInfinity NegativeInfinity del resultado. El resultado de una operación que se desborda es y el resultado de una operación que se desborda es , como se muestra Double.MaxValue PositiveInfinity en el ejemplo Double.MinValue NegativeInfinity 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

Module Example
   Public Sub Main()
      Dim value1 As Double = 4.565e153
      Dim value2 As Double = 6.9375e172
      Dim result As Double = value1 * value2
      Console.WriteLine("PositiveInfinity: {0}", 
                         Double.IsPositiveInfinity(result))
      Console.WriteLine("NegativeInfinity: {0}", 
                        Double.IsNegativeInfinity(result))
      Console.WriteLine()                  
      value1 = -value1
      result = value1 * value2
      Console.WriteLine("PositiveInfinity: {0}", 
                         Double.IsPositiveInfinity(result))
      Console.WriteLine("NegativeInfinity: {0}", 
                        Double.IsNegativeInfinity(result))
   End Sub
End Module
' The example displays the following output:
'       PositiveInfinity: True
'       NegativeInfinity: False
'       
'       PositiveInfinity: False
'       NegativeInfinity: True

PositiveInfinity también es el resultado de una división por cero con un dividendo positivo y de una NegativeInfinity 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 los resultados de las siguientes operaciones:
- División por cero con un dividendo de cero. Tenga en cuenta que otros casos de división por cero tienen como resultado PositiveInfinity o NegativeInfinity .
Cualquier operación de punto flotante con una entrada no válida. Por ejemplo, llamar al método con un valor negativo devuelve , al igual que llamar al método con un valor mayor o menor Math.Sqrt NaN que uno Math.Acos negativo.
Cualquier operación con un argumento cuyo valor es Double.NaN .

Conversiones de tipos y la estructura Double

La estructura no define ningún operador de conversión explícito o implícito; en su lugar, el compilador Double implementa las conversiones.

La conversión del valor de cualquier tipo numérico primitivo en es una conversión de ampliación y, por tanto, no requiere un operador de conversión explícito ni una llamada a un método de conversión a menos que un compilador lo Double requiera explícitamente. Por ejemplo, el compilador de C# requiere un operador de conversión para las conversiones de a , mientras que el Visual Basic Decimal Double no lo hace. En el ejemplo siguiente se convierte el valor mínimo o máximo de otros tipos numéricos primitivos en Double .

using System;

public class Example
{
   public static void Main()
   {
      dynamic[] values = { Byte.MinValue, Byte.MaxValue, Decimal.MinValue,
                           Decimal.MaxValue, Int16.MinValue, Int16.MaxValue,
                           Int32.MinValue, Int32.MaxValue, Int64.MinValue,
                           Int64.MaxValue, SByte.MinValue, SByte.MaxValue,
                           Single.MinValue, Single.MaxValue, UInt16.MinValue,
                           UInt16.MaxValue, UInt32.MinValue, UInt32.MaxValue,
                           UInt64.MinValue, UInt64.MaxValue };
      double dblValue;
      foreach (var value in values) {
         if (value.GetType() == typeof(Decimal))
            dblValue = (Double) value;
         else
            dblValue = value;
         Console.WriteLine("{0} ({1}) --> {2:R} ({3})",
                           value, value.GetType().Name,
                           dblValue, dblValue.GetType().Name);
      }
   }
}
// The example displays the following output:
//    0 (Byte) --> 0 (Double)
//    255 (Byte) --> 255 (Double)
//    -79228162514264337593543950335 (Decimal) --> -7.9228162514264338E+28 (Double)
//    79228162514264337593543950335 (Decimal) --> 7.9228162514264338E+28 (Double)
//    -32768 (Int16) --> -32768 (Double)
//    32767 (Int16) --> 32767 (Double)
//    -2147483648 (Int32) --> -2147483648 (Double)
//    2147483647 (Int32) --> 2147483647 (Double)
//    -9223372036854775808 (Int64) --> -9.2233720368547758E+18 (Double)
//    9223372036854775807 (Int64) --> 9.2233720368547758E+18 (Double)
//    -128 (SByte) --> -128 (Double)
//    127 (SByte) --> 127 (Double)
//    -3.402823E+38 (Single) --> -3.4028234663852886E+38 (Double)
//    3.402823E+38 (Single) --> 3.4028234663852886E+38 (Double)
//    0 (UInt16) --> 0 (Double)
//    65535 (UInt16) --> 65535 (Double)
//    0 (UInt32) --> 0 (Double)
//    4294967295 (UInt32) --> 4294967295 (Double)
//    0 (UInt64) --> 0 (Double)
//    18446744073709551615 (UInt64) --> 1.8446744073709552E+19 (Double)

Module Example
   Public Sub Main()
      Dim values() As Object = { Byte.MinValue, Byte.MaxValue, Decimal.MinValue,
                                 Decimal.MaxValue, Int16.MinValue, Int16.MaxValue,
                                 Int32.MinValue, Int32.MaxValue, Int64.MinValue,
                                 Int64.MaxValue, SByte.MinValue, SByte.MaxValue,
                                 Single.MinValue, Single.MaxValue, UInt16.MinValue,
                                 UInt16.MaxValue, UInt32.MinValue, UInt32.MaxValue,
                                 UInt64.MinValue, UInt64.MaxValue }
      Dim dblValue As Double
      For Each value In values
         dblValue = value
         Console.WriteLine("{0} ({1}) --> {2:R} ({3})",
                           value, value.GetType().Name,
                           dblValue, dblValue.GetType().Name)
      Next
   End Sub
End Module
' The example displays the following output:
'    0 (Byte) --> 0 (Double)
'    255 (Byte) --> 255 (Double)
'    -79228162514264337593543950335 (Decimal) --> -7.9228162514264338E+28 (Double)
'    79228162514264337593543950335 (Decimal) --> 7.9228162514264338E+28 (Double)
'    -32768 (Int16) --> -32768 (Double)
'    32767 (Int16) --> 32767 (Double)
'    -2147483648 (Int32) --> -2147483648 (Double)
'    2147483647 (Int32) --> 2147483647 (Double)
'    -9223372036854775808 (Int64) --> -9.2233720368547758E+18 (Double)
'    9223372036854775807 (Int64) --> 9.2233720368547758E+18 (Double)
'    -128 (SByte) --> -128 (Double)
'    127 (SByte) --> 127 (Double)
'    -3.402823E+38 (Single) --> -3.4028234663852886E+38 (Double)
'    3.402823E+38 (Single) --> 3.4028234663852886E+38 (Double)
'    0 (UInt16) --> 0 (Double)
'    65535 (UInt16) --> 65535 (Double)
'    0 (UInt32) --> 0 (Double)
'    4294967295 (UInt32) --> 4294967295 (Double)
'    0 (UInt64) --> 0 (Double)
'    18446744073709551615 (UInt64) --> 1.8446744073709552E+19 (Double)

Además, los Single valores , y se Single.NaN Single.PositiveInfinity Single.NegativeInfinity convierten en , y , Double.NaN Double.PositiveInfinity Double.NegativeInfinity respectivamente.

Tenga en cuenta que la conversión del valor de algunos tipos numéricos en un Double valor puede implicar una pérdida de precisión. Como se muestra en el ejemplo, es posible una pérdida de precisión al convertir los valores Decimal Int64 , y en UInt64 Double valores.

La conversión de un valor en un valor de cualquier otro tipo de datos numérico primitivo es una conversión de limitación y requiere un operador de conversión (en C#), un método de conversión (en Visual Basic) o una llamada Double a un Convert método. Los valores que están fuera del intervalo del tipo de datos de destino, definidos por las propiedades y del tipo de destino, se comportan como se muestra MinValue MaxValue en la tabla siguiente.

Tipo de destino	Resultado
Cualquier tipo entero	Excepción OverflowException si la conversión se produce en un contexto comprobado. Si la conversión se produce en un contexto no desactivado (el valor predeterminado en C#), la operación de conversión se realiza correctamente, pero el valor se desborda.
Decimal	Excepción OverflowException.
Single	Single.NegativeInfinity para valores negativos. Single.PositiveInfinity para valores positivos.

Además, , y inician un para las conversiones a enteros en un contexto activado, pero estos valores se desbordan cuando se convierten en enteros en un Double.NaN Double.PositiveInfinity contexto no Double.NegativeInfinity OverflowException comprobado. Para las conversiones a Decimal , siempre inician un OverflowException . Para las conversiones a Single , se convierten en Single.NaN , y , Single.PositiveInfinity Single.NegativeInfinity respectivamente.

Tenga en cuenta que una pérdida de precisión puede deberse a la conversión de Double un valor a otro tipo numérico. En el caso de la conversión a cualquiera de los tipos enteros, como se muestra en la salida del ejemplo, el componente fraccionado se pierde cuando el valor se redondea (como en Visual Basic) o se trunca (como en Double C#). Para las conversiones a valores y , es posible Decimal que el valor no tenga una representación precisa en el tipo de datos de Single Double destino.

En el ejemplo siguiente se convierten varios Double valores en otros tipos numéricos. Las conversiones se producen en un contexto comprobado en Visual Basic (valor predeterminado) y en C# (debido a la palabra clave checked). La salida del ejemplo muestra el resultado de las conversiones en un contexto activado y desactivado. Puede realizar conversiones en un contexto no desactivado en Visual Basic compilando con el modificador del compilador y en C# comentando /removeintchecks+ la checked instrucción .

using System;

public class Example
{
   public static void Main()
   {
      Double[] values = { Double.MinValue, -67890.1234, -12345.6789,
                          12345.6789, 67890.1234, Double.MaxValue,
                          Double.NaN, Double.PositiveInfinity,
                          Double.NegativeInfinity };
      checked {
         foreach (var value in values) {
            try {
                Int64 lValue = (long) value;
                Console.WriteLine("{0} ({1}) --> {2} (0x{2:X16}) ({3})",
                                  value, value.GetType().Name,
                                  lValue, lValue.GetType().Name);
            }
            catch (OverflowException) {
               Console.WriteLine("Unable to convert {0} to Int64.", value);
            }
            try {
                UInt64 ulValue = (ulong) value;
                Console.WriteLine("{0} ({1}) --> {2} (0x{2:X16}) ({3})",
                                  value, value.GetType().Name,
                                  ulValue, ulValue.GetType().Name);
            }
            catch (OverflowException) {
               Console.WriteLine("Unable to convert {0} to UInt64.", value);
            }
            try {
                Decimal dValue = (decimal) value;
                Console.WriteLine("{0} ({1}) --> {2} ({3})",
                                  value, value.GetType().Name,
                                  dValue, dValue.GetType().Name);
            }
            catch (OverflowException) {
               Console.WriteLine("Unable to convert {0} to Decimal.", value);
            }
            try {
                Single sValue = (float) value;
                Console.WriteLine("{0} ({1}) --> {2} ({3})",
                                  value, value.GetType().Name,
                                  sValue, sValue.GetType().Name);
            }
            catch (OverflowException) {
               Console.WriteLine("Unable to convert {0} to Single.", value);
            }
            Console.WriteLine();
         }
      }
   }
}
// The example displays the following output for conversions performed
// in a checked context:
//       Unable to convert -1.79769313486232E+308 to Int64.
//       Unable to convert -1.79769313486232E+308 to UInt64.
//       Unable to convert -1.79769313486232E+308 to Decimal.
//       -1.79769313486232E+308 (Double) --> -Infinity (Single)
//
//       -67890.1234 (Double) --> -67890 (0xFFFFFFFFFFFEF6CE) (Int64)
//       Unable to convert -67890.1234 to UInt64.
//       -67890.1234 (Double) --> -67890.1234 (Decimal)
//       -67890.1234 (Double) --> -67890.13 (Single)
//
//       -12345.6789 (Double) --> -12345 (0xFFFFFFFFFFFFCFC7) (Int64)
//       Unable to convert -12345.6789 to UInt64.
//       -12345.6789 (Double) --> -12345.6789 (Decimal)
//       -12345.6789 (Double) --> -12345.68 (Single)
//
//       12345.6789 (Double) --> 12345 (0x0000000000003039) (Int64)
//       12345.6789 (Double) --> 12345 (0x0000000000003039) (UInt64)
//       12345.6789 (Double) --> 12345.6789 (Decimal)
//       12345.6789 (Double) --> 12345.68 (Single)
//
//       67890.1234 (Double) --> 67890 (0x0000000000010932) (Int64)
//       67890.1234 (Double) --> 67890 (0x0000000000010932) (UInt64)
//       67890.1234 (Double) --> 67890.1234 (Decimal)
//       67890.1234 (Double) --> 67890.13 (Single)
//
//       Unable to convert 1.79769313486232E+308 to Int64.
//       Unable to convert 1.79769313486232E+308 to UInt64.
//       Unable to convert 1.79769313486232E+308 to Decimal.
//       1.79769313486232E+308 (Double) --> Infinity (Single)
//
//       Unable to convert NaN to Int64.
//       Unable to convert NaN to UInt64.
//       Unable to convert NaN to Decimal.
//       NaN (Double) --> NaN (Single)
//
//       Unable to convert Infinity to Int64.
//       Unable to convert Infinity to UInt64.
//       Unable to convert Infinity to Decimal.
//       Infinity (Double) --> Infinity (Single)
//
//       Unable to convert -Infinity to Int64.
//       Unable to convert -Infinity to UInt64.
//       Unable to convert -Infinity to Decimal.
//       -Infinity (Double) --> -Infinity (Single)
// The example displays the following output for conversions performed
// in an unchecked context:
//       -1.79769313486232E+308 (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       -1.79769313486232E+308 (Double) --> 9223372036854775808 (0x8000000000000000) (UInt64)
//       Unable to convert -1.79769313486232E+308 to Decimal.
//       -1.79769313486232E+308 (Double) --> -Infinity (Single)
//
//       -67890.1234 (Double) --> -67890 (0xFFFFFFFFFFFEF6CE) (Int64)
//       -67890.1234 (Double) --> 18446744073709483726 (0xFFFFFFFFFFFEF6CE) (UInt64)
//       -67890.1234 (Double) --> -67890.1234 (Decimal)
//       -67890.1234 (Double) --> -67890.13 (Single)
//
//       -12345.6789 (Double) --> -12345 (0xFFFFFFFFFFFFCFC7) (Int64)
//       -12345.6789 (Double) --> 18446744073709539271 (0xFFFFFFFFFFFFCFC7) (UInt64)
//       -12345.6789 (Double) --> -12345.6789 (Decimal)
//       -12345.6789 (Double) --> -12345.68 (Single)
//
//       12345.6789 (Double) --> 12345 (0x0000000000003039) (Int64)
//       12345.6789 (Double) --> 12345 (0x0000000000003039) (UInt64)
//       12345.6789 (Double) --> 12345.6789 (Decimal)
//       12345.6789 (Double) --> 12345.68 (Single)
//
//       67890.1234 (Double) --> 67890 (0x0000000000010932) (Int64)
//       67890.1234 (Double) --> 67890 (0x0000000000010932) (UInt64)
//       67890.1234 (Double) --> 67890.1234 (Decimal)
//       67890.1234 (Double) --> 67890.13 (Single)
//
//       1.79769313486232E+308 (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       1.79769313486232E+308 (Double) --> 0 (0x0000000000000000) (UInt64)
//       Unable to convert 1.79769313486232E+308 to Decimal.
//       1.79769313486232E+308 (Double) --> Infinity (Single)
//
//       NaN (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       NaN (Double) --> 0 (0x0000000000000000) (UInt64)
//       Unable to convert NaN to Decimal.
//       NaN (Double) --> NaN (Single)
//
//       Infinity (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       Infinity (Double) --> 0 (0x0000000000000000) (UInt64)
//       Unable to convert Infinity to Decimal.
//       Infinity (Double) --> Infinity (Single)
//
//       -Infinity (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       -Infinity (Double) --> 9223372036854775808 (0x8000000000000000) (UInt64)
//       Unable to convert -Infinity to Decimal.
//       -Infinity (Double) --> -Infinity (Single)

Module Example
   Public Sub Main()
      Dim values() As Double = { Double.MinValue, -67890.1234, -12345.6789,
                                 12345.6789, 67890.1234, Double.MaxValue,
                                 Double.NaN, Double.PositiveInfinity,
                                 Double.NegativeInfinity }
      For Each value In values
         Try
             Dim lValue As Int64 = CLng(value)
             Console.WriteLine("{0} ({1}) --> {2} (0x{2:X16}) ({3})",
                               value, value.GetType().Name,
                               lValue, lValue.GetType().Name)
         Catch e As OverflowException
            Console.WriteLine("Unable to convert {0} to Int64.", value)
         End Try
         Try
             Dim ulValue As UInt64 = CULng(value)
             Console.WriteLine("{0} ({1}) --> {2} (0x{2:X16}) ({3})",
                               value, value.GetType().Name,
                               ulValue, ulValue.GetType().Name)
         Catch e As OverflowException
            Console.WriteLine("Unable to convert {0} to UInt64.", value)
         End Try
         Try
             Dim dValue As Decimal = CDec(value)
             Console.WriteLine("{0} ({1}) --> {2} ({3})",
                               value, value.GetType().Name,
                               dValue, dValue.GetType().Name)
         Catch e As OverflowException
            Console.WriteLine("Unable to convert {0} to Decimal.", value)
         End Try
         Try
             Dim sValue As Single = CSng(value)
             Console.WriteLine("{0} ({1}) --> {2} ({3})",
                               value, value.GetType().Name,
                               sValue, sValue.GetType().Name)
         Catch e As OverflowException
            Console.WriteLine("Unable to convert {0} to Single.", value)
         End Try
         Console.WriteLine()
      Next
   End Sub
End Module
' The example displays the following output for conversions performed
' in a checked context:
'       Unable to convert -1.79769313486232E+308 to Int64.
'       Unable to convert -1.79769313486232E+308 to UInt64.
'       Unable to convert -1.79769313486232E+308 to Decimal.
'       -1.79769313486232E+308 (Double) --> -Infinity (Single)
'
'       -67890.1234 (Double) --> -67890 (0xFFFFFFFFFFFEF6CE) (Int64)
'       Unable to convert -67890.1234 to UInt64.
'       -67890.1234 (Double) --> -67890.1234 (Decimal)
'       -67890.1234 (Double) --> -67890.13 (Single)
'
'       -12345.6789 (Double) --> -12346 (0xFFFFFFFFFFFFCFC6) (Int64)
'       Unable to convert -12345.6789 to UInt64.
'       -12345.6789 (Double) --> -12345.6789 (Decimal)
'       -12345.6789 (Double) --> -12345.68 (Single)
'
'       12345.6789 (Double) --> 12346 (0x000000000000303A) (Int64)
'       12345.6789 (Double) --> 12346 (0x000000000000303A) (UInt64)
'       12345.6789 (Double) --> 12345.6789 (Decimal)
'       12345.6789 (Double) --> 12345.68 (Single)
'
'       67890.1234 (Double) --> 67890 (0x0000000000010932) (Int64)
'       67890.1234 (Double) --> 67890 (0x0000000000010932) (UInt64)
'       67890.1234 (Double) --> 67890.1234 (Decimal)
'       67890.1234 (Double) --> 67890.13 (Single)
'
'       Unable to convert 1.79769313486232E+308 to Int64.
'       Unable to convert 1.79769313486232E+308 to UInt64.
'       Unable to convert 1.79769313486232E+308 to Decimal.
'       1.79769313486232E+308 (Double) --> Infinity (Single)
'
'       Unable to convert NaN to Int64.
'       Unable to convert NaN to UInt64.
'       Unable to convert NaN to Decimal.
'       NaN (Double) --> NaN (Single)
'
'       Unable to convert Infinity to Int64.
'       Unable to convert Infinity to UInt64.
'       Unable to convert Infinity to Decimal.
'       Infinity (Double) --> Infinity (Single)
'
'       Unable to convert -Infinity to Int64.
'       Unable to convert -Infinity to UInt64.
'       Unable to convert -Infinity to Decimal.
'       -Infinity (Double) --> -Infinity (Single)
' The example displays the following output for conversions performed
' in an unchecked context:
'       -1.79769313486232E+308 (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
'       -1.79769313486232E+308 (Double) --> 9223372036854775808 (0x8000000000000000) (UInt64)
'       Unable to convert -1.79769313486232E+308 to Decimal.
'       -1.79769313486232E+308 (Double) --> -Infinity (Single)
'
'       -67890.1234 (Double) --> -67890 (0xFFFFFFFFFFFEF6CE) (Int64)
'       -67890.1234 (Double) --> 18446744073709483726 (0xFFFFFFFFFFFEF6CE) (UInt64)
'       -67890.1234 (Double) --> -67890.1234 (Decimal)
'       -67890.1234 (Double) --> -67890.13 (Single)
'
'       -12345.6789 (Double) --> -12346 (0xFFFFFFFFFFFFCFC6) (Int64)
'       -12345.6789 (Double) --> 18446744073709539270 (0xFFFFFFFFFFFFCFC6) (UInt64)
'       -12345.6789 (Double) --> -12345.6789 (Decimal)
'       -12345.6789 (Double) --> -12345.68 (Single)
'
'       12345.6789 (Double) --> 12346 (0x000000000000303A) (Int64)
'       12345.6789 (Double) --> 12346 (0x000000000000303A) (UInt64)
'       12345.6789 (Double) --> 12345.6789 (Decimal)
'       12345.6789 (Double) --> 12345.68 (Single)
'
'       67890.1234 (Double) --> 67890 (0x0000000000010932) (Int64)
'       67890.1234 (Double) --> 67890 (0x0000000000010932) (UInt64)
'       67890.1234 (Double) --> 67890.1234 (Decimal)
'       67890.1234 (Double) --> 67890.13 (Single)
'
'       1.79769313486232E+308 (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
'       1.79769313486232E+308 (Double) --> 0 (0x0000000000000000) (UInt64)
'       Unable to convert 1.79769313486232E+308 to Decimal.
'       1.79769313486232E+308 (Double) --> Infinity (Single)
'
'       NaN (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
'       NaN (Double) --> 0 (0x0000000000000000) (UInt64)
'       Unable to convert NaN to Decimal.
'       NaN (Double) --> NaN (Single)
'
'       Infinity (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
'       Infinity (Double) --> 0 (0x0000000000000000) (UInt64)
'       Unable to convert Infinity to Decimal.
'       Infinity (Double) --> Infinity (Single)
'
'       -Infinity (Double) --> -9223372036854775808 (0x8000000000000000) (Int64)
'       -Infinity (Double) --> 9223372036854775808 (0x8000000000000000) (UInt64)
'       Unable to convert -Infinity to Decimal.
'       -Infinity (Double) --> -Infinity (Single)

Para obtener más información sobre la conversión de tipos numéricos, vea Conversión de tipos en las tablas .NET Framework y Conversión de tipos.

Floating-Point funcionalidad

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

Comparación de valores. Puede llamar al método para determinar si dos valores son iguales o el método Equals para determinar la relación entre dos Double CompareTo valores.

La Double estructura 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 , se convierte en un antes Double Double de realizar la comparación.

Advertencia

Debido a las diferencias de precisión, dos valores que espera que sean iguales pueden resultar desiguales, lo que afecta al Double resultado de la comparación. Consulte la sección Pruebas de igualdad para obtener más información sobre cómo comparar dos Double valores.

También puede llamar a los métodos , , y para IsNaN probar estos valores IsInfinity IsPositiveInfinity IsNegativeInfinity especiales.
Operaciones matemáticas. Las operaciones aritméticas comunes, como la suma, resta, multiplicación y división, se implementan mediante compiladores de lenguaje e instrucciones del lenguaje intermedio común (CIL), en lugar de mediante Double métodos. Si uno de los operandos de una operación matemática es un tipo numérico distinto de , se convierte en un antes Double Double de realizar la operación. El resultado de la operación también es un Double valor.

Se pueden realizar otras operaciones matemáticas llamando a static ( Shared en Visual Basic) de la clase System.Math . Incluye métodos adicionales que se usan habitualmente para operaciones aritméticas (como , y ), geometría (como y ) y Math.Abs cálculo Math.Sign Math.Sqrt Math.Cos Math.Sin (como Math.Log ).

También puede manipular los bits individuales de un Double valor. El BitConverter.DoubleToInt64Bits método conserva el patrón de bits de un valor en un entero de Double 64 bits. El BitConverter.GetBytes(Double) método devuelve su patrón de bits en una matriz de bytes.
Redondear. El redondeo se suele usar como técnica para reducir el impacto de las diferencias entre los valores causados por problemas de precisión y representación de punto flotante. Puede redondear Double un valor llamando al método Math.Round .
Aplicar formato a. Puede convertir un valor en Double su representación de cadena llamando al método o usando la característica de formato ToString 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 Cadenas de formato numérico estándar y Cadenas de formato numérico personalizado.
Analizar cadenas. Puede convertir la representación de cadena de un valor de punto flotante en un valor llamando Double al Parse método o TryParse . Si se produce un error en la operación de análisis, Parse el método produce una excepción, mientras que el método devuelve TryParse false .
Conversión de tipos. La estructura proporciona una implementación de interfaz explícita para la interfaz , que admite la conversión entre dos Double tipos de datos .NET Framework IConvertible estándar. Los compiladores de lenguaje también admiten la conversión implícita de valores de todos los demás tipos numéricos estándar en Double valores. La conversión de un valor de cualquier tipo numérico estándar en es una conversión de ampliación y no requiere el usuario de un operador de conversión o Double método de conversión.

Sin embargo, la conversión Int64 de los valores y puede Single implicar una pérdida de precisión. En 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 afecta con mayor frecuencia a Single los valores que se convierten en Double valores. En el ejemplo siguiente, dos valores generados por operaciones de división idénticas no son iguales porque uno de los valores es un valor de punto flotante de precisión sencilla convertido en 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
```
```
Module Example
   Public Sub Main()
      Dim value As Double = .1
      Dim result1 As Double = value * 10
      Dim result2 As Double
      For ctr As Integer = 1 To 10
         result2 += value
      Next
      Console.WriteLine(".1 * 10:           {0:R}", result1)
      Console.WriteLine(".1 Added 10 times: {0:R}", result2)
   End Sub
End Module
' The example displays the following output:
'       .1 * 10:           1
'       .1 Added 10 times: 0.99999999999999989
```

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

Campos

Epsilon	Representa el menor valor Double positivo mayor que cero. Este campo es constante.
MaxValue	Representa el mayor valor posible de un Double. Este campo es constante.
MinValue	Representa el menor valor posible de un Double. Este campo es constante.
NaN	Representa un valor no numérico (`NaN`). Este campo es constante.
NegativeInfinity	Representa infinito negativo. Este campo es constante.
PositiveInfinity	Representa infinito positivo. Este campo es constante.

Métodos

CompareTo(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.
CompareTo(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.
Equals(Double)	Devuelve un valor que indica si esta instancia y un objeto Double especificado representan el mismo valor.
Equals(Object)	Devuelve un valor que indica si esta instancia equivale a un objeto especificado.
GetHashCode()	Devuelve el código hash de esta instancia.
GetTypeCode()	Devuelve el TypeCode para el tipo de valor Double.
IsFinite(Double)	Determina si el valor especificado es limitado (cero, no normal o normal).
IsInfinity(Double)	Devuelve un valor que indica si el número especificado se evalúa como infinito negativo o positivo.
IsNaN(Double)	Devuelve un valor que indica si el valor especificado no es un número (NaN).
IsNegative(Double)	Determina si el valor especificado es negativo.
IsNegativeInfinity(Double)	Devuelve un valor que indica si el número especificado se evalúa como infinito negativo.
IsNormal(Double)	Determina si el valor especificado es normal.
IsPositiveInfinity(Double)	Devuelve un valor que indica si el número especificado se evalúa como infinito positivo.
IsSubnormal(Double)	Determina si el valor especificado no es normal.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Convierte un intervalo de caracteres que contiene la representación en cadena de un número con el estilo y el formato específico de la referencia cultural que se hayan especificado en el número de punto flotante de precisión doble equivalente.
Parse(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.
Parse(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.
Parse(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.
Parse(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.
ToString()	Convierte el valor numérico de esta instancia en la representación de cadena equivalente.
ToString(IFormatProvider)	Convierte el valor numérico de esta instancia en la representación de cadena equivalente usando la información de formato específica de la referencia cultural especificada.
ToString(String)	Convierte el valor numérico de esta instancia en la representación de cadena equivalente usando el formato especificado.
ToString(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 especificaran.
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Intenta dar formato al valor de la instancia doble actual en el intervalo de caracteres proporcionado.
TryParse(ReadOnlySpan<Char>, Double)	Convierte la representación de intervalo de un número con el estilo y el formato específico de la referencia cultural que se hayan especificado 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.
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Double)	Convierte un intervalo de caracteres que contiene la representación en cadena de un número con el estilo y el formato específico de la referencia cultural que se hayan especificado 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.
TryParse(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.
TryParse(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.

Operadores

Equality(Double, Double)	Devuelve un valor que indica si dos valores Double especificados son iguales.
GreaterThan(Double, Double)	Devuelve un valor que indica si un valor Double especificado es mayor que otro valor Double especificado.
GreaterThanOrEqual(Double, Double)	Devuelve un valor que indica si un valor Double especificado es mayor o igual que otro valor Double especificado.
Inequality(Double, Double)	Devuelve un valor que indica si dos valores Double especificados no son iguales.
LessThan(Double, Double)	Devuelve un valor que indica si un valor Double especificado es menor que otro valor Double especificado.
LessThanOrEqual(Double, Double)	Devuelve un valor que indica si un valor Double especificado es menor o igual que otro valor Double especificado.

Implementaciones de interfaz explícitas

IComparable.CompareTo(Object)	Compara 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.
IConvertible.GetTypeCode()	Devuelve el TypeCode para esta instancia.
IConvertible.ToBoolean(IFormatProvider)	Para obtener una descripción de este miembro, vea ToBoolean(IFormatProvider).
IConvertible.ToByte(IFormatProvider)	Para obtener una descripción de este miembro, vea ToByte(IFormatProvider).
IConvertible.ToChar(IFormatProvider)	No se admite esta conversión. Cualquier intento de usar este método produce una excepción InvalidCastException.
IConvertible.ToDateTime(IFormatProvider)	No se admite esta conversión. Cualquier intento de usar este método produce una excepción InvalidCastException.
IConvertible.ToDecimal(IFormatProvider)	Para obtener una descripción de este miembro, vea ToDecimal(IFormatProvider).
IConvertible.ToDouble(IFormatProvider)	Para obtener una descripción de este miembro, vea ToDouble(IFormatProvider).
IConvertible.ToInt16(IFormatProvider)	Para obtener una descripción de este miembro, vea ToInt16(IFormatProvider).
IConvertible.ToInt32(IFormatProvider)	Para obtener una descripción de este miembro, vea ToInt32(IFormatProvider).
IConvertible.ToInt64(IFormatProvider)	Para obtener una descripción de este miembro, vea ToInt64(IFormatProvider).
IConvertible.ToSByte(IFormatProvider)	Para obtener una descripción de este miembro, vea ToSByte(IFormatProvider).
IConvertible.ToSingle(IFormatProvider)	Para obtener una descripción de este miembro, vea ToSingle(IFormatProvider).
IConvertible.ToType(Type, IFormatProvider)	Para obtener una descripción de este miembro, vea ToType(Type, IFormatProvider).
IConvertible.ToUInt16(IFormatProvider)	Para obtener una descripción de este miembro, vea ToUInt16(IFormatProvider).
IConvertible.ToUInt32(IFormatProvider)	Para obtener una descripción de este miembro, vea ToUInt32(IFormatProvider).
IConvertible.ToUInt64(IFormatProvider)	Para obtener una descripción de este miembro, vea ToUInt64(IFormatProvider).

Se aplica a

Seguridad para subprocesos

Todos los miembros de este tipo son seguros para subprocesos. Los miembros que parecen modificar el estado de instancia devuelven realmente 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 debe protegerse mediante un bloqueo para garantizar la seguridad de los subprocesos.