Double Estructura
Definición
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>, IFormattablepublic value class double : IComparable<double>, IConvertible, IEquatable<double>, IParsable<double>, ISpanParsable<double>, IUtf8SpanParsable<double>, System::Numerics::IAdditionOperators<double, double, double>, System::Numerics::IAdditiveIdentity<double, double>, System::Numerics::IBinaryFloatingPointIeee754<double>, System::Numerics::IBinaryNumber<double>, System::Numerics::IBitwiseOperators<double, double, double>, System::Numerics::IComparisonOperators<double, double, bool>, System::Numerics::IDecrementOperators<double>, System::Numerics::IDivisionOperators<double, double, double>, System::Numerics::IEqualityOperators<double, double, bool>, System::Numerics::IExponentialFunctions<double>, System::Numerics::IFloatingPoint<double>, System::Numerics::IFloatingPointConstants<double>, System::Numerics::IFloatingPointIeee754<double>, System::Numerics::IHyperbolicFunctions<double>, System::Numerics::IIncrementOperators<double>, System::Numerics::ILogarithmicFunctions<double>, System::Numerics::IMinMaxValue<double>, System::Numerics::IModulusOperators<double, double, double>, System::Numerics::IMultiplicativeIdentity<double, double>, System::Numerics::IMultiplyOperators<double, double, double>, System::Numerics::INumber<double>, System::Numerics::INumberBase<double>, System::Numerics::IPowerFunctions<double>, System::Numerics::IRootFunctions<double>, System::Numerics::ISignedNumber<double>, System::Numerics::ISubtractionOperators<double, double, double>, System::Numerics::ITrigonometricFunctions<double>, System::Numerics::IUnaryNegationOperators<double, double>, System::Numerics::IUnaryPlusOperators<double, double>public value class double : IComparable, IComparable<double>, IConvertible, IEquatable<double>, ISpanFormattablepublic value class double : IComparable<double>, IConvertible, IEquatable<double>, IParsable<double>, ISpanParsable<double>, System::Numerics::IAdditionOperators<double, double, double>, System::Numerics::IAdditiveIdentity<double, double>, System::Numerics::IBinaryFloatingPointIeee754<double>, System::Numerics::IBinaryNumber<double>, System::Numerics::IBitwiseOperators<double, double, double>, System::Numerics::IComparisonOperators<double, double, bool>, System::Numerics::IDecrementOperators<double>, System::Numerics::IDivisionOperators<double, double, double>, System::Numerics::IEqualityOperators<double, double, bool>, System::Numerics::IExponentialFunctions<double>, System::Numerics::IFloatingPoint<double>, System::Numerics::IFloatingPointConstants<double>, System::Numerics::IFloatingPointIeee754<double>, System::Numerics::IHyperbolicFunctions<double>, System::Numerics::IIncrementOperators<double>, System::Numerics::ILogarithmicFunctions<double>, System::Numerics::IMinMaxValue<double>, System::Numerics::IModulusOperators<double, double, double>, System::Numerics::IMultiplicativeIdentity<double, double>, System::Numerics::IMultiplyOperators<double, double, double>, System::Numerics::INumber<double>, System::Numerics::INumberBase<double>, System::Numerics::IPowerFunctions<double>, System::Numerics::IRootFunctions<double>, System::Numerics::ISignedNumber<double>, System::Numerics::ISubtractionOperators<double, double, double>, System::Numerics::ITrigonometricFunctions<double>, System::Numerics::IUnaryNegationOperators<double, double>, System::Numerics::IUnaryPlusOperators<double, double>public value class double : IComparable, IConvertible, IFormattablepublic value class double : IComparable, IComparable<double>, IEquatable<double>, IFormattablepublic struct Double : IComparable, IComparable<double>, IConvertible, IEquatable<double>, IFormattablepublic readonly struct Double : IComparable<double>, IConvertible, IEquatable<double>, IParsable<double>, ISpanParsable<double>, IUtf8SpanParsable<double>, System.Numerics.IAdditionOperators<double,double,double>, System.Numerics.IAdditiveIdentity<double,double>, System.Numerics.IBinaryFloatingPointIeee754<double>, System.Numerics.IBinaryNumber<double>, System.Numerics.IBitwiseOperators<double,double,double>, System.Numerics.IComparisonOperators<double,double,bool>, System.Numerics.IDecrementOperators<double>, System.Numerics.IDivisionOperators<double,double,double>, System.Numerics.IEqualityOperators<double,double,bool>, System.Numerics.IExponentialFunctions<double>, System.Numerics.IFloatingPoint<double>, System.Numerics.IFloatingPointConstants<double>, System.Numerics.IFloatingPointIeee754<double>, System.Numerics.IHyperbolicFunctions<double>, System.Numerics.IIncrementOperators<double>, System.Numerics.ILogarithmicFunctions<double>, System.Numerics.IMinMaxValue<double>, System.Numerics.IModulusOperators<double,double,double>, System.Numerics.IMultiplicativeIdentity<double,double>, System.Numerics.IMultiplyOperators<double,double,double>, System.Numerics.INumber<double>, System.Numerics.INumberBase<double>, System.Numerics.IPowerFunctions<double>, System.Numerics.IRootFunctions<double>, System.Numerics.ISignedNumber<double>, System.Numerics.ISubtractionOperators<double,double,double>, System.Numerics.ITrigonometricFunctions<double>, System.Numerics.IUnaryNegationOperators<double,double>, System.Numerics.IUnaryPlusOperators<double,double>public readonly struct Double : IComparable, IComparable<double>, IConvertible, IEquatable<double>, IFormattablepublic readonly struct Double : IComparable, IComparable<double>, IConvertible, IEquatable<double>, ISpanFormattablepublic readonly struct Double : IComparable<double>, IConvertible, IEquatable<double>, IParsable<double>, ISpanParsable<double>, System.Numerics.IAdditionOperators<double,double,double>, System.Numerics.IAdditiveIdentity<double,double>, System.Numerics.IBinaryFloatingPointIeee754<double>, System.Numerics.IBinaryNumber<double>, System.Numerics.IBitwiseOperators<double,double,double>, System.Numerics.IComparisonOperators<double,double,bool>, System.Numerics.IDecrementOperators<double>, System.Numerics.IDivisionOperators<double,double,double>, System.Numerics.IEqualityOperators<double,double,bool>, System.Numerics.IExponentialFunctions<double>, System.Numerics.IFloatingPoint<double>, System.Numerics.IFloatingPointConstants<double>, System.Numerics.IFloatingPointIeee754<double>, System.Numerics.IHyperbolicFunctions<double>, System.Numerics.IIncrementOperators<double>, System.Numerics.ILogarithmicFunctions<double>, System.Numerics.IMinMaxValue<double>, System.Numerics.IModulusOperators<double,double,double>, System.Numerics.IMultiplicativeIdentity<double,double>, System.Numerics.IMultiplyOperators<double,double,double>, System.Numerics.INumber<double>, System.Numerics.INumberBase<double>, System.Numerics.IPowerFunctions<double>, System.Numerics.IRootFunctions<double>, System.Numerics.ISignedNumber<double>, System.Numerics.ISubtractionOperators<double,double,double>, System.Numerics.ITrigonometricFunctions<double>, System.Numerics.IUnaryNegationOperators<double,double>, System.Numerics.IUnaryPlusOperators<double,double>[System.Serializable]
public struct Double : IComparable, IConvertible, IFormattable[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public struct Double : IComparable, IComparable<double>, IConvertible, IEquatable<double>, IFormattablepublic struct Double : IComparable, IComparable<double>, IEquatable<double>, IFormattabletype double = struct
interface IConvertible
interface IFormattabletype double = struct
interface IConvertible
interface IFormattable
interface IParsable<double>
interface ISpanFormattable
interface ISpanParsable<double>
interface IUtf8SpanFormattable
interface IUtf8SpanParsable<double>
interface IAdditionOperators<double, double, double>
interface IAdditiveIdentity<double, double>
interface IBinaryFloatingPointIeee754<double>
interface IBinaryNumber<double>
interface IBitwiseOperators<double, double, double>
interface IComparisonOperators<double, double, bool>
interface IEqualityOperators<double, double, bool>
interface IDecrementOperators<double>
interface IDivisionOperators<double, double, double>
interface IIncrementOperators<double>
interface IModulusOperators<double, double, double>
interface IMultiplicativeIdentity<double, double>
interface IMultiplyOperators<double, double, double>
interface INumber<double>
interface INumberBase<double>
interface ISubtractionOperators<double, double, double>
interface IUnaryNegationOperators<double, double>
interface IUnaryPlusOperators<double, double>
interface IExponentialFunctions<double>
interface IFloatingPointConstants<double>
interface IFloatingPoint<double>
interface ISignedNumber<double>
interface IFloatingPointIeee754<double>
interface IHyperbolicFunctions<double>
interface ILogarithmicFunctions<double>
interface IPowerFunctions<double>
interface IRootFunctions<double>
interface ITrigonometricFunctions<double>
interface IMinMaxValue<double>type double = struct
interface IConvertible
interface ISpanFormattable
interface IFormattabletype double = struct
interface IConvertible
interface IFormattable
interface IParsable<double>
interface ISpanFormattable
interface ISpanParsable<double>
interface IAdditionOperators<double, double, double>
interface IAdditiveIdentity<double, double>
interface IBinaryFloatingPointIeee754<double>
interface IBinaryNumber<double>
interface IBitwiseOperators<double, double, double>
interface IComparisonOperators<double, double, bool>
interface IEqualityOperators<double, double, bool>
interface IDecrementOperators<double>
interface IDivisionOperators<double, double, double>
interface IIncrementOperators<double>
interface IModulusOperators<double, double, double>
interface IMultiplicativeIdentity<double, double>
interface IMultiplyOperators<double, double, double>
interface INumber<double>
interface INumberBase<double>
interface ISubtractionOperators<double, double, double>
interface IUnaryNegationOperators<double, double>
interface IUnaryPlusOperators<double, double>
interface IExponentialFunctions<double>
interface IFloatingPointConstants<double>
interface IFloatingPoint<double>
interface ISignedNumber<double>
interface IFloatingPointIeee754<double>
interface IHyperbolicFunctions<double>
interface ILogarithmicFunctions<double>
interface IPowerFunctions<double>
interface IRootFunctions<double>
interface ITrigonometricFunctions<double>
interface IMinMaxValue<double>type double = struct
interface IConvertible
interface IFormattable
interface IParsable<double>
interface ISpanFormattable
interface ISpanParsable<double>
interface IAdditionOperators<double, double, double>
interface IAdditiveIdentity<double, double>
interface IBinaryFloatingPointIeee754<double>
interface IBinaryNumber<double>
interface IBitwiseOperators<double, double, double>
interface IComparisonOperators<double, double, bool>
interface IEqualityOperators<double, double, bool>
interface IDecrementOperators<double>
interface IDivisionOperators<double, double, double>
interface IIncrementOperators<double>
interface IModulusOperators<double, double, double>
interface IMultiplicativeIdentity<double, double>
interface IMultiplyOperators<double, double, double>
interface INumber<double>
interface INumberBase<double>
interface ISubtractionOperators<double, double, double>
interface IUnaryNegationOperators<double, double>
interface IUnaryPlusOperators<double, double>
interface IUtf8SpanFormattable
interface IUtf8SpanParsable<double>
interface IExponentialFunctions<double>
interface IFloatingPointConstants<double>
interface IFloatingPoint<double>
interface ISignedNumber<double>
interface IFloatingPointIeee754<double>
interface IHyperbolicFunctions<double>
interface ILogarithmicFunctions<double>
interface IPowerFunctions<double>
interface IRootFunctions<double>
interface ITrigonometricFunctions<double>
interface IMinMaxValue<double>[<System.Serializable>]
type double = struct
interface IFormattable
interface IConvertible[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type double = struct
interface IFormattable
interface IConvertibletype double = struct
interface IFormattablePublic Structure Double
Implements IComparable, IComparable(Of Double), IConvertible, IEquatable(Of Double), IFormattablePublic Structure Double
Implements IAdditionOperators(Of Double, Double, Double), IAdditiveIdentity(Of Double, Double), IBinaryFloatingPointIeee754(Of Double), IBinaryNumber(Of Double), IBitwiseOperators(Of Double, Double, Double), IComparable(Of Double), IComparisonOperators(Of Double, Double, Boolean), IConvertible, IDecrementOperators(Of Double), IDivisionOperators(Of Double, Double, Double), IEqualityOperators(Of Double, Double, Boolean), IEquatable(Of Double), IExponentialFunctions(Of Double), IFloatingPoint(Of Double), IFloatingPointConstants(Of Double), IFloatingPointIeee754(Of Double), IHyperbolicFunctions(Of Double), IIncrementOperators(Of Double), ILogarithmicFunctions(Of Double), IMinMaxValue(Of Double), IModulusOperators(Of Double, Double, Double), IMultiplicativeIdentity(Of Double, Double), IMultiplyOperators(Of Double, Double, Double), INumber(Of Double), INumberBase(Of Double), IParsable(Of Double), IPowerFunctions(Of Double), IRootFunctions(Of Double), ISignedNumber(Of Double), ISpanParsable(Of Double), ISubtractionOperators(Of Double, Double, Double), ITrigonometricFunctions(Of Double), IUnaryNegationOperators(Of Double, Double), IUnaryPlusOperators(Of Double, Double), IUtf8SpanParsable(Of Double)Public Structure Double
Implements IComparable, IComparable(Of Double), IConvertible, IEquatable(Of Double), ISpanFormattablePublic Structure Double
Implements IAdditionOperators(Of Double, Double, Double), IAdditiveIdentity(Of Double, Double), IBinaryFloatingPointIeee754(Of Double), IBinaryNumber(Of Double), IBitwiseOperators(Of Double, Double, Double), IComparable(Of Double), IComparisonOperators(Of Double, Double, Boolean), IConvertible, IDecrementOperators(Of Double), IDivisionOperators(Of Double, Double, Double), IEqualityOperators(Of Double, Double, Boolean), IEquatable(Of Double), IExponentialFunctions(Of Double), IFloatingPoint(Of Double), IFloatingPointConstants(Of Double), IFloatingPointIeee754(Of Double), IHyperbolicFunctions(Of Double), IIncrementOperators(Of Double), ILogarithmicFunctions(Of Double), IMinMaxValue(Of Double), IModulusOperators(Of Double, Double, Double), IMultiplicativeIdentity(Of Double, Double), IMultiplyOperators(Of Double, Double, Double), INumber(Of Double), INumberBase(Of Double), IParsable(Of Double), IPowerFunctions(Of Double), IRootFunctions(Of Double), ISignedNumber(Of Double), ISpanParsable(Of Double), ISubtractionOperators(Of Double, Double, Double), ITrigonometricFunctions(Of Double), IUnaryNegationOperators(Of Double, Double), IUnaryPlusOperators(Of Double, Double)Public Structure Double
Implements IComparable, IConvertible, IFormattablePublic Structure Double
Implements IComparable, IComparable(Of Double), IEquatable(Of Double), IFormattable- Herencia
- Atributos
- Implementaciones
-
IComparable IComparable<Double> IConvertible IEquatable<Double> IFormattable IComparable<TSelf> IEquatable<TSelf> IParsable<Double> IParsable<TSelf> ISpanFormattable ISpanParsable<Double> ISpanParsable<TSelf> IUtf8SpanFormattable IUtf8SpanParsable<Double> IUtf8SpanParsable<TSelf> IAdditionOperators<Double,Double,Double> IAdditionOperators<TSelf,TSelf,TSelf> IAdditiveIdentity<Double,Double> IAdditiveIdentity<TSelf,TSelf> IBinaryFloatingPointIeee754<Double> IBinaryNumber<Double> IBinaryNumber<TSelf> IBitwiseOperators<Double,Double,Double> IBitwiseOperators<TSelf,TSelf,TSelf> IComparisonOperators<Double,Double,Boolean> IComparisonOperators<TSelf,TSelf,Boolean> IDecrementOperators<Double> IDecrementOperators<TSelf> IDivisionOperators<Double,Double,Double> IDivisionOperators<TSelf,TSelf,TSelf> IEqualityOperators<Double,Double,Boolean> IEqualityOperators<TSelf,TOther,TResult> IEqualityOperators<TSelf,TSelf,Boolean> IExponentialFunctions<Double> IExponentialFunctions<TSelf> IFloatingPoint<Double> IFloatingPoint<TSelf> IFloatingPointConstants<Double> IFloatingPointConstants<TSelf> IFloatingPointIeee754<Double> IFloatingPointIeee754<TSelf> IHyperbolicFunctions<Double> IHyperbolicFunctions<TSelf> IIncrementOperators<Double> IIncrementOperators<TSelf> ILogarithmicFunctions<Double> ILogarithmicFunctions<TSelf> IMinMaxValue<Double> IModulusOperators<Double,Double,Double> IModulusOperators<TSelf,TSelf,TSelf> IMultiplicativeIdentity<Double,Double> IMultiplicativeIdentity<TSelf,TSelf> IMultiplyOperators<Double,Double,Double> IMultiplyOperators<TSelf,TSelf,TSelf> INumber<Double> INumber<TSelf> INumberBase<Double> INumberBase<TSelf> IPowerFunctions<Double> IPowerFunctions<TSelf> IRootFunctions<Double> IRootFunctions<TSelf> ISignedNumber<Double> ISignedNumber<TSelf> ISubtractionOperators<Double,Double,Double> ISubtractionOperators<TSelf,TSelf,TSelf> ITrigonometricFunctions<Double> ITrigonometricFunctions<TSelf> IUnaryNegationOperators<Double,Double> IUnaryNegationOperators<TSelf,TSelf> IUnaryPlusOperators<Double,Double> IUnaryPlusOperators<TSelf,TSelf>
Ejemplos
En el siguiente ejemplo de código, se muestra el uso de Double:
// The Temperature class stores the temperature as a Double
// and delegates most of the functionality to the Double
// implementation.
public class Temperature : IComparable, IFormattable
{
// IComparable.CompareTo implementation.
public int CompareTo(object obj) {
if (obj == null) return 1;
Temperature temp = obj as Temperature;
if (obj != null)
return m_value.CompareTo(temp.m_value);
else
throw new ArgumentException("object is not a Temperature");
}
// IFormattable.ToString implementation.
public string ToString(string format, IFormatProvider provider) {
if( format != null ) {
if( format.Equals("F") ) {
return String.Format("{0}'F", this.Value.ToString());
}
if( format.Equals("C") ) {
return String.Format("{0}'C", this.Celsius.ToString());
}
}
return m_value.ToString(format, provider);
}
// Parses the temperature from a string in the form
// [ws][sign]digits['F|'C][ws]
public static Temperature Parse(string s, NumberStyles styles, IFormatProvider provider) {
Temperature temp = new Temperature();
if( s.TrimEnd(null).EndsWith("'F") ) {
temp.Value = Double.Parse( s.Remove(s.LastIndexOf('\''), 2), styles, provider);
}
else if( s.TrimEnd(null).EndsWith("'C") ) {
temp.Celsius = Double.Parse( s.Remove(s.LastIndexOf('\''), 2), styles, provider);
}
else {
temp.Value = Double.Parse(s, styles, provider);
}
return temp;
}
// The value holder
protected double m_value;
public double Value {
get {
return m_value;
}
set {
m_value = value;
}
}
public double Celsius {
get {
return (m_value-32.0)/1.8;
}
set {
m_value = 1.8*value+32.0;
}
}
}
// The Temperature class stores the temperature as a Double
// and delegates most of the functionality to the Double
// implementation.
type Temperature() =
member val Value = 0. with get, set
member this.Celsius
with get () = (this.Value - 32.) / 1.8
and set (value) =
this.Value <- 1.8 * value + 32.
// Parses the temperature from a string in the form
// [ws][sign]digits['F|'C][ws]
static member Parse(s: string, styles: NumberStyles, provider: IFormatProvider) =
let temp = Temperature()
if s.TrimEnd(null).EndsWith "'F" then
temp.Value <- Double.Parse(s.Remove(s.LastIndexOf '\'', 2), styles, provider)
elif s.TrimEnd(null).EndsWith "'C" then
temp.Celsius <- Double.Parse(s.Remove(s.LastIndexOf '\'', 2), styles, provider)
else
temp.Value <- Double.Parse(s, styles, provider)
temp
interface IComparable with
// IComparable.CompareTo implementation.
member this.CompareTo(obj: obj) =
match obj with
| null -> 1
| :? Temperature as temp ->
this.Value.CompareTo temp.Value
| _ ->
invalidArg "obj" "object is not a Temperature"
interface IFormattable with
// IFormattable.ToString implementation.
member this.ToString(format: string, provider: IFormatProvider) =
match format with
| "F" ->
$"{this.Value}'F"
| "C" ->
$"{this.Celsius}'C"
| _ ->
this.Value.ToString(format, provider)
' 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().EndsWith("'F") Then
temp.Value = Double.Parse(s.Remove(s.LastIndexOf("'"c), 2), styles, provider)
Else
If s.TrimEnd().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 Double representa un número de 64 bits de doble precisión con valores que van desde -1,79769313486232e308 hasta +1,79769313486232e308, así como cero positivo o negativo, PositiveInfinity, NegativeInfinity y no un número (NaN). Está pensado para representar valores extremadamente grandes (como distancias entre planetas o galaxias) o extremadamente pequeños (como la masa molecular de una sustancia en kilogramos) y que a menudo son imprecisos (como la distancia de la tierra a otro sistema solar). El tipo Double cumple con el estándar IEC 60559:1989 (IEEE 754) para la aritmética de punto flotante binario.
Representación y precisión de punto flotante
El tipo de datos Double almacena valores de punto flotante de doble precisión en un formato binario de 64 bits, como se muestra en la siguiente tabla:
| Parte | Bits |
|---|---|
| Significante o mantisa | 0-51 |
| Exponent | 52-62 |
| Signo (0 = Positivo, 1 = Negativo) | 63 |
Al igual que las fracciones decimales no pueden representar con precisión algunos valores fraccionarios (como 1/3 o Math.PI), las fracciones binarias no pueden representar algunos valores fraccionarios. Por ejemplo, 1/10, que se representa de forma precisa con 0,1 como fracción decimal, se representa con 0,001100110011 como fracción binaria, con el patrón "0011" que se repite hasta el infinito. En este caso, el valor de punto flotante proporciona una representación imprecisa del número que representa. Realizar operaciones matemáticas adicionales con el valor original de punto flotante suele tender a aumentar su falta de precisión. Por ejemplo, si compara el resultado de multiplicar .1 por 10 y agregar .1 a .1 nueve veces, verá esa adición, porque ha implicado ocho operaciones más, ha generado el resultado menos preciso. (Antes de .NET 10, esta disparidad solo es evidente si se muestran los dos valores Double mediante la cadena de formato numérico "R" estándar, que muestra hasta los 17 dígitos de precisión admitidos por el tipo Double).
using System;
public class Example13
{
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: {result1:R}");
Console.WriteLine($".1 Added 10 times: {result2:R}");
}
}
// The example displays the following output:
// .1 * 10: 1
// .1 Added 10 times: 0.99999999999999989
let value = 0.1
let result1 = value * 10.
let mutable result2 = 0.
for i = 1 to 10 do
result2 <- result2 + value
printfn $".1 * 10: {result1:R}"
printfn $".1 Added 10 times: {result2:R}"
// The example displays the following output:
// .1 * 10: 1
// .1 Added 10 times: 0.99999999999999989
Module Example14
Public Sub Run()
Dim value As Double = 0.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 fraccionarios, los números de punto flotante solo pueden aproximarse a los números reales.
Todos los números de coma flotante también tienen un número limitado de dígitos significativos, lo que también determina la precisión con la que un valor de coma flotante se aproxima a un número real. Un valor Double tiene hasta 15 dígitos decimales de precisión, aunque internamente se mantiene un máximo 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, añade el producto de Double.Epsilon y un cuatrillón. El producto, sin embargo, es demasiado pequeño para modificar el valor de punto flotante original. Su dígito menos significativo es la milésima, mientras que el dígito más significativo del producto es 10-309.
using System;
public class Example14
{
public static void Main()
{
Double value = 123456789012.34567;
Double additional = Double.Epsilon * 1e15;
Console.WriteLine($"{value} + {additional} = {value + additional}");
}
}
// The example displays the following output:
// 123456789012.346 + 4.94065645841247E-309 = 123456789012.346
open System
let value = 123456789012.34567
let additional = Double.Epsilon * 1e15
printfn $"{value} + {additional} = {value + additional}"
// The example displays the following output:
// 123456789012.346 + 4.94065645841247E-309 = 123456789012.346
Module Example15
Public Sub Run()
Dim value As Double = 123456789012.34567
Dim additional As Double = Double.Epsilon * 1.0E+15
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 punto flotante que aparecen iguales para una precisión determinada podrían no compararse iguales, ya que sus dígitos menos significativos son diferentes. En el ejemplo siguiente, se agregan una serie de números y su total se compara con su total esperado.
using System; public class Example10 { 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 ({total}) does not equal the 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).let values = [ 10.0; 2.88; 2.88; 2.88; 9.0 ] let result = 27.64 let total = List.sum values if total.Equals result then printfn "The sum of the values equals the total." else printfn $"The sum of the values ({total}) does not equal the 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 Example11 Public Sub Run() 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).Los dos valores son desiguales debido a una pérdida de precisión durante las operaciones de adición. En este caso, el problema se puede resolver llamando al método Math.Round(Double, Int32) para redondear los valores de Double a la precisión deseada antes de realizar la 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, ya que el número de punto flotante binario podría no ser igual al número decimal. Un ejemplo anterior ilustraba esto mostrando el resultado de multiplicar 0,1 por 10 y sumar 0,1 veces.
Cuando la precisión de las operaciones numéricas con valores fraccionarios es importante, puede usar el Decimal tipo en lugar del Double tipo . Cuando la precisión en operaciones numéricas con valores integrales más allá del rango de los tipos Int128UInt128 sea importante, utilice el tipo BigInteger.
Los valores de Single tienen menos precisión que los valores de Double. Un Single valor que se convierte en un aparentemente equivalente Double a menudo no es igual al Double valor debido a las diferencias de precisión. En el siguiente ejemplo, el resultado de operaciones de división idénticas se asigna a un valor Double y Single. Después de convertir el valor Single en un Double, una comparación de los dos valores muestra que son desiguales.
using System; public class Example9 { public static void Run() { double value1 = 1 / 3.0; float sValue2 = 1 / 3.0f; double value2 = (double)sValue2; Console.WriteLine($"{value1:R} = {value2:R}: {value1.Equals(value2)}"); } } // The example displays the following output: // 0.33333333333333331 = 0.3333333432674408: Falseopen System let value1 = 1. / 3. let sValue2 = 1f /3f let value2 = double sValue2 printfn $"{value1:R} = {value2:R}: {value1.Equals value2}" // The example displays the following output: // 0.33333333333333331 = 0.3333333432674408: FalseModule Example10 Public Sub Run() 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: FalsePara evitar este problema, utilice Double en lugar del tipo de datos Single, o utilice el método Round para que ambos valores tengan la misma precisión.
Además, el resultado de las operaciones aritméticas y de asignación con Double valores puede diferir ligeramente por la plataforma debido a la pérdida de precisión del Double tipo. Por ejemplo, el resultado de asignar un valor literal Double puede diferir en las versiones de 32 y 64 bits de .NET. El siguiente ejemplo ilustra esta diferencia cuando se asignan a una variable Double el valor literal -4,42330604244772E-305 y una variable cuyo valor es -4,42330604244772E-305. Tenga en cuenta que el resultado del método Parse(String) 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);
// 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
let value = -4.42330604244772E-305
let fromLiteral = -4.42330604244772E-305
let fromVariable = value
let fromParse = Double.Parse "-4.42330604244772E-305"
printfn $"Double value from literal: {fromLiteral,29:R}"
printfn $"Double value from variable: {fromVariable,28:R}"
printfn $"Double value from Parse method: {fromParse,24:R}"
// 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.4233060424477198E-305
Dim fromLiteral As Double = -4.4233060424477198E-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)
' 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
Prueba de igualdad
Para considerarse igual, dos Double valores deben representar valores idénticos. Sin embargo, debido a las diferencias de precisión entre los valores, o debido a la pérdida de precisión de uno o ambos valores, los valores de punto flotante que se espera que sean idénticos suelen resultar ser desiguales debido a las diferencias en sus dígitos menos significativos. Como resultado, llama al método Equals para determinar si dos valores son iguales o llama al método CompareTo para determinar la relación entre dos valores de Double, a menudo produce resultados inesperados. Esto es evidente en el siguiente ejemplo, donde dos valores de Double aparentemente iguales resultan ser desiguales porque el primero tiene 15 dígitos de precisión, mientras que el segundo tiene 17.
using System;
public class Example
{
public static void Main()
{
double value1 = .333333333333333;
double value2 = 1.0/3;
Console.WriteLine($"{value1} = {value2}: {value1.Equals(value2)}");
}
}
// The example displays the following output:
// 0.333333333333333 = 0.33333333333333331: False
open System
let value1 = 0.333333333333333
let value2 = 1. / 3.
printfn $"{value1:R} = {value2:R}: {value1.Equals value2}"
// The example displays the following output:
// 0.333333333333333 = 0.33333333333333331: False
Module Example1
Public Sub Run()
Dim value1 As Double = 0.333333333333333
Dim value2 As Double = 1 / 3
Console.WriteLine("{0} = {1}: {2}", value1, value2, value1.Equals(value2))
End Sub
End Module
' The example displays the following output:
' 0.333333333333333 = 0.33333333333333331: False
En los casos en que una pérdida de precisión pueda afectar al resultado de una comparación, puede adoptar cualquiera de las siguientes alternativas a llamar al método Equals o al método CompareTo:
Llame al método Math.Round para asegurarse de que ambos valores tienen la misma precisión. En el ejemplo siguiente se modifica un ejemplo anterior para usar este enfoque para que dos valores fraccionarios sean equivalentes.
double value1 = .333333333333333; double value2 = 1.0 / 3; int precision = 7; value1 = Math.Round(value1, precision); value2 = Math.Round(value2, precision); Console.WriteLine($"{value1} = {value2}: {value1.Equals(value2)}"); // The example displays the following output: // 0.3333333 = 0.3333333: Trueopen System let v1 = 0.333333333333333 let v2 = 1. / 3. let precision = 7 let value1 = Math.Round(v1, precision) let value2 = Math.Round(v2, precision) printfn $"{value1:R} = {value2:R}: {value1.Equals value2}" // The example displays the following output: // 0.3333333 = 0.3333333: TrueModule Example3 Public Sub Run() Dim value1 As Double = 0.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} = {1}: {2}", value1, value2, value1.Equals(value2)) End Sub End Module ' The example displays the following output: ' 0.3333333 = 0.3333333: TrueEl problema de precisión todavía se aplica al redondeo de valores de punto medio. Para obtener más información, consulte el método Math.Round(Double, Int32, MidpointRounding).
Realice pruebas para encontrar la igualdad aproximada en lugar de la igualdad. Esto requiere definir una cantidad absoluta por la cual los dos valores pueden diferir pero seguir siendo iguales, o definir una cantidad relativa por la cual el valor más pequeño puede divergir del valor más grande.
Warning
Double.Epsilon a veces se usa como medida absoluta de la distancia entre dos valores de Double al probar la igualdad. Sin embargo, Double.Epsilon mide el valor más pequeño posible que se puede agregar o restar de un Double cuyo valor es cero. Para la mayoría de los valores de Double positivos y negativos, el valor de Double.Epsilon es demasiado pequeño para detectarse. Por lo tanto, excepto para 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 método
IsApproximatelyEqualque prueba la diferencia relativa entre dos valores. El método divide porMath.Max(value1, value2), de manera que la comparación sea relativa al mayor (por magnitud) de los dos valores, colocando el resultado en el orden correcto de magnitud. SiMath.Maxdevuelve cero (que ocurre cuando un valor es cero y el otro es negativo), el método vuelve aMath.Min(value1, value2)usar el valor distinto de cero como divisor. También contrasta el resultado de las llamadas al métodoIsApproximatelyEqualy al método Equals(Double).using System; public class Example3 { public static void Main() { double one1 = .1 * 10; double one2 = 0; for (int ctr = 1; ctr <= 10; ctr++) one2 += .1; Console.WriteLine($"{one1} = {one2}: {one1.Equals(one2)}"); Console.WriteLine($"{one1} is approximately equal to {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: Trueopen System let isApproximatelyEqual (value1: double) (value2: double) (epsilon: double) = // If they are equal anyway, just return True. if value1.Equals value2 then true else // Handle NaN, Infinity. if Double.IsInfinity value1 || Double.IsNaN value1 then value1.Equals value2 elif Double.IsInfinity value2 || Double.IsNaN value2 then value1.Equals value2 else // Handle zero to avoid division by zero let divisor = max value1 value2 let divisor = if divisor.Equals 0 then min value1 value2 else divisor abs ((value1 - value2) / divisor) <= epsilon let one1 = 0.1 * 10. let mutable one2 = 0. for _ = 1 to 10 do one2 <- one2 + 0.1 printfn $"{one1:R} = {one2:R}: {one1.Equals one2}" printfn $"{one1:R} is approximately equal to {one2:R}: {isApproximatelyEqual one1 one2 0.000000001}" // The example displays the following output: // 1 = 0.99999999999999989: False // 1 is approximately equal to 0.99999999999999989: TrueModule Example4 Public Sub Run() Dim one1 As Double = 0.1 * 10 Dim one2 As Double = 0 For ctr As Integer = 1 To 10 one2 += 0.1 Next Console.WriteLine("{0} = {1}: {2}", one1, one2, one1.Equals(one2)) Console.WriteLine("{0} is approximately equal to {1}: {2}", one1, one2, IsApproximatelyEqual(one1, one2, 0.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) ElseIf Double.IsInfinity(value2) Or Double.IsNaN(value2) Then 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
Valores y excepciones de punto flotante
A diferencia de las operaciones con tipos enteros, que lanzan una DivideByZeroException para la división por cero o una OverflowException para el desbordamiento en un contexto comprobado, las operaciones con valores de punto flotante no lanzan excepciones. En cambio, en situaciones excepcionales, el resultado de una operación de coma 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 siguiente ejemplo.
using System; public class Example6 { public static void Main() { Double value1 = 1.1632875981534209e-225; Double value2 = 9.1642346778e-175; Double result = value1 * value2; Console.WriteLine($"{value1} * {value2} = {result}"); Console.WriteLine($"{result} = 0: {result.Equals(0.0)}"); } } // The example displays the following output: // 1.16328759815342E-225 * 9.1642346778E-175 = 0 // 0 = 0: Truelet value1 = 1.1632875981534209e-225 let value2 = 9.1642346778e-175 let result = value1 * value2 printfn $"{value1} * {value2} = {result}" printfn $"{result} = 0: {result.Equals 0.0}" // The example displays the following output: // 1.16328759815342E-225 * 9.1642346778E-175 = 0 // 0 = 0: TrueModule Example7 Public Sub Run() 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: TrueSi 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 PositiveInfinity o NegativeInfinity, según corresponda para el signo del resultado. El resultado de una operación que desborda Double.MaxValue es PositiveInfinityy el resultado de una operación que desborda Double.MinValue es NegativeInfinity, como se muestra en el ejemplo siguiente.
using System; public class Example7 { public static void Main() { Double value1 = 4.565e153; Double value2 = 6.9375e172; Double result = value1 * value2; Console.WriteLine($"PositiveInfinity: {Double.IsPositiveInfinity(result)}"); Console.WriteLine($"NegativeInfinity: {Double.IsNegativeInfinity(result)}{Environment.NewLine}"); value1 = -value1; result = value1 * value2; Console.WriteLine($"PositiveInfinity: {Double.IsPositiveInfinity(result)}"); Console.WriteLine($"NegativeInfinity: {Double.IsNegativeInfinity(result)}"); } } // The example displays the following output: // PositiveInfinity: True // NegativeInfinity: False // // PositiveInfinity: False // NegativeInfinity: Trueopen System let value1 = 4.565e153 let value2 = 6.9375e172 let result = value1 * value2 printfn $"PositiveInfinity: {Double.IsPositiveInfinity result}" printfn $"NegativeInfinity: {Double.IsNegativeInfinity result}\n" let value3 = - value1 let result2 = value2 * value3 printfn $"PositiveInfinity: {Double.IsPositiveInfinity result2}" printfn $"NegativeInfinity: {Double.IsNegativeInfinity result2}" // The example displays the following output: // PositiveInfinity: True // NegativeInfinity: False // // PositiveInfinity: False // NegativeInfinity: TrueModule Example8 Public Sub Run() Dim value1 As Double = 4.565E+153 Dim value2 As Double = 6.9375E+172 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: TruePositiveInfinity también resulta de una división por cero con un dividendo positivo y NegativeInfinity resulta de una división por cero con un dividendo negativo.
Si una operación de punto flotante no es válida, el resultado de la operación es NaN. Por ejemplo, NaN resulta de las siguientes operaciones:
División por cero con un dividendo de cero. Tenga en cuenta que otros casos de división por cero dan como resultado PositiveInfinity o NegativeInfinity.
Cualquier operación de coma flotante con una entrada no válida. Por ejemplo, llamar al método Math.Sqrt con un valor negativo devuelveNaN, al igual que llamar al método Math.Acos con un valor mayor que uno o menor que menos uno.
Cualquier operación con un argumento cuyo valor es Double.NaN.
Conversiones de tipos
La estructura Double no define ningún operador de conversión explícito o implícito; en su lugar, el compilador implementa las conversiones.
La conversión del valor de cualquier tipo numérico primitivo a Double es una conversión de ampliación y, por lo 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 requiera explícitamente. Por ejemplo, el compilador de C# requiere un operador de conversión para las conversiones de Decimal a Double, mientras que el compilador de Visual Basic no. El siguiente ejemplo convierte el valor mínimo o máximo de otros tipos numéricos primitivos a un Double.
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 (dynamic value in values)
{
if (value.GetType() == typeof(decimal))
dblValue = (double)value;
else
dblValue = value;
Console.WriteLine($"{value} ({value.GetType().Name}) --> " +
$"{dblValue:R} ({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)
open System
let values: obj[] =
[| 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 |]
for value in values do
let dblValue = value :?> double
printfn $"{value} ({value.GetType().Name}) --> {dblValue:R} ({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 Example5
Public Sub Run()
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 valores de SingleSingle.NaN, Single.PositiveInfinityy Single.NegativeInfinity convierten en Double.NaN, Double.PositiveInfinityy Double.NegativeInfinity, respectivamente.
Tenga en cuenta que la conversión del valor de algunos tipos numéricos a un valor de Double puede implicar una pérdida de precisión. Como ilustra el ejemplo, es posible que se pierda precisión al convertir valores Decimal, Int64, y UInt64 en valores Double.
La conversión de un valor de Double a un valor de cualquier otro tipo de datos numérico primitivo es una conversión de restricción y requiere un operador de conversión (en C#), un método de conversión (en Visual Basic) o una llamada a un método Convert. Los valores que están fuera del intervalo del tipo de datos de destino, que se definen mediante las propiedades MinValue y MaxValue del tipo de destino, se comportan como se muestra en la tabla siguiente.
| Tipo de destino | Result |
|---|---|
| Cualquier tipo entero | Excepción de OverflowException si la conversión se produce en un contexto comprobado. Si la conversión se produce en un contexto no comprobado (el valor predeterminado en C#), la operación de conversión se realiza correctamente, pero el valor se desborda. |
| Decimal | Una OverflowException excepción. |
| Single |
Single.NegativeInfinity para valores negativos. Single.PositiveInfinity para valores positivos. |
Además, Double.NaN, Double.PositiveInfinityy Double.NegativeInfinity lanzan un OverflowException para conversiones a enteros en un contexto comprobado, pero estos valores se desbordan cuando se convierten a enteros en un contexto sin comprobación. Para las conversiones a Decimal, siempre lanzan un/a OverflowException. Para las conversiones a Single, estas se transforman en Single.NaN, Single.PositiveInfinityy Single.NegativeInfinity, respectivamente.
Una pérdida de precisión puede dar lugar a la conversión de un Double 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 fraccionario se pierde cuando el valor de Double se redondea (como en Visual Basic) o trunca (como en C#). Para las conversiones a los valores Decimal y Single, es posible que el valor Double no tenga una representación precisa en el tipo de datos de destino.
En el ejemplo siguiente se convierte una serie de valores de Double en otros tipos numéricos. Las conversiones se producen en un contexto comprobado en Visual Basic (valor predeterminado), en C# (debido a la palabra clave checked) y en F# (debido al Checked módulo). La conclusión del ejemplo muestra el resultado de las conversiones en un contexto tanto comprobado como no comprobado. Puede realizar conversiones en un contexto no comprobado en Visual Basic al compilar con el modificador de compilación /removeintchecks+, en C# al comentar la instrucción checked, y en F# al comentar la instrucción open Checked.
using System;
public class Example5
{
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($"{value} ({value.GetType().Name}) --> {lValue} (0x{lValue:X16}) ({lValue.GetType().Name})");
}
catch (OverflowException)
{
Console.WriteLine($"Unable to convert {value} to Int64.");
}
try
{
UInt64 ulValue = (ulong)value;
Console.WriteLine($"{value} ({value.GetType().Name}) --> {ulValue} (0x{ulValue:X16}) ({ulValue.GetType().Name})");
}
catch (OverflowException)
{
Console.WriteLine($"Unable to convert {value} to UInt64.");
}
try
{
Decimal dValue = (decimal)value;
Console.WriteLine($"{value} ({value.GetType().Name}) --> {dValue} ({dValue.GetType().Name})");
}
catch (OverflowException)
{
Console.WriteLine($"Unable to convert {value} to Decimal.");
}
try
{
Single sValue = (float)value;
Console.WriteLine($"{value} ({value.GetType().Name}) --> {sValue} ({sValue.GetType().Name})");
}
catch (OverflowException)
{
Console.WriteLine($"Unable to convert {value} to Single.");
}
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)
open System
open Checked
let values =
[| Double.MinValue; -67890.1234; -12345.6789
12345.6789; 67890.1234; Double.MaxValue
Double.NaN; Double.PositiveInfinity;
Double.NegativeInfinity |]
for value in values do
try
let lValue = int64 value
printfn $"{value} ({value.GetType().Name}) --> {lValue} (0x{lValue:X16}) ({lValue.GetType().Name})"
with :? OverflowException ->
printfn $"Unable to convert {value} to Int64."
try
let ulValue = uint64 value
printfn $"{value} ({value.GetType().Name}) --> {ulValue} (0x{ulValue:X16}) ({ulValue.GetType().Name})"
with :? OverflowException ->
printfn $"Unable to convert {value} to UInt64."
try
let dValue = decimal value
printfn $"{value} ({value.GetType().Name}) --> {dValue} ({dValue.GetType().Name})"
with :? OverflowException ->
printfn $"Unable to convert {value} to Decimal."
try
let sValue = float32 value
printfn $"{value} ({value.GetType().Name}) --> {sValue} ({sValue.GetType().Name})"
with :? OverflowException ->
printfn $"Unable to convert {value} to Single."
printfn ""
// 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 Example6
Public Sub Run()
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 Type Conversion in .NET and Type Conversion Tables.
Funcionalidad de punto flotante
La estructura Double y los tipos relacionados proporcionan métodos para realizar operaciones en las siguientes áreas:
Comparación de valores. Puede llamar al método Equals para determinar si dos valores Double son iguales o el método CompareTo para determinar la relación entre dos valores.
La estructura Double también admite un conjunto completo de operadores de comparación. Por ejemplo, puede probar la igualdad o la desigualdad, o determinar si un valor es mayor o igual que otro. Se convierte a un Double antes de realizar la comparación si uno de los operandos es un tipo numérico que no sea Double.
Warning
Debido a las diferencias de precisión, dos Double valores que se espera que sean iguales podrían resultar desiguales, lo que afecta al resultado de la comparación. Para obtener información sobre cómo comparar dos Double valores, consulte la sección Prueba de igualdad .
También puede llamar a los métodos IsNaN, IsInfinity, IsPositiveInfinityy IsNegativeInfinity para probar estos valores especiales.
Operaciones matemáticas Las operaciones aritméticas comunes, como la suma, la resta, la multiplicación y la división, se implementan mediante compiladores de lenguaje e instrucciones de lenguaje intermedio común (CIL), en lugar de mediante métodos Double. Si uno de los operandos de una operación matemática es un tipo numérico distinto de , Doublese convierte en un Double antes de realizar la operación. El resultado de la operación también es un valor Double.
Otras operaciones matemáticas se pueden realizar llamando a métodos
static(Shareden Visual Basic) de la clase System.Math. Incluye métodos adicionales comúnmente utilizados para aritmética (como Math.Abs, Math.Sign, y Math.Sqrt), geometría (como Math.Cos y Math.Sin) y cálculo (como Math.Log).También puede manipular los bits individuales en un valor de Double. El método BitConverter.DoubleToInt64Bits conserva el patrón de bits de un valor Double en un entero de 64 bits. El método BitConverter.GetBytes(Double) devuelve su patrón de bits en una matriz de bytes.
Redondeo. El redondeo se suele usar como técnica para reducir el impacto de las diferencias entre los valores causados por problemas de representación y precisión de punto flotante. Puede redondear un Double valor llamando al método Math.Round.
Formato. Puede convertir un valor Double a su representación de cadena llamando al método ToString o utilizando la característica de formato compuesto. Para obtener información sobre cómo las cadenas de formato controlan la representación en cadena de los valores de punto flotante, consulte Cadenas con formato numérico estándar y Cadenas con formato numérico personalizado.
Análisis de cadenas. Puede convertir la representación de cadena de un valor de coma flotante en un valor Double llamando al método Parse o TryParse. Si se produce un error en la operación de análisis, el método Parse produce una excepción, mientras que el método TryParse devuelve
false.Conversión de tipos. La estructura Double proporciona una implementación de interfaz explícita para la interfaz IConvertible, que admite la conversión entre dos tipos de datos estándar .NET. Los compiladores de lenguaje también admiten la conversión implícita de valores de todos los demás tipos numéricos estándar a valores Double. La conversión de un valor de cualquier tipo numérico estándar a un Double es una conversión de ampliación y no requiere el uso de un operador de conversión o método de conversión.
Sin embargo, la conversión de los valores Int64 y Single pueden implicar una pérdida de precisión. La siguiente tabla muestra 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 más frecuencia a los valores de Single que se convierten en valores de Double. En el siguiente ejemplo, dos valores producidos por operaciones de división idénticas no son iguales porque uno de los valores es un valor de coma flotante de precisión simple convertido a un Double.
using System; public class Example13 { 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: {result1:R}"); Console.WriteLine($".1 Added 10 times: {result2:R}"); } } // The example displays the following output: // .1 * 10: 1 // .1 Added 10 times: 0.99999999999999989let value = 0.1 let result1 = value * 10. let mutable result2 = 0. for i = 1 to 10 do result2 <- result2 + value printfn $".1 * 10: {result1:R}" printfn $".1 Added 10 times: {result2:R}" // The example displays the following output: // .1 * 10: 1 // .1 Added 10 times: 0.99999999999999989Module Example14 Public Sub Run() Dim value As Double = 0.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
Campos
| Nombre | Description |
|---|---|
| E |
Representa la base logarítmica natural, especificada por la constante, e. |
| Epsilon |
Representa el valor positivo Double más pequeño que es mayor que cero. Este campo es constante. |
| MaxValue |
Representa el valor más grande posible de .Double Este campo es constante. |
| MinValue |
Representa el valor más pequeño posible de .Double Este campo es constante. |
| NaN |
Representa un valor que no es un número ( |
| NegativeInfinity |
Representa infinito negativo. Este campo es constante. |
| NegativeZero |
Representa el número negativo cero (-0). |
| Pi |
Representa la relación de la circunferencia de un círculo a su diámetro, especificado por la constante, π. |
| PositiveInfinity |
Representa infinito positivo. Este campo es constante. |
| Tau |
Representa el número de radianes en un turno, especificado por la constante, τ. |
Métodos
| Nombre | Description |
|---|---|
| Abs(Double) |
Calcula el valor absoluto de un valor. |
| Acos(Double) |
Calcula el arco-coseno de un valor. |
| Acosh(Double) |
Calcula el coseno de arco hiperbólico de un valor. |
| AcosPi(Double) |
Calcula el arco-coseno de un valor y divide el resultado por |
| Asin(Double) |
Calcula el arco seno de un valor. |
| Asinh(Double) |
Calcula el arco-seno hiperbólico de un valor. |
| AsinPi(Double) |
Calcula el arco-seno de un valor y divide el resultado por |
| Atan(Double) |
Calcula la tangente de arco de un valor. |
| Atan2(Double, Double) |
Calcula la tangente de arco del cociente de dos valores. |
| Atan2Pi(Double, Double) |
Calcula la tangente de arco para el cociente de dos valores y divide el resultado por |
| Atanh(Double) |
Calcula la tangente de arco hiperbólico de un valor. |
| AtanPi(Double) |
Calcula la tangente de arco de un valor y divide el resultado por pi. |
| BitDecrement(Double) |
Devuelve el valor más grande que compara menos que un valor especificado. |
| BitIncrement(Double) |
Devuelve el valor más pequeño que compara mayor que un valor especificado. |
| Cbrt(Double) |
Calcula la raíz del cubo de un valor. |
| Ceiling(Double) |
Calcula el límite máximo de un valor. |
| Clamp(Double, Double, Double) |
Fija un valor en un valor mínimo inclusivo y máximo. |
| ClampNative(Double, Double, Double) |
Abraza un valor a un valor mínimo y máximo inclusivo mediante el comportamiento específico de la plataforma para |
| 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 menor, igual o mayor 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 menor, igual o mayor que el valor del objeto especificado. |
| ConvertToInteger<TInteger>(Double) |
Convierte un valor en un tipo entero especificado mediante saturación en desbordamiento. |
| ConvertToIntegerNative<TInteger>(Double) |
Convierte un valor en un tipo entero especificado mediante el comportamiento específico de la plataforma en el desbordamiento. |
| CopySign(Double, Double) |
Copia el signo de un valor en el signo de otro valor. |
| Cos(Double) |
Calcula el coseno de un valor. |
| Cosh(Double) |
Calcula el coseno hiperbólico de un valor. |
| CosPi(Double) |
Calcula el coseno de un valor que ha sido multipledado por |
| CreateChecked<TOther>(TOther) |
Crea una instancia del tipo actual a partir de un valor, iniciando una excepción de desbordamiento para los valores que se encuentran fuera del intervalo que se puede representar del tipo actual. |
| CreateSaturating<TOther>(TOther) |
Crea una instancia del tipo actual a partir de un valor, saturando los valores que se encuentran fuera del intervalo que se puede representar del tipo actual. |
| CreateTruncating<TOther>(TOther) |
Crea una instancia del tipo actual a partir de un valor, truncando los valores que se encuentran fuera del intervalo que se puede representar del tipo actual. |
| DegreesToRadians(Double) |
Convierte un valor determinado de grados a radianes. |
| Equals(Double) |
Devuelve un valor que indica si esta instancia y un objeto especificado Double representan el mismo valor. |
| Equals(Object) |
Devuelve un valor que indica si esta instancia es igual a un objeto especificado. |
| Exp(Double) |
|
| Exp10(Double) |
|
| Exp10M1(Double) |
|
| Exp2(Double) |
|
| Exp2M1(Double) |
|
| ExpM1(Double) |
|
| Floor(Double) |
Calcula el piso de un valor. |
| FusedMultiplyAdd(Double, Double, Double) |
Calcula la multiplicación fusionada de tres valores. |
| GetHashCode() |
Devuelve el código hash de esta instancia. |
| GetTypeCode() | |
| Hypot(Double, Double) |
Calcula la hipotenusa dadas dos valores que representan las longitudes de los lados más cortos en un triángulo con ángulo derecho. |
| Ieee754Remainder(Double, Double) |
Calcula el resto de dos valores especificados por IEEE 754. |
| ILogB(Double) |
Calcula el logaritmo entero de un valor. |
| IsEvenInteger(Double) |
Determina si un valor representa un número entero par. |
| IsFinite(Double) |
Determina si el valor especificado es finito (cero, subnormal o normal). |
| IsInfinity(Double) |
Devuelve un valor que indica si el número especificado se evalúa como infinito negativo o positivo. |
| IsInteger(Double) |
Determina si un valor representa un valor entero. |
| 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. |
| IsOddInteger(Double) |
Determina si un valor representa un número entero impar. |
| IsPositive(Double) |
Determina si un valor es positivo. |
| IsPositiveInfinity(Double) |
Devuelve un valor que indica si el número especificado se evalúa como infinito positivo. |
| IsPow2(Double) |
Determina si un valor es una potencia de dos. |
| IsRealNumber(Double) |
Determina si un valor representa un número real. |
| IsSubnormal(Double) |
Determina si el valor especificado es subnormal. |
| Lerp(Double, Double, Double) |
Realiza una interpolación lineal entre dos valores en función del peso especificado. |
| Log(Double, Double) |
Calcula el logaritmo de un valor en la base especificada. |
| Log(Double) |
Calcula el logaritmo natural ( |
| Log10(Double) |
Calcula el logaritmo base-10 de un valor. |
| Log10P1(Double) |
Calcula el logaritmo base-10 de un valor más uno. |
| Log2(Double) |
Calcula el registro2 de un valor. |
| Log2P1(Double) |
Calcula el logaritmo base-2 de un valor más uno. |
| LogP1(Double) |
Calcula el logaritmo natural ( |
| Max(Double, Double) |
Compara dos valores con el proceso, que es mayor. |
| MaxMagnitude(Double, Double) |
Compara dos valores con el proceso, que es mayor. |
| MaxMagnitudeNumber(Double, Double) |
Compara dos valores con el proceso que tiene la magnitud mayor y devuelve el otro valor si una entrada es |
| MaxNative(Double, Double) |
Compara dos valores con el proceso, que es mayor mediante el comportamiento específico de la plataforma para |
| MaxNumber(Double, Double) |
Compara dos valores con el proceso, que es mayor y devuelve el otro valor si una entrada es |
| Min(Double, Double) |
Compara dos valores con el proceso, que es menor. |
| MinMagnitude(Double, Double) |
Compara dos valores con el proceso, que es menor. |
| MinMagnitudeNumber(Double, Double) |
Compara dos valores con el proceso que tiene la magnitud menor y devuelve el otro valor si una entrada es |
| MinNative(Double, Double) |
Compara dos valores con el proceso, que es menor mediante el comportamiento específico de la plataforma para |
| MinNumber(Double, Double) |
Compara dos valores con el proceso, que es menor y devuelve el otro valor si una entrada es |
| MultiplyAddEstimate(Double, Double, Double) |
Calcula una estimación de ( |
| Parse(ReadOnlySpan<Byte>, IFormatProvider) |
Analiza un intervalo de caracteres UTF-8 en un valor. |
| Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider) |
Analiza un intervalo de caracteres UTF-8 en un valor. |
| Parse(ReadOnlySpan<Char>, IFormatProvider) |
Analiza un intervalo de caracteres en un valor. |
| Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider) |
Convierte un intervalo de caracteres que contiene la representación de cadena de un número en un estilo especificado y un formato específico de la referencia cultural a su número de punto flotante de precisión doble equivalente. |
| Parse(String, IFormatProvider) |
Convierte la representación de cadena de un número en un formato específico de la referencia cultural especificado a su número de punto flotante de precisión doble equivalente. |
| Parse(String, NumberStyles, IFormatProvider) |
Convierte la representación de cadena de un número en un estilo y formato específico de la referencia cultural especificados en su número de punto flotante de precisión doble equivalente. |
| Parse(String, NumberStyles) |
Convierte la representación de cadena de un número en un estilo especificado en su número de punto flotante de precisión doble equivalente. |
| Parse(String) |
Convierte la representación de cadena de un número en su número de punto flotante de precisión doble equivalente. |
| Pow(Double, Double) |
Calcula un valor elevado a una potencia determinada. |
| RadiansToDegrees(Double) |
Convierte un valor determinado de radianes en grados. |
| ReciprocalEstimate(Double) |
Calcula una estimación de la recíproca de un valor. |
| ReciprocalSqrtEstimate(Double) |
Calcula una estimación de la raíz cuadrada recíproca de un valor. |
| RootN(Double, Int32) |
Calcula la n-ª raíz de un valor. |
| Round(Double, Int32, MidpointRounding) |
Redondea un valor a un número especificado de dígitos fraccionarios mediante el modo de redondeo predeterminado (ToEven). |
| Round(Double, Int32) |
Redondea un valor a un número especificado de dígitos fraccionarios mediante el modo de redondeo predeterminado (ToEven). |
| Round(Double, MidpointRounding) |
Redondea un valor al entero más cercano mediante el modo de redondeo especificado. |
| Round(Double) |
Redondea un valor al entero más cercano mediante el modo de redondeo predeterminado (ToEven). |
| ScaleB(Double, Int32) |
Calcula el producto de un valor y su base-radix elevado a la potencia especificada. |
| Sign(Double) |
Calcula el signo de un valor. |
| Sin(Double) |
Calcula el seno de un valor. |
| SinCos(Double) |
Calcula el seno y el coseno de un valor. |
| SinCosPi(Double) |
Calcula el seno y el coseno de un valor. |
| Sinh(Double) |
Calcula el seno hiperbólico de un valor. |
| SinPi(Double) |
Calcula el seno de un valor multiplicado por |
| Sqrt(Double) |
Calcula la raíz cuadrada de un valor. |
| Tan(Double) |
Calcula la tangente de un valor. |
| Tanh(Double) |
Calcula la tangente hiperbólica de un valor. |
| TanPi(Double) |
Calcula la tangente de un valor que ha sido multipledado por |
| ToString() |
Convierte el valor numérico de esta instancia en su representación de cadena equivalente. |
| ToString(IFormatProvider) |
Convierte el valor numérico de esta instancia en su representación de cadena equivalente mediante la información de formato específica de la referencia cultural especificada. |
| ToString(String, IFormatProvider) |
Convierte el valor numérico de esta instancia en su representación de cadena equivalente mediante el formato especificado y la información de formato específica de la referencia cultural. |
| ToString(String) |
Convierte el valor numérico de esta instancia en su representación de cadena equivalente mediante el formato especificado. |
| Truncate(Double) |
Trunca un valor. |
| TryFormat(Span<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider) |
Intenta dar formato al valor de la instancia actual como UTF-8 en el intervalo de bytes proporcionado. |
| 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<Byte>, Double) |
Intenta convertir un intervalo de caracteres UTF-8 que contiene la representación de cadena de un número en su número de punto flotante de precisión doble equivalente. |
| TryParse(ReadOnlySpan<Byte>, IFormatProvider, Double) |
Intenta analizar un intervalo de caracteres UTF-8 en un valor. |
| TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, Double) |
Intenta analizar un intervalo de caracteres UTF-8 en un valor. |
| TryParse(ReadOnlySpan<Char>, Double) |
Convierte la representación de intervalo de un número en un estilo especificado y un formato específico de la referencia cultural a su número de punto flotante de precisión doble equivalente. Un valor devuelto indica si la conversión se realizó correctamente o no. |
| TryParse(ReadOnlySpan<Char>, IFormatProvider, Double) |
Intenta analizar un intervalo de caracteres en un valor. |
| TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Double) |
Convierte un intervalo de caracteres que contiene la representación de cadena de un número en un estilo especificado y un formato específico de la referencia cultural a su número de punto flotante de precisión doble equivalente. Un valor devuelto indica si la conversión se realizó correctamente o no. |
| TryParse(String, Double) |
Convierte la representación de cadena de un número en su número de punto flotante de precisión doble equivalente. Un valor devuelto indica si la conversión se realizó correctamente o no. |
| TryParse(String, IFormatProvider, Double) |
Intenta analizar una cadena en un valor. |
| TryParse(String, NumberStyles, IFormatProvider, Double) |
Convierte la representación de cadena de un número en un estilo y formato específico de la referencia cultural especificados en su número de punto flotante de precisión doble equivalente. Un valor devuelto indica si la conversión se realizó correctamente o no. |
Operadores
| Nombre | Description |
|---|---|
| Equality(Double, Double) |
Devuelve un valor que indica si dos valores especificados Double son iguales. |
| GreaterThan(Double, Double) |
Devuelve un valor que indica si un valor especificado Double es mayor que otro valor especificado Double . |
| GreaterThanOrEqual(Double, Double) |
Devuelve un valor que indica si un valor especificado Double es mayor o igual que otro valor especificado Double . |
| Inequality(Double, Double) |
Devuelve un valor que indica si dos valores especificados Double no son iguales. |
| LessThan(Double, Double) |
Devuelve un valor que indica si un valor especificado Double es menor que otro valor especificado Double . |
| LessThanOrEqual(Double, Double) |
Devuelve un valor que indica si un valor especificado Double es menor o igual que otro valor especificado Double . |
Implementaciones de interfaz explícitas
| Nombre | Description |
|---|---|
| IAdditionOperators<Double,Double,Double>.Addition(Double, Double) |
Agrega dos valores juntos para calcular su suma. |
| IAdditiveIdentity<Double,Double>.AdditiveIdentity |
Obtiene la identidad de suma del tipo actual. |
| IBinaryNumber<Double>.AllBitsSet |
Obtiene una instancia del tipo binario en el que se establecen todos los bits. |
| IBitwiseOperators<Double,Double,Double>.BitwiseAnd(Double, Double) |
Calcula los valores bit a bit y de dos valores. |
| IBitwiseOperators<Double,Double,Double>.BitwiseOr(Double, Double) |
Calcula el bit a bit o de dos valores. |
| IBitwiseOperators<Double,Double,Double>.ExclusiveOr(Double, Double) |
Calcula el valor exclusivo o de dos valores. |
| IBitwiseOperators<Double,Double,Double>.OnesComplement(Double) |
Calcula la representación ones-complement de un valor determinado. |
| IComparable.CompareTo(Object) |
Compara la instancia actual con otro objeto del mismo tipo y devuelve un entero que indica si la instancia actual precede, sigue o se produce en la misma posición en el criterio de ordenación que el otro objeto. |
| IConvertible.GetTypeCode() |
Devuelve para TypeCode 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) |
Esta conversión no se admite. Si se intenta usar este método, se produce una InvalidCastExceptionexcepción . |
| IConvertible.ToDateTime(IFormatProvider) |
Esta conversión no se admite. Si se intenta usar este método, se produce una InvalidCastExceptionexcepción . |
| 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). |
| IDecrementOperators<Double>.Decrement(Double) |
Disminuye un valor. |
| IDivisionOperators<Double,Double,Double>.Division(Double, Double) |
Divide un valor por otro para calcular su cociente. |
| IFloatingPoint<Double>.GetExponentByteCount() |
Obtiene el número de bytes que se escribirán como parte de TryWriteExponentLittleEndian(Span<Byte>, Int32). |
| IFloatingPoint<Double>.GetExponentShortestBitLength() |
Obtiene la longitud, en bits, de la representación complementaria de dos más corta del exponente actual. |
| IFloatingPoint<Double>.GetSignificandBitLength() |
Obtiene la longitud, en bits, del significado actual. |
| IFloatingPoint<Double>.GetSignificandByteCount() |
Obtiene el número de bytes que se escribirán como parte de TryWriteSignificandLittleEndian(Span<Byte>, Int32). |
| IFloatingPoint<Double>.TryWriteExponentBigEndian(Span<Byte>, Int32) |
Intenta escribir el exponente actual, en formato big-endian, en un intervalo determinado. |
| IFloatingPoint<Double>.TryWriteExponentLittleEndian(Span<Byte>, Int32) |
Intenta escribir el exponente actual, en formato little-endian, en un intervalo determinado. |
| IFloatingPoint<Double>.TryWriteSignificandBigEndian(Span<Byte>, Int32) |
Intenta escribir el significado actual, en formato big-endian, en un intervalo determinado. |
| IFloatingPoint<Double>.TryWriteSignificandLittleEndian(Span<Byte>, Int32) |
Intenta escribir el significado actual, en formato little-endian, en un intervalo determinado. |
| IFloatingPointConstants<Double>.E |
Obtiene la constante |
| IFloatingPointConstants<Double>.Pi |
Obtiene la constante |
| IFloatingPointConstants<Double>.Tau |
Obtiene la constante |
| IFloatingPointIeee754<Double>.Epsilon |
Obtiene el valor más pequeño, de modo que se puede agregar a |
| IFloatingPointIeee754<Double>.NaN |
Obtiene un valor que representa |
| IFloatingPointIeee754<Double>.NegativeInfinity |
Obtiene un valor que representa un valor negativo |
| IFloatingPointIeee754<Double>.NegativeZero |
Obtiene un valor que representa un valor negativo |
| IFloatingPointIeee754<Double>.PositiveInfinity |
Obtiene un valor que representa un valor positivo |
| IIncrementOperators<Double>.Increment(Double) |
Incrementa un valor. |
| IMinMaxValue<Double>.MaxValue |
Obtiene el valor máximo del tipo actual. |
| IMinMaxValue<Double>.MinValue |
Obtiene el valor mínimo del tipo actual. |
| IModulusOperators<Double,Double,Double>.Modulus(Double, Double) |
Divide dos valores juntos para calcular su módulo o resto. |
| IMultiplicativeIdentity<Double,Double>.MultiplicativeIdentity |
Obtiene la identidad multiplicativa del tipo actual. |
| IMultiplyOperators<Double,Double,Double>.Multiply(Double, Double) |
Multiplica dos valores juntos para calcular su producto. |
| INumberBase<Double>.IsCanonical(Double) |
Determina si un valor está en su representación canónica. |
| INumberBase<Double>.IsComplexNumber(Double) |
Determina si un valor representa un número complejo. |
| INumberBase<Double>.IsImaginaryNumber(Double) |
Determina si un valor representa un número imaginario puro. |
| INumberBase<Double>.IsZero(Double) |
Determina si un valor es cero. |
| INumberBase<Double>.One |
Obtiene el valor |
| INumberBase<Double>.Radix |
Obtiene la raíz, o base, para el tipo. |
| INumberBase<Double>.TryConvertFromChecked<TOther>(TOther, Double) |
Representa un número de punto flotante de precisión doble. |
| INumberBase<Double>.TryConvertFromSaturating<TOther>(TOther, Double) |
Representa un número de punto flotante de precisión doble. |
| INumberBase<Double>.TryConvertFromTruncating<TOther>(TOther, Double) |
Representa un número de punto flotante de precisión doble. |
| INumberBase<Double>.TryConvertToChecked<TOther>(Double, TOther) |
Intenta convertir una instancia del tipo actual en otro tipo, iniciando una excepción de desbordamiento para los valores que se encuentran fuera del intervalo que se puede representar del tipo actual. |
| INumberBase<Double>.TryConvertToSaturating<TOther>(Double, TOther) |
Intenta convertir una instancia del tipo actual en otro tipo, saturando los valores que se encuentran fuera del intervalo que se puede representar del tipo actual. |
| INumberBase<Double>.TryConvertToTruncating<TOther>(Double, TOther) |
Intenta convertir una instancia del tipo actual en otro tipo, truncando los valores que se encuentran fuera del intervalo que se puede representar del tipo actual. |
| INumberBase<Double>.Zero |
Obtiene el valor |
| ISignedNumber<Double>.NegativeOne |
Obtiene el valor |
| ISubtractionOperators<Double,Double,Double>.Subtraction(Double, Double) |
Resta dos valores para calcular su diferencia. |
| IUnaryNegationOperators<Double,Double>.UnaryNegation(Double) |
Calcula la negación unaria de un valor. |
| IUnaryPlusOperators<Double,Double>.UnaryPlus(Double) |
Calcula la unaria más de un valor. |
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, leer y escribir en una variable compartida que contenga una instancia de este tipo debe estar protegida por un bloqueo para garantizar la seguridad de los subprocesos.
