Exportar (0) Imprimir
Expandir todo

Double (Estructura)

Actualización: noviembre 2007

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<T>, 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;
			}
		}
	}


/// <summary>
/// Temperature class stores the value as Double
/// and delegates most of the functionality 
/// to the Double implementation.
/// </summary>
public class Temperature implements  IComparable,IFormattable
{
    /// <summary>
    /// IComparable.CompareTo implementation.
    /// </summary>
    public int CompareTo(Object obj)
    {
        if (obj instanceof Temperature) {
            Temperature temp = ((Temperature)(obj));
            return ((System.Double)mvalue).CompareTo(temp.mvalue);
        }
        throw new ArgumentException("object is not a Temperature");
    } //CompareTo

    /// <summary>
    /// IFormattable.ToString implementation.
    /// </summary>
    public String ToString(String format, IFormatProvider provider)
    {
        if (format != null) {
            if (format.Equals("F")) {
                return String.Format("{0}'F", 
                    System.Convert.ToString(this.get_Value()));
            }
            if (format.Equals("C")) {
                return String.Format("{0}'C", 
                    System.Convert.ToString(this.get_Celsius()));
            }
        }
        return ((System.Double)mvalue).ToString(format, provider);
    } //ToString

    /// <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.set_Value(System.Double.Parse(s.Remove(s.LastIndexOf('\''), 2),
                styles, provider));
        }
        else {
            if (s.TrimEnd(null).EndsWith("'C")) {
                temp.set_Celsius(System.Double.Parse(s.
                    Remove(s.LastIndexOf('\''), 2), styles, provider));
            }
            else {
                temp.set_Value(System.Double.Parse(s, styles, provider));
            }
        }
        return temp;
    } //Parse

    // The value holder
    protected double mvalue;

    /** @property
     */
    public double get_Value()
    {
        return mvalue;
	}//get_Value

	/** @property
     */
    public void set_Value(double value)
    {
        mvalue = value;
	}//set_Value

	/** @property 
     */
    public double get_Celsius()
    {
        return (mvalue - 32.0) / 1.8;
	}//get_Celsius

	/** @property 
     */
    public void set_Celsius(double value)
    {
        mvalue = 1.8 * value + 32.0;
	}//set_Celsius
} //Temperature


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

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

		/// <summary>
		/// IFormattable.ToString implementation.
		/// </summary>
		public function ToString(format : String, provider : IFormatProvider) : String {
			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 function Parse(s : String, styles : NumberStyles, provider : IFormatProvider) : Temperature{
			var temp : Temperature = 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 var m_value : double;

		public function get Value() : double{
			return m_value;
		}
		
                public function set Value(value : double) {
			m_value = value;
		}

		public function get Celsius() : double {
			return (m_value-32.0)/1.8;
                }

                public function set Celsius(value : double) {
			m_value = 1.8*value+32.0;
		}
	}


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.

643eft0t.alert_caution(es-es,VS.90).gifPrecaució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.

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

.NET Framework y .NET Compact Framework no admiten todas las versiones de cada plataforma. Para obtener una lista de las versiones compatibles, vea Requisitos de sistema de .NET Framework.

.NET Framework

Compatible con: 3.5, 3.0, 2.0, 1.1, 1.0

.NET Compact Framework

Compatible con: 3.5, 2.0, 1.0

XNA Framework

Compatible con: 2.0, 1.0

Adiciones de comunidad

AGREGAR
Mostrar:
© 2015 Microsoft