Exportar (0) Imprimir
Expandir todo

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>
/** @attribute SerializableAttribute() */ 
/** @attribute ComVisibleAttribute(true) */ 
public final class Double extends ValueType implements IComparable, IFormattable, 
	IConvertible, IComparable<double>, IEquatable<double>
JScript admite el uso de estructuras, pero no admite la declaración de estructuras nuevas.

El tipo de valor Double representa un número de 64 bits de precisión doble con valores que comprenden desde el negativo 1.79769313486232e308 al positivo 1.79769313486232e308, así como el cero positivo o negativo, PositiveInfinity, NegativeInfinity y un valor no numérico (NaN).

Double satisface la norma IEC 60559:1989 (IEEE 754) para la aritmética de puntos flotantes binarios.

Double proporciona métodos para comparar instancias de este tipo, convertir el valor de una instancia en su representación en forma de cadena y convertir la representación en forma de cadena de un número en una instancia de dicho tipo. Para obtener información acerca de la forma en que los códigos de especificación de formato controlan la representación en forma de cadena de los tipos de valor, vea Información general sobre formatos, Cadenas con formato numérico estándar y Cadenas con formato numérico personalizado.

Uso de los números en punto flotante

Al realizar operaciones binarias, si uno de los operandos corresponde a un tipo Double, se requerirá que el otro operando sea un tipo de entero o un tipo de punto flotante (Double o Single). Antes de realizar la operación, si el otro operando no es Double, se convierte en Double y la operación se realiza utilizando por lo menos el intervalo y la precisión del tipo Double. Si la operación produce un resultado numérico, el tipo del resultado es Double.

Los operadores de punto flotante, incluidos los operadores de asignación, no producen excepciones. En su lugar, en situaciones excepcionales, el resultado de la operación de punto flotante es cero, infinito o elemento no numérico (NaN), tal como se describe a continuación:

  • Si el resultado de una operación de punto flotante es demasiado pequeño para el formato de destino, el resultado de la operación es cero.

  • Si la magnitud del resultado de una operación de punto flotante es demasiado grande para el formato de destino, el resultado de la operación es PositiveInfinity o NegativeInfinity, de la forma adecuada para el signo del resultado.

  • Si una operación de punto flotante no es válida, el resultado de la operación es NaN.

  • Si uno o ambos operandos de una operación de punto flotante son NaN, el resultado de la operación es NaN.

Recuerde que un número en punto flotante sólo se puede aproximar a un número decimal y que su precisión determina el grado de aproximación de ese número en punto flotante a un número decimal. De forma predeterminada, un valor Double contiene 15 dígitos decimales de precisión, si bien internamente se mantiene una precisión máxima de 17 dígitos. La precisión de un número en 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.

  • Una operación matemática o de comparación que utilice un número en punto flotante puede no producir el mismo resultado que el que produciría un número decimal si el número en punto flotante no se aproxima exactamente al número decimal.

  • Es posible que un valor no realice una acción de ida y vuelta si está implicado un número en punto flotante. Se dice que un valor realiza una acción de ida y vuelta cuando una operación convierte un número en punto flotante a otro formato y, después, otra operación inversa vuelve a convertirlo en número en punto flotante, y este último número en punto flotante es igual al número en 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.

Implementaciones de interfaces

Este tipo implementa las interfaces IComparable, IComparable, IFormattable y IConvertible. Utilice la clase Convert para las conversiones en lugar de la implementación de miembro de interfaz explícita de IConvertible de este tipo.

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

/// <summary>
/// Temperature class stores the value as Double
/// and delegates most of the functionality 
/// to the Double implementation.
/// </summary>
public class Temperature : IComparable, IFormattable {
    /// <summary>
    /// IComparable.CompareTo implementation.
    /// </summary>
    public int CompareTo(object obj) {
        if(obj is Temperature) {
            Temperature temp = (Temperature) obj;

            return m_value.CompareTo(temp.m_value);
        }
        
        throw new ArgumentException("object is not a Temperature");    
    }

    /// <summary>
    /// IFormattable.ToString implementation.
    /// </summary>
    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);
    }

    /// <summary>
    /// Parses the temperature from a string in form
    /// [ws][sign]digits['F|'C][ws]
    /// </summary>
    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;
        }
    }
}

Los miembros estáticos públicos (Shared en Visual Basic) de este tipo son seguros para la ejecución de subprocesos. No se garantiza que los miembros de instancias sean seguros para la ejecución de subprocesos.

Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium, Windows Mobile para Pocket PC, Windows Mobile para Smartphone, Windows Server 2003, Windows XP Media Center, Windows XP Professional x64, Windows XP SP2, Windows XP Starter Edition

.NET Framework no admite todas las versiones de cada plataforma. Para obtener una lista de las versiones admitidas, vea Requisitos del sistema.

.NET Framework

Compatible con: 2.0, 1.1, 1.0

.NET Compact Framework

Compatible con: 2.0, 1.0

Adiciones de comunidad

AGREGAR
Mostrar:
© 2015 Microsoft