Exportar (0) Imprimir
Expandir todo
Este artículo se tradujo de forma manual. Mueva el puntero sobre las frases del artículo para ver el texto original.
Traducción
Original
Este tema aún no ha recibido ninguna valoración - Valorar este tema

Double (Estructura)

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

Espacio de nombres:  System
Ensamblado:  mscorlib (en mscorlib.dll)
[SerializableAttribute]
[ComVisibleAttribute(true)]
public struct Double : IComparable, IFormattable, 
	IConvertible, IComparable<double>, IEquatable<double>

El tipo Double expone los siguientes miembros.

  NombreDescripción
Método públicoCompatible con XNA Framework643eft0t.PortableClassLibrary(es-es,VS.100).gifCompareTo(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 menor, igual o mayor que el valor del número de punto flotante de precisión doble especificado.
Método públicoCompatible con XNA FrameworkCompareTo(Object)Compara esta instancia con un objeto especificado y devuelve un entero que indica si el valor de esta instancia es menor, igual o mayor que el valor del objeto especificado.
Método públicoCompatible con XNA Framework643eft0t.PortableClassLibrary(es-es,VS.100).gifEquals(Double)Devuelve un valor que indica si esta instancia y un objeto Double especificado representan el mismo valor.
Método públicoCompatible con XNA Framework643eft0t.PortableClassLibrary(es-es,VS.100).gifEquals(Object)Devuelve un valor que indica si la instancia equivale a un objeto especificado. (Invalida a ValueType.Equals(Object)).
Método protegidoCompatible con XNA Framework643eft0t.PortableClassLibrary(es-es,VS.100).gifFinalize Permite que un objeto intente liberar recursos y realizar otras operaciones de limpieza antes de ser reclamado por la recolección de elementos no utilizados. (Se hereda de Object).
Método públicoCompatible con XNA Framework643eft0t.PortableClassLibrary(es-es,VS.100).gifGetHashCodeDevuelve el código hash de esta instancia. (Invalida a ValueType.GetHashCode()).
Método públicoCompatible con XNA Framework643eft0t.PortableClassLibrary(es-es,VS.100).gifGetType Obtiene el Typede la instancia actual. (Se hereda de Object).
Método públicoCompatible con XNA FrameworkGetTypeCodeDevuelve el TypeCode para el tipo de valor Double.
Método públicoMiembro estáticoCompatible con XNA Framework643eft0t.PortableClassLibrary(es-es,VS.100).gifIsInfinityDevuelve un valor que indica si el número especificado se evalúa como infinito negativo o positivo.
Método públicoMiembro estáticoCompatible con XNA Framework643eft0t.PortableClassLibrary(es-es,VS.100).gifIsNaNDevuelve un valor que indica si el número especificado se evalúa como un valor no numérico (NaN).
Método públicoMiembro estáticoCompatible con XNA Framework643eft0t.PortableClassLibrary(es-es,VS.100).gifIsNegativeInfinityDevuelve un valor que indica si el número especificado se evalúa como infinito negativo.
Método públicoMiembro estáticoCompatible con XNA Framework643eft0t.PortableClassLibrary(es-es,VS.100).gifIsPositiveInfinityDevuelve un valor que indica si el número especificado se evalúa como infinito positivo.
Método protegidoCompatible con XNA Framework643eft0t.PortableClassLibrary(es-es,VS.100).gifMemberwiseClone Crea una copia superficial del Object actual. (Se hereda de Object).
Método públicoMiembro estáticoCompatible con XNA FrameworkParse(String)Convierte la representación en forma de cadena de un número en el número de punto flotante de precisión doble equivalente.
Método públicoMiembro estáticoCompatible con XNA FrameworkParse(String, NumberStyles)Convierte la representación en forma de cadena de un número con un estilo especificado en el número de punto flotante de precisión doble equivalente.
Método públicoMiembro estáticoCompatible con XNA Framework643eft0t.PortableClassLibrary(es-es,VS.100).gifParse(String, IFormatProvider)Convierte la representación en forma de cadena de un número con un formato específico de la referencia cultural especificado en el número de punto flotante de precisión doble equivalente.
Método públicoMiembro estáticoCompatible con XNA Framework643eft0t.PortableClassLibrary(es-es,VS.100).gifParse(String, NumberStyles, IFormatProvider)Convierte la representación en forma de cadena de un número con un estilo y un formato específico de la referencia cultural especificados en el número de punto flotante de precisión doble equivalente.
Método públicoCompatible con XNA Framework643eft0t.PortableClassLibrary(es-es,VS.100).gifToString()Convierte el valor numérico de esta instancia en la representación de cadena equivalente. (Invalida a ValueType.ToString()).
Método públicoCompatible con XNA Framework643eft0t.PortableClassLibrary(es-es,VS.100).gifToString(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 indicada.
Método públicoCompatible con XNA FrameworkToString(String)Convierte el valor numérico de esta instancia en la representación de cadena equivalente utilizando el formato especificado.
Método públicoCompatible con XNA Framework643eft0t.PortableClassLibrary(es-es,VS.100).gifToString(String, IFormatProvider)Convierte el valor numérico de esta instancia en la representación de cadena equivalente, usando el formato y la información de formato específica de la referencia cultural indicados.
Método públicoMiembro estáticoTryParse(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 tuvo éxito o no.
Método públicoMiembro estático643eft0t.PortableClassLibrary(es-es,VS.100).gifTryParse(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 tuvo éxito o no.
Arriba
  NombreDescripción
Operador públicoMiembro estáticoEqualityDevuelve un valor que indica si dos valores Double especificados son iguales.
Operador públicoMiembro estáticoGreaterThanDevuelve un valor que indica si un valor Double especificado es mayor que otro valor Double especificado.
Operador públicoMiembro estáticoGreaterThanOrEqualDevuelve un valor que indica si un valor Double especificado es mayor o igual que otro valor Double especificado.
Operador públicoMiembro estáticoInequalityDevuelve un valor que indica si dos valores Double especificados no son iguales.
Operador públicoMiembro estáticoLessThanDevuelve un valor que indica si un valor Double especificado es menor que otro valor Double especificado.
Operador públicoMiembro estáticoLessThanOrEqualDevuelve un valor que indica si un valor Double especificado es menor o igual que otro valor Double especificado.
Arriba
  NombreDescripción
Campo públicoMiembro estáticoCompatible con XNA Framework643eft0t.PortableClassLibrary(es-es,VS.100).gifEpsilonRepresenta el menor valor Double positivo mayor que cero. Este campo es constante.
Campo públicoMiembro estáticoCompatible con XNA Framework643eft0t.PortableClassLibrary(es-es,VS.100).gifMaxValueRepresenta el mayor valor posible de un objeto Double. Este campo es constante.
Campo públicoMiembro estáticoCompatible con XNA Framework643eft0t.PortableClassLibrary(es-es,VS.100).gifMinValueRepresenta el menor valor posible de Double. Este campo es constante.
Campo públicoMiembro estáticoCompatible con XNA Framework643eft0t.PortableClassLibrary(es-es,VS.100).gifNaNRepresenta un valor no numérico (NaN). Este campo es constante.
Campo públicoMiembro estáticoCompatible con XNA Framework643eft0t.PortableClassLibrary(es-es,VS.100).gifNegativeInfinityRepresenta infinito negativo. Este campo es constante.
Campo públicoMiembro estáticoCompatible con XNA Framework643eft0t.PortableClassLibrary(es-es,VS.100).gifPositiveInfinityRepresenta infinito positivo. Este campo es constante.
Arriba
  NombreDescripción
Implementación explícita de interfacesMétodo privadoCompatible con XNA FrameworkIConvertible.ToBooleanInfraestructura. Para obtener una descripción de este miembro, vea IConvertible.ToBoolean.
Implementación explícita de interfacesMétodo privadoCompatible con XNA FrameworkIConvertible.ToByteInfraestructura. Para obtener una descripción de este miembro, vea IConvertible.ToByte.
Implementación explícita de interfacesMétodo privadoCompatible con XNA FrameworkIConvertible.ToCharInfraestructura. No se admite esta conversión. Cualquier intento de utilizar este método produce una excepción InvalidCastException.
Implementación explícita de interfacesMétodo privadoCompatible con XNA FrameworkIConvertible.ToDateTimeInfraestructura. No se admite esta conversión. Cualquier intento de utilizar este método produce una excepción InvalidCastException.
Implementación explícita de interfacesMétodo privadoCompatible con XNA FrameworkIConvertible.ToDecimalInfraestructura. Para obtener una descripción de este miembro, vea IConvertible.ToDecimal.
Implementación explícita de interfacesMétodo privadoCompatible con XNA FrameworkIConvertible.ToDoubleInfraestructura. Para obtener una descripción de este miembro, vea IConvertible.ToDouble.
Implementación explícita de interfacesMétodo privadoCompatible con XNA FrameworkIConvertible.ToInt16Infraestructura. Para obtener una descripción de este miembro, vea IConvertible.ToInt16.
Implementación explícita de interfacesMétodo privadoCompatible con XNA FrameworkIConvertible.ToInt32Infraestructura. Para obtener una descripción de este miembro, vea IConvertible.ToInt32.
Implementación explícita de interfacesMétodo privadoCompatible con XNA FrameworkIConvertible.ToInt64Infraestructura. Para obtener una descripción de este miembro, vea IConvertible.ToInt64.
Implementación explícita de interfacesMétodo privadoCompatible con XNA FrameworkIConvertible.ToSByteInfraestructura. Para obtener una descripción de este miembro, vea IConvertible.ToSByte.
Implementación explícita de interfacesMétodo privadoCompatible con XNA FrameworkIConvertible.ToSingleInfraestructura. Para obtener una descripción de este miembro, vea IConvertible.ToSingle.
Implementación explícita de interfacesMétodo privadoCompatible con XNA FrameworkIConvertible.ToTypeInfraestructura. Para obtener una descripción de este miembro, vea IConvertible.ToType.
Implementación explícita de interfacesMétodo privadoCompatible con XNA FrameworkIConvertible.ToUInt16Infraestructura. Para obtener una descripción de este miembro, vea IConvertible.ToUInt16.
Implementación explícita de interfacesMétodo privadoCompatible con XNA FrameworkIConvertible.ToUInt32Infraestructura. Para obtener una descripción de este miembro, vea IConvertible.ToUInt32.
Implementación explícita de interfacesMétodo privadoCompatible con XNA FrameworkIConvertible.ToUInt64Infraestructura. Para obtener una descripción de este miembro, vea IConvertible.ToUInt64.
Arriba

El tipo de valor 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 Aplicar formato a tipos, 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.

Valores de coma flotante y pérdida de precisión

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.

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


double value = -4.42330604244772E-305;

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

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


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


.NET Framework

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

.NET Framework Client Profile

Compatible con: 4, 3.5 SP1

Compatible con:

Windows 7, Windows Vista SP1 o posterior, Windows XP SP3, Windows XP SP2 x64 Edition, Windows Server 2008 (no se admite Server Core), Windows Server 2008 R2 (se admite Server Core con SP1 o posterior), Windows Server 2003 SP2

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

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

Nota de precauciónPrecaución

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

¿Te ha resultado útil?
(Caracteres restantes: 1500)
Gracias por sus comentarios

Adiciones de comunidad

AGREGAR
Mostrar:
© 2014 Microsoft. Reservados todos los derechos.