Double Estrutura
Definição
Importante
Algumas informações dizem respeito a um produto pré-lançado que pode ser substancialmente modificado antes de ser lançado. A Microsoft não faz garantias, de forma expressa ou implícita, em relação à informação aqui apresentada.
Representa um número de ponto flutuante de precisão dupla.
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- Herança
- Atributos
- Implementações
-
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>
Exemplos
O exemplo de código a seguir ilustra o 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
Observações
O Double tipo de valor representa um número de 64 bits de precisão dupla com valores que variam de negativo 1,79769313486232e308 a positivo 1,79769313486232e308, bem como zero positivo ou negativo, PositiveInfinity, NegativeInfinitye não um número (NaN). Destina-se a representar valores extremamente grandes (como distâncias entre planetas ou galáxias) ou extremamente pequenos (como a massa molecular de uma substância em quilogramas) e que muitas vezes são imprecisos (como a distância da Terra a outro sistema solar). O tipo Double está em conformidade com a norma IEC 60559:1989 (IEEE 754) para aritmética binária de ponto flutuante.
Representação e precisão de ponto flutuante
O Double tipo de dados armazena valores de ponto flutuante de precisão dupla em um formato binário de 64 bits, conforme mostrado na tabela a seguir:
| Parte | Bits |
|---|---|
| Significand ou mantissa | 0-51 |
| Exponent | 52-62 |
| Sinal (0 = Positivo, 1 = Negativo) | 63 |
Assim como as frações decimais são incapazes de representar com precisão alguns valores fracionários (como 1/3 ou Math.PI), as frações binárias são incapazes de representar alguns valores fracionários. Por exemplo, 1/10, que é representado precisamente por .1 como uma fração decimal, é representado por .001100110011 como uma fração binária, com o padrão "0011" repetindo ao infinito. Neste caso, o valor de vírgula flutuante fornece uma representação imprecisa do número que representa. A realização de operações matemáticas adicionais sobre o valor original de vírgula flutuante tende frequentemente a aumentar a sua falta de precisão. Por exemplo, se comparar o resultado de multiplicar 0,1 por 10 e somar 0,1 por 0,1 nove vezes, verá que a adição, porque envolveu mais oito operações, produziu o resultado menos preciso. (Antes do .NET 10, esta disparidade só é evidente se mostrar os dois valores Double usando a cadeia numérica "R" padrão numérico, que apresenta até todos os 17 dígitos de precisão suportados pelo 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
Como alguns números não podem ser representados exatamente como valores binários fracionários, números de ponto flutuante só podem aproximar números reais.
Todos os números de vírgula flutuante também têm um número limitado de dígitos significativos, o que também determina a precisão com que um valor de vírgula flutuante se aproxima de um número real. Um Double valor tem até 15 dígitos decimais de precisão, embora um máximo de 17 dígitos seja mantido internamente. Isto significa que algumas operações em ponto flutuante podem não ter a precisão necessária para alterar o valor de um ponto flutuante. O exemplo a seguir fornece uma ilustração. Ele define um valor de ponto flutuante muito grande e, em seguida, adiciona o produto de Double.Epsilon e um quatrilhão a ele. O produto, no entanto, é muito pequeno para modificar o valor original em ponto flutuante. Seu dígito menos significativo é milésimo, enquanto o dígito mais significativo no produto é 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
A precisão limitada de um número em ponto flutuante tem várias consequências:
Dois números em ponto flutuante que parecem iguais para uma precisão particular podem não se comparar, porque os seus dígitos menos significativos são diferentes. No exemplo a seguir, uma série de números é somada e seu total é comparado com o 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).Os dois valores são desiguais devido à perda de precisão durante as operações de adição. Nesse caso, o problema pode ser resolvido chamando o método Math.Round(Double, Int32) para arredondar os valores de Double para a precisão desejada antes de executar a comparação.
Uma operação matemática ou de comparação que usa um número de vírgula flutuante pode não produzir o mesmo resultado se um número decimal for usado, porque o número binário de vírgula flutuante pode não ser igual ao número decimal. Um exemplo anterior ilustrou isso exibindo o resultado de multiplicar .1 por 10 e adicionar .1 vezes.
Quando a precisão em operações numéricas com valores fracionários é importante, pode usar o Decimal tipo em vez do Double tipo. Quando a precisão em operações numéricas com valores inteiros além do intervalo suportado pelos tipos Int128UInt128 for importante, utilize o tipo BigInteger.
Single valores têm menos precisão do que Double valores. Um Single valor que é convertido para um aparentemente equivalente Double muitas vezes não é igual ao Double valor devido a diferenças de precisão. No exemplo a seguir, o resultado de operações de divisão idênticas é atribuído a um Double e um Single valor. Depois que o valor Single é convertido em um Double, uma comparação dos dois valores mostra que eles são desiguais.
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 esse problema, use o Double no lugar do tipo de Single dados ou use o Round método para que ambos os valores tenham a mesma precisão.
Além disso, o resultado das operações aritméticas e de atribuição com Double valores pode diferir ligeiramente consoante a plataforma devido à perda de precisão do Double tipo. Por exemplo, o resultado de atribuir um valor literal Double pode diferir nas versões de 32 e 64 bits do .NET. O exemplo a seguir ilustra essa diferença quando o valor literal -4,42330604244772E-305 e uma variável cujo valor é -4,42330604244772E-305 são atribuídos a uma Double variável. Note que o resultado do método, Parse(String) neste caso, não sofre perda de precisão.
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
Teste de igualdade
Para serem considerados iguais, dois valores Double devem representar valores idênticos. No entanto, devido a diferenças na precisão entre os valores, ou devido a uma perda de precisão por um ou ambos os valores, os valores de vírgula flutuante que se espera que sejam idênticos muitas vezes acabam por ser desiguais devido a diferenças nos seus dígitos menos significativos. Como resultado, chamadas para o método Equals para determinar se dois valores são iguais, ou chamadas para o método CompareTo para determinar a relação entre dois valores Double, geralmente produzem resultados inesperados. Isto é evidente no exemplo seguinte, onde dois valores aparentemente iguais Double acabam por ser desiguais porque o primeiro tem 15 dígitos de precisão, enquanto o segundo tem 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
Nos casos em que uma perda de precisão provavelmente afetará o resultado de uma comparação, pode adotar qualquer uma das seguintes alternativas em vez de chamar os métodos Equals ou CompareTo:
Chame o método Math.Round para garantir que ambos os valores tenham a mesma precisão. O exemplo a seguir modifica um exemplo anterior para usar essa abordagem para que dois valores fracionários sejam 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: TrueO problema da precisão continua a aplicar-se ao arredondamento dos valores médios. Para obter mais informações, consulte o método Math.Round(Double, Int32, MidpointRounding).
Teste para igualdade aproximada em vez de igualdade. Isso requer que você defina uma quantidade absoluta pela qual os dois valores podem diferir, mas ainda assim ser iguais, ou que você defina uma quantidade relativa pela qual o valor menor pode divergir do valor maior.
Warning
Double.Epsilon às vezes é usado como uma medida absoluta da distância entre dois valores Double ao testar a igualdade. No entanto, Double.Epsilon mede o menor valor possível que pode ser adicionado ou subtraído de um Double cujo valor é zero. Para a maioria dos valores de Double positivos e negativos, o valor de Double.Epsilon é muito pequeno para ser detetado. Portanto, exceto para valores que são zero, não recomendamos seu uso em testes de igualdade.
O exemplo a seguir usa a última abordagem para definir um método
IsApproximatelyEqualque testa a diferença relativa entre dois valores. O método divide porMath.Max(value1, value2), de modo que a comparação é relativa ao maior (em magnitude) dos dois valores, o que coloca o resultado na ordem correta de grandeza. SeMath.Maxdevolver zero (o que acontece quando um valor é zero e o outro negativo), o método volta aMath.Min(value1, value2)usar o valor não nulo como divisor. Ele também contrasta o resultado de chamadas para o métodoIsApproximatelyEquale o 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 de vírgula flutuante e exceções
Ao contrário das operações com tipos integrais, que lançam a DivideByZeroException para divisão por zero ou uma OverflowException para estouro num contexto controlado, operações com valores de ponto flutuante não lançam exceções. Em vez disso, em situações excecionais, o resultado de uma operação de ponto flutuante é zero, infinito positivo, infinito negativo ou não um número (NaN):
Se o resultado de uma operação de ponto flutuante for muito pequeno para o formato de destino, o resultado será zero. Isso pode ocorrer quando dois números muito pequenos são multiplicados, como mostra o exemplo a seguir.
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: TrueSe a magnitude do resultado de uma operação de ponto flutuante exceder a gama do formato de destino, o resultado da operação é PositiveInfinity ou NegativeInfinity, conforme apropriado ao sinal do resultado. O resultado de uma operação que transborda Double.MaxValue é PositiveInfinitye o resultado de uma operação que transborda Double.MinValue é NegativeInfinity, como mostra o exemplo a seguir.
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 também resulta de uma divisão por zero com um dividendo positivo, e NegativeInfinity resulta de uma divisão por zero com um dividendo negativo.
Se uma operação de ponto flutuante for inválida, o resultado da operação será NaN. Por exemplo, NaN resulta das seguintes operações:
Divisão por zero com um dividendo de zero. Note-se que outros casos de divisão por zero resultam em PositiveInfinity ou NegativeInfinity.
Qualquer operação de ponto flutuante com uma entrada inválida. Por exemplo, chamar o Math.Sqrt método com um valor negativo retorna NaN, assim como chamar o Math.Acos método com um valor maior que um ou menor que negativo.
Qualquer operação com um argumento cujo valor é Double.NaN.
Conversões de tipos
A estrutura Double não define nenhum operador de conversão explícito ou implícito; em vez disso, as conversões são implementadas pelo compilador.
A conversão do valor de qualquer tipo numérico primitivo para Double é uma conversão de alargamento e, portanto, não requer um operador de conversão explícito ou uma chamada a um método de conversão, a menos que um compilador o exija explicitamente. Por exemplo, o compilador C# requer um operador de casting para conversões de Decimal para Double, enquanto o compilador Visual Basic não o faz. O exemplo a seguir converte o valor mínimo ou máximo de outros tipos numéricos primitivos em um 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)
Além disso, os valores SingleSingle.NaN, Single.PositiveInfinitye Single.NegativeInfinity convertem em Double.NaN, Double.PositiveInfinitye Double.NegativeInfinity, respectivamente.
Observe que a conversão do valor de alguns tipos numéricos para um valor Double pode envolver uma perda de precisão. Como o exemplo ilustra, uma perda de precisão é possível ao converter Decimal, Int64e UInt64 valores em Double valores.
A conversão de um valor Double para um valor de qualquer outro tipo de dado numérico primitivo é uma conversão de estreitamento e requer um operador cast (em C#), um método de conversão (em Visual Basic) ou uma chamada para um método Convert. Os valores que estão fora do intervalo do tipo de dados de destino, que são definidos pelas propriedades MinValue e MaxValue do tipo de destino, se comportam conforme mostrado na tabela a seguir.
| Tipo de destino | Result |
|---|---|
| Qualquer tipo integral | Uma exceção OverflowException se a conversão ocorrer em um contexto verificado. Se a conversão ocorrer num contexto sem verificação (o padrão em C#), a operação de conversão é bem-sucedida, mas o valor excede. |
| Decimal | Uma OverflowException exceção. |
| Single |
Single.NegativeInfinity para valores negativos. Single.PositiveInfinity para valores positivos. |
Além disso, Double.NaN, Double.PositiveInfinitye Double.NegativeInfinity lançam uma exceção OverflowException para conversões em inteiros em um contexto verificado, mas esses valores comportam-se de forma inesperada quando convertidos em inteiros em um contexto não verificado. Para conversões para Decimal, eles sempre lançam um OverflowException. Para conversões para Single, convertem-se em Single.NaN, Single.PositiveInfinitye Single.NegativeInfinity, respectivamente.
Pode resultar uma perda de precisão ao converter um Double valor para outro tipo numérico. No caso de converter para qualquer um dos tipos integrais, como mostra a saída do exemplo, o componente fracionário perde-se quando o valor Double é arredondado (como em Visual Basic) ou truncado (como em C#). Para conversões para Decimal e Single valores, o valor Double pode não ter uma representação precisa no tipo de dados de destino.
O exemplo a seguir converte vários valores de Double em vários outros tipos numéricos. As conversões ocorrem num contexto verificado em Visual Basic (o padrão), em C# (devido à palavra-chave checked) e em F# (devido ao módulo Checked). A saída do exemplo mostra o resultado de conversões em um contexto verificado e não verificado. Você pode executar conversões em um contexto não verificado no Visual Basic compilando com a opção de compilador /removeintchecks+, em C# comentando a instrução checked e em F# comentando a instrução 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 mais informações sobre a conversão de tipos numéricos, veja
Funcionalidade de ponto flutuante
A Double estrutura e os tipos relacionados fornecem métodos para realizar operações nas seguintes áreas:
Comparação de valores. Você pode chamar o método Equals para determinar se dois valores Double são iguais ou o método CompareTo para determinar a relação entre dois valores.
A estrutura Double também suporta um conjunto completo de operadores de comparação. Por exemplo, você pode testar a igualdade ou a desigualdade, ou determinar se um valor é maior ou igual a outro. Se um dos operandos for um tipo numérico diferente de um Double, ele será convertido em um Double antes de executar a comparação.
Warning
Devido a diferenças de precisão, dois Double valores que se espera serem iguais podem revelar-se desiguais, o que afeta o resultado da comparação. Para informações sobre como comparar dois Double valores, consulte a secção Teste de igualdade .
Você também pode chamar os métodos IsNaN, IsInfinity, IsPositiveInfinitye IsNegativeInfinity para testar esses valores especiais.
Operações matemáticas. Operações aritméticas comuns, como adição, subtração, multiplicação e divisão, são implementadas por compiladores de linguagem ou pelas instruções da Common Intermediate Language (CIL), em vez de por métodos Double. Se um dos operandos numa operação matemática for de um tipo numérico diferente de um Double, é convertido para a Double antes de executar a operação. O resultado da operação também é um Double valor.
Outras operações matemáticas podem ser realizadas chamando métodos
static(Sharedem Visual Basic) na classe System.Math. Inclui métodos adicionais comumente usados para aritmética (como Math.Abs, , e Math.Sign), geometria (como Math.Sqrt e Math.Cos), e cálculo (como Math.SinMath.Log).Você também pode manipular os bits individuais em um valor Double. O BitConverter.DoubleToInt64Bits método preserva o padrão de bits de um valor Double num inteiro de 64 bits. O método BitConverter.GetBytes(Double) retorna seu padrão de bits em uma matriz de bytes.
Arredondamento. O arredondamento é frequentemente usado como uma técnica para reduzir o impacto das diferenças entre valores causadas por problemas de representação e precisão de ponto flutuante. Você pode arredondar um valor Double chamando o método Math.Round.
Formatação. Você pode converter um Double valor em sua representação de cadeia de caracteres chamando o ToString método ou usando o recurso de formatação composta. Para obter informações sobre como as cadeias de caracteres de formato controlam a representação de cadeias de caracteres de valores de vírgula flutuante, consulte Cadeias de caracteres de formato numérico padrão e Cadeias de caracteres de formato numérico personalizadas.
Analisar cadeias de caracteres. Você pode converter a representação em cadeia de caracteres de um valor de ponto flutuante em um valor Double chamando o método Parse ou TryParse. Se a operação de análise falhar, o método Parse lançará uma exceção, enquanto o método TryParse retornará
false.Conversão de tipo. A estrutura Double fornece uma implementação explícita de interface para a interface IConvertible, que suporta a conversão entre quaisquer dois tipos de dados .NET padrão. Os compiladores de linguagem também suportam a conversão implícita de valores de todos os outros tipos numéricos padrão em Double valores. A conversão de um valor de qualquer tipo numérico padrão para um Double é uma conversão de ampliação e não requer que o utilizador utilize um operador de conversão ou um método de conversão.
No entanto, a conversão de Int64 e Single valores pode envolver uma perda de precisão. A tabela a seguir lista as diferenças de precisão para cada um desses tipos:
Tipo Máxima precisão Precisão interna Double 15 17 Int64 19 dígitos decimais 19 dígitos decimais Single 7 dígitos decimais 9 dígitos decimais O problema da precisão afeta com mais frequência os valores Single que são convertidos em valores Double. No exemplo a seguir, dois valores produzidos por operações de divisão idênticas são desiguais porque um dos valores é um valor de ponto flutuante de precisão única convertido em .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
| Name | Descrição |
|---|---|
| E |
Representa a base logarítmica natural, especificada pela constante, e. |
| Epsilon |
Representa o menor valor positivo Double que seja maior que zero. Este campo é constante. |
| MaxValue |
Representa o maior valor possível de um Double. Este campo é constante. |
| MinValue |
Representa o menor valor possível de um Double. Este campo é constante. |
| NaN |
Representa um valor que não é um número ( |
| NegativeInfinity |
Representa o infinito negativo. Este campo é constante. |
| NegativeZero |
Representa o número menos zero (-0). |
| Pi |
Representa a razão entre a circunferência de um círculo e o seu diâmetro, especificada pela constante, π. |
| PositiveInfinity |
Representa o infinito positivo. Este campo é constante. |
| Tau |
Representa o número de radianos numa volta, especificado pela constante, τ. |
Métodos
| Name | Descrição |
|---|---|
| Abs(Double) |
Calcula o absoluto de um valor. |
| Acos(Double) |
Calcula o arc-cosseno de um valor. |
| Acosh(Double) |
Calcula o arc-cosseno hiperbólico de um valor. |
| AcosPi(Double) |
Calcula o arc-cosseno de um valor e divide o resultado por |
| Asin(Double) |
Calcula o seno de arco de um valor. |
| Asinh(Double) |
Calcula o arco-seno hiperbólico de um valor. |
| AsinPi(Double) |
Calcula o arco-seno de um valor e divide o resultado por |
| Atan(Double) |
Calcula a tangente de arco de um valor. |
| Atan2(Double, Double) |
Calcula o arco tangente do quociente de dois valores. |
| Atan2Pi(Double, Double) |
Calcula a tangente de arco para o quociente de dois valores e divide o resultado por |
| Atanh(Double) |
Calcula a tangente hiperbólica de arco de um valor. |
| AtanPi(Double) |
Calcula o arco tangente de um valor e divide o resultado por pi. |
| BitDecrement(Double) |
Devolve o maior valor que se compara a menos do que um valor especificado. |
| BitIncrement(Double) |
Devolve o menor valor que se compara a um valor especificado. |
| Cbrt(Double) |
Calcula a raiz cúbica de um valor. |
| Ceiling(Double) |
Calcula o teto de um valor. |
| Clamp(Double, Double, Double) |
Fixa um valor a um valor mínimo e máximo inclusivo. |
| ClampNative(Double, Double, Double) |
Fixa um valor a um valor mínimo e máximo inclusivo usando comportamentos específicos da plataforma para |
| CompareTo(Double) |
Compara esta instância com um número de ponto flutuante de dupla precisão especificado e devolve um inteiro que indica se o valor desta instância é menor, igual ou superior ao valor do número de ponto flutuante de dupla precisão especificado. |
| CompareTo(Object) |
Compara esta instância com um objeto especificado e devolve um inteiro que indica se o valor desta instância é menor, igual ou superior ao valor do objeto especificado. |
| ConvertToInteger<TInteger>(Double) |
Converte um valor para um tipo inteiro especificado usando saturação no overflow |
| ConvertToIntegerNative<TInteger>(Double) |
Converte um valor para um tipo inteiro especificado usando o comportamento específico da plataforma no overflow. |
| CopySign(Double, Double) |
Copia o sinal de um valor para o sinal de outro valor. |
| Cos(Double) |
Calcula o cosseno de um valor. |
| Cosh(Double) |
Calcula o cosseno hiperbólico de um valor. |
| CosPi(Double) |
Calcula o cosseno de um valor que foi multiplicado por |
| CreateChecked<TOther>(TOther) |
Cria uma instância do tipo atual a partir de um valor, lançando uma exceção de overflow para quaisquer valores que estejam fora do intervalo representável do tipo atual. |
| CreateSaturating<TOther>(TOther) |
Cria uma instância do tipo atual a partir de um valor, saturando quaisquer valores que estejam fora do intervalo representável do tipo atual. |
| CreateTruncating<TOther>(TOther) |
Cria uma instância do tipo atual a partir de um valor, truncando quaisquer valores que estejam fora do intervalo representável do tipo atual. |
| DegreesToRadians(Double) |
Converte um dado valor de graus para radianos. |
| Equals(Double) |
Devolve um valor que indica se esta instância e um objeto especificado Double representam o mesmo valor. |
| Equals(Object) |
Devolve um valor que indica se esta instância é igual a um objeto especificado. |
| Exp(Double) |
Computações |
| Exp10(Double) |
Computações |
| Exp10M1(Double) |
Calcula |
| Exp2(Double) |
Computações |
| Exp2M1(Double) |
Calcula |
| ExpM1(Double) |
Calcula |
| Floor(Double) |
Calcula o mínimo de um valor. |
| FusedMultiplyAdd(Double, Double, Double) |
Calcula a multiplicação-soma fundida de três valores. |
| GetHashCode() |
Devolve o código de hash para esta instância. |
| GetTypeCode() | |
| Hypot(Double, Double) |
Calcula a hipotenusa dados dois valores que representam os comprimentos dos lados mais curtos num triângulo retângulo. |
| Ieee754Remainder(Double, Double) |
Calcula os restantes dois valores especificados pelo IEEE 754. |
| ILogB(Double) |
Calcula o logaritmo inteiro de um valor. |
| IsEvenInteger(Double) |
Determina se um valor representa um número inteiro par. |
| IsFinite(Double) |
Determina se o valor especificado é finito (zero, subnormal ou normal). |
| IsInfinity(Double) |
Devolve um valor que indica se o número especificado se avalia para o infinito negativo ou positivo. |
| IsInteger(Double) |
Determina se um valor representa um valor integral. |
| IsNaN(Double) |
Devolve um valor que indica se o valor especificado não é um número (NaN). |
| IsNegative(Double) |
Determina se o valor especificado é negativo. |
| IsNegativeInfinity(Double) |
Devolve um valor que indica se o número especificado se avalia até menos infinito. |
| IsNormal(Double) |
Determina se o valor especificado é normal. |
| IsOddInteger(Double) |
Determina se um valor representa um número inteiro ímpar. |
| IsPositive(Double) |
Determina se um valor é positivo. |
| IsPositiveInfinity(Double) |
Devolve um valor que indica se o número especificado equivale a infinito positivo. |
| IsPow2(Double) |
Determina se um valor é uma potência de dois. |
| IsRealNumber(Double) |
Determina se um valor representa um número real. |
| IsSubnormal(Double) |
Determina se o valor especificado é subnormal. |
| Lerp(Double, Double, Double) |
Realiza uma interpolação linear entre dois valores com base no peso dado. |
| Log(Double, Double) |
Calcula o logaritmo de um valor na base especificada. |
| Log(Double) |
Calcula o logaritmo natural |
| Log10(Double) |
Calcula o logaritmo em base 10 de um valor. |
| Log10P1(Double) |
Calcula o logaritmo em base 10 de um valor mais um. |
| Log2(Double) |
Calcula o log2 de um valor. |
| Log2P1(Double) |
Calcula o logaritmo em base 2 de um valor mais um. |
| LogP1(Double) |
Calcula o logaritmo natural ( |
| Max(Double, Double) |
Compara dois valores para calcular qual é maior. |
| MaxMagnitude(Double, Double) |
Compara dois valores para calcular qual é maior. |
| MaxMagnitudeNumber(Double, Double) |
Compara dois valores para calcular qual tem maior magnitude e devolve o outro valor se uma entrada for |
| MaxNative(Double, Double) |
Compara dois valores para calcular qual é maior usando comportamento específico da plataforma para |
| MaxNumber(Double, Double) |
Compara dois valores para calcular qual é maior e devolve o outro valor se uma entrada for |
| Min(Double, Double) |
Compara dois valores para calcular qual é menor. |
| MinMagnitude(Double, Double) |
Compara dois valores para calcular qual é menor. |
| MinMagnitudeNumber(Double, Double) |
Compara dois valores para calcular que tem a magnitude menor e devolve o outro valor se uma entrada for |
| MinNative(Double, Double) |
Compara dois valores para calcular qual é menor usando comportamento específico da plataforma para |
| MinNumber(Double, Double) |
Compara dois valores para calcular qual é menor e devolve o outro valor se uma entrada for |
| MultiplyAddEstimate(Double, Double, Double) |
Calcula uma estimativa de ( |
| Parse(ReadOnlySpan<Byte>, IFormatProvider) |
Analisa um intervalo de caracteres UTF-8 num valor. |
| Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider) |
Analisa um intervalo de caracteres UTF-8 num valor. |
| Parse(ReadOnlySpan<Char>, IFormatProvider) |
Divide um intervalo de caracteres num valor. |
| Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider) |
Converte um intervalo de caracteres que contém a representação em cadeia de um número num estilo especificado e formato específico de cultura para o seu equivalente numérico de ponto flutuante de dupla precisão. |
| Parse(String, IFormatProvider) |
Converte a representação da cadeia de um número num formato específico de cultura para o seu equivalente numérico de ponto flutuante de dupla precisão. |
| Parse(String, NumberStyles, IFormatProvider) |
Converte a representação em cadeia de um número num estilo especificado e formato específico de cultura para o seu equivalente numérico de ponto flutuante de dupla precisão. |
| Parse(String, NumberStyles) |
Converte a representação em cadeia de um número num estilo especificado para o seu equivalente em ponto flutuante de dupla precisão. |
| Parse(String) |
Converte a representação em cadeia de um número para o seu equivalente em ponto flutuante de dupla precisão. |
| Pow(Double, Double) |
Calcula um valor elevado para uma dada potência. |
| RadiansToDegrees(Double) |
Converte um dado valor de radianos em graus. |
| ReciprocalEstimate(Double) |
Calcula uma estimativa do recíproco de um valor. |
| ReciprocalSqrtEstimate(Double) |
Calcula uma estimativa da raiz quadrada recíproca de um valor. |
| RootN(Double, Int32) |
Calcula a raiz n-ésima de um valor. |
| Round(Double, Int32, MidpointRounding) |
Arredonda um valor para um número especificado de dígitos fracionários usando o modo de arredondamento padrão (ToEven). |
| Round(Double, Int32) |
Arredonda um valor para um número especificado de dígitos fracionários usando o modo de arredondamento padrão (ToEven). |
| Round(Double, MidpointRounding) |
Arredonda um valor para o número inteiro mais próximo usando o modo de arredondamento especificado. |
| Round(Double) |
Arredonda um valor para o número inteiro mais próximo usando o modo de arredondamento padrão (ToEven). |
| ScaleB(Double, Int32) |
Calcula o produto de um valor e da sua base raix elevada para a potência especificada. |
| Sign(Double) |
Calcula o sinal de um valor. |
| Sin(Double) |
Calcula o seno de um valor. |
| SinCos(Double) |
Calcula o seno e o cosseno de um valor. |
| SinCosPi(Double) |
Calcula o seno e o cosseno de um valor. |
| Sinh(Double) |
Calcula o seno hiperbólico de um valor. |
| SinPi(Double) |
Calcula o seno de um valor que foi multiplicado por |
| Sqrt(Double) |
Calcula a raiz quadrada de um valor. |
| Tan(Double) |
Calcula a tangente de um valor. |
| Tanh(Double) |
Calcula a tangente hiperbólica de um valor. |
| TanPi(Double) |
Calcula a tangente de um valor que foi multiplicado por |
| ToString() |
Converte o valor numérico desta instância para a sua representação equivalente em cadeias. |
| ToString(IFormatProvider) |
Converte o valor numérico desta instância para a sua representação equivalente de cadeias usando a informação de formato específica da cultura especificada. |
| ToString(String, IFormatProvider) |
Converte o valor numérico desta instância para a sua representação equivalente de cadeias usando o formato especificado e a informação específica de formato da cultura. |
| ToString(String) |
Converte o valor numérico desta instância para a sua representação equivalente em cadeias, usando o formato especificado. |
| Truncate(Double) |
Trunca um valor. |
| TryFormat(Span<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider) |
Tenta formatar o valor da instância atual como UTF-8 no intervalo fornecido de bytes. |
| TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider) |
Tenta formatar o valor da instância dupla atual no intervalo de caracteres fornecido. |
| TryParse(ReadOnlySpan<Byte>, Double) |
Tenta converter um espaço de caracteres UTF-8 contendo a representação de cadeias de um número para o seu equivalente de número de ponto flutuante de dupla precisão. |
| TryParse(ReadOnlySpan<Byte>, IFormatProvider, Double) |
Tenta separar um intervalo de caracteres UTF-8 num valor. |
| TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, Double) |
Tenta separar um intervalo de caracteres UTF-8 num valor. |
| TryParse(ReadOnlySpan<Char>, Double) |
Converte a representação de abrangência de um número num estilo especificado e formato específico de cultura para o seu equivalente numérico em ponto flutuante de dupla precisão. Um valor de retorno indica se a conversão teve sucesso ou falhou. |
| TryParse(ReadOnlySpan<Char>, IFormatProvider, Double) |
Tenta separar um intervalo de caracteres num valor. |
| TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Double) |
Converte um intervalo de caracteres contendo a representação de cadeias de um número num estilo especificado e formato específico de cultura para o seu equivalente numérico de ponto flutuante de dupla precisão. Um valor de retorno indica se a conversão teve sucesso ou falhou. |
| TryParse(String, Double) |
Converte a representação em cadeia de um número para o seu equivalente em ponto flutuante de dupla precisão. Um valor de retorno indica se a conversão teve sucesso ou falhou. |
| TryParse(String, IFormatProvider, Double) |
Tenta analisar uma cadeia num valor. |
| TryParse(String, NumberStyles, IFormatProvider, Double) |
Converte a representação em cadeia de um número num estilo especificado e formato específico de cultura para o seu equivalente numérico de ponto flutuante de dupla precisão. Um valor de retorno indica se a conversão teve sucesso ou falhou. |
Operadores
| Name | Descrição |
|---|---|
| Equality(Double, Double) |
Devolve um valor que indica se dois valores especificados Double são iguais. |
| GreaterThan(Double, Double) |
Devolve um valor que indica se um valor especificado Double é maior do que outro valor especificado Double . |
| GreaterThanOrEqual(Double, Double) |
Devolve um valor que indica se um valor especificado Double é maior ou igual a outro valor especificado Double . |
| Inequality(Double, Double) |
Devolve um valor que indica se dois valores especificados Double não são iguais. |
| LessThan(Double, Double) |
Devolve um valor que indica se um valor especificado Double é inferior a outro valor especificado Double . |
| LessThanOrEqual(Double, Double) |
Devolve um valor que indica se um valor especificado Double é menor ou igual a outro valor especificado Double . |
Implementações de Interface Explícita
| Name | Descrição |
|---|---|
| IAdditionOperators<Double,Double,Double>.Addition(Double, Double) |
Soma dois valores para calcular a sua soma. |
| IAdditiveIdentity<Double,Double>.AdditiveIdentity |
Obtém a identidade aditiva do tipo atual. |
| IBinaryNumber<Double>.AllBitsSet |
Obtém uma instância do tipo binário em que todos os bits estão definidos. |
| IBitwiseOperators<Double,Double,Double>.BitwiseAnd(Double, Double) |
Calcula o bit a bit de dois valores. |
| IBitwiseOperators<Double,Double,Double>.BitwiseOr(Double, Double) |
Calcula o bit-or-ou de dois valores. |
| IBitwiseOperators<Double,Double,Double>.ExclusiveOr(Double, Double) |
Calcula o ou exclusivo de dois valores. |
| IBitwiseOperators<Double,Double,Double>.OnesComplement(Double) |
Calcula a representação de um complemento de um dado valor. |
| IComparable.CompareTo(Object) |
Compara a instância atual com outro objeto do mesmo tipo e devolve um inteiro que indica se a instância atual precede, segue ou ocorre na mesma posição na ordem de ordenação que o outro objeto. |
| IConvertible.GetTypeCode() |
Devolve o TypeCode para este caso. |
| IConvertible.ToBoolean(IFormatProvider) |
Para uma descrição deste elemento, veja ToBoolean(IFormatProvider). |
| IConvertible.ToByte(IFormatProvider) |
Para uma descrição deste elemento, veja ToByte(IFormatProvider). |
| IConvertible.ToChar(IFormatProvider) |
Esta conversão não é suportada. Tentar usar este método lança um InvalidCastException. |
| IConvertible.ToDateTime(IFormatProvider) |
Esta conversão não é suportada. Tentar usar este método lança um InvalidCastException. |
| IConvertible.ToDecimal(IFormatProvider) |
Para uma descrição deste elemento, veja ToDecimal(IFormatProvider). |
| IConvertible.ToDouble(IFormatProvider) |
Para uma descrição deste elemento, veja ToDouble(IFormatProvider). |
| IConvertible.ToInt16(IFormatProvider) |
Para uma descrição deste elemento, veja ToInt16(IFormatProvider). |
| IConvertible.ToInt32(IFormatProvider) |
Para uma descrição deste elemento, veja ToInt32(IFormatProvider). |
| IConvertible.ToInt64(IFormatProvider) |
Para uma descrição deste elemento, veja ToInt64(IFormatProvider). |
| IConvertible.ToSByte(IFormatProvider) |
Para uma descrição deste elemento, veja ToSByte(IFormatProvider). |
| IConvertible.ToSingle(IFormatProvider) |
Para uma descrição deste elemento, veja ToSingle(IFormatProvider). |
| IConvertible.ToType(Type, IFormatProvider) |
Para uma descrição deste elemento, veja ToType(Type, IFormatProvider). |
| IConvertible.ToUInt16(IFormatProvider) |
Para uma descrição deste elemento, veja ToUInt16(IFormatProvider). |
| IConvertible.ToUInt32(IFormatProvider) |
Para uma descrição deste elemento, veja ToUInt32(IFormatProvider). |
| IConvertible.ToUInt64(IFormatProvider) |
Para uma descrição deste elemento, veja ToUInt64(IFormatProvider). |
| IDecrementOperators<Double>.Decrement(Double) |
Diminui um valor. |
| IDivisionOperators<Double,Double,Double>.Division(Double, Double) |
Divide um valor por outro para calcular o seu quociente. |
| IFloatingPoint<Double>.GetExponentByteCount() |
Obtém o número de bytes que serão escritos como parte de TryWriteExponentLittleEndian(Span<Byte>, Int32). |
| IFloatingPoint<Double>.GetExponentShortestBitLength() |
Obtém o comprimento, em bits, da representação do complemento dos dois mais curtos do expoente atual. |
| IFloatingPoint<Double>.GetSignificandBitLength() |
Obtém o comprimento, em pedaços, do significado atual. |
| IFloatingPoint<Double>.GetSignificandByteCount() |
Obtém o número de bytes que serão escritos como parte de TryWriteSignificandLittleEndian(Span<Byte>, Int32). |
| IFloatingPoint<Double>.TryWriteExponentBigEndian(Span<Byte>, Int32) |
Tenta escrever o expoente atual, em formato big-endian, para um determinado intervalo. |
| IFloatingPoint<Double>.TryWriteExponentLittleEndian(Span<Byte>, Int32) |
Tenta escrever o expoente atual, em formato little-endian, para um determinado intervalo. |
| IFloatingPoint<Double>.TryWriteSignificandBigEndian(Span<Byte>, Int32) |
Tenta escrever o significado atual, em formato big-endian, para um determinado intervalo. |
| IFloatingPoint<Double>.TryWriteSignificandLittleEndian(Span<Byte>, Int32) |
Tenta escrever o significado atual, em formato little-endian, para um determinado intervalo. |
| IFloatingPointConstants<Double>.E |
Obtém a constante |
| IFloatingPointConstants<Double>.Pi |
Obtém a constante |
| IFloatingPointConstants<Double>.Tau |
Obtém a constante |
| IFloatingPointIeee754<Double>.Epsilon |
Obtém o menor valor tal que pode ser somado a |
| IFloatingPointIeee754<Double>.NaN |
Obtém um valor que representa |
| IFloatingPointIeee754<Double>.NegativeInfinity |
Obtém um valor que representa negativo |
| IFloatingPointIeee754<Double>.NegativeZero |
Obtém um valor que representa negativo |
| IFloatingPointIeee754<Double>.PositiveInfinity |
Obtém um valor que representa positivo |
| IIncrementOperators<Double>.Increment(Double) |
Incrementa um valor. |
| IMinMaxValue<Double>.MaxValue |
Obtém o valor máximo do tipo atual. |
| IMinMaxValue<Double>.MinValue |
Obtém o valor mínimo do tipo atual. |
| IModulusOperators<Double,Double,Double>.Modulus(Double, Double) |
Divide dois valores para calcular o seu módulo ou resto. |
| IMultiplicativeIdentity<Double,Double>.MultiplicativeIdentity |
Obtém a identidade multiplicativa do tipo atual. |
| IMultiplyOperators<Double,Double,Double>.Multiply(Double, Double) |
Multiplica dois valores juntos para calcular o seu produto. |
| INumberBase<Double>.IsCanonical(Double) |
Determina se um valor está na sua representação canónica. |
| INumberBase<Double>.IsComplexNumber(Double) |
Determina se um valor representa um número complexo. |
| INumberBase<Double>.IsImaginaryNumber(Double) |
Determina se um valor representa um número puramente imaginário. |
| INumberBase<Double>.IsZero(Double) |
Determina se um valor é zero. |
| INumberBase<Double>.One |
Obtém o valor |
| INumberBase<Double>.Radix |
Obtém a raiz, ou base, para o tipo. |
| INumberBase<Double>.TryConvertFromChecked<TOther>(TOther, Double) |
Representa um número de ponto flutuante de precisão dupla. |
| INumberBase<Double>.TryConvertFromSaturating<TOther>(TOther, Double) |
Representa um número de ponto flutuante de precisão dupla. |
| INumberBase<Double>.TryConvertFromTruncating<TOther>(TOther, Double) |
Representa um número de ponto flutuante de precisão dupla. |
| INumberBase<Double>.TryConvertToChecked<TOther>(Double, TOther) |
Tenta converter uma instância do tipo atual para outro tipo, lançando uma exceção de overflow para quaisquer valores que estejam fora do intervalo representável do tipo atual. |
| INumberBase<Double>.TryConvertToSaturating<TOther>(Double, TOther) |
Tenta converter uma instância do tipo atual para outro tipo, saturando quaisquer valores que estejam fora do intervalo representável do tipo atual. |
| INumberBase<Double>.TryConvertToTruncating<TOther>(Double, TOther) |
Tenta converter uma instância do tipo atual para outro tipo, truncando quaisquer valores que estejam fora do intervalo representável do tipo atual. |
| INumberBase<Double>.Zero |
Obtém o valor |
| ISignedNumber<Double>.NegativeOne |
Obtém o valor |
| ISubtractionOperators<Double,Double,Double>.Subtraction(Double, Double) |
Subtrai dois valores para calcular a sua diferença. |
| IUnaryNegationOperators<Double,Double>.UnaryNegation(Double) |
Calcula a negação unária de um valor. |
| IUnaryPlusOperators<Double,Double>.UnaryPlus(Double) |
Calcula o plus unário de um valor. |
Aplica-se a
Segurança de Thread
Todos os membros deste tipo são seguros para fios. Os membros que parecem modificar o estado da instância retornam na verdade uma nova instância inicializada com o novo valor. Como em qualquer outro tipo, a leitura e escrita numa variável partilhada que contenha uma instância deste tipo deve ser protegida por um bloqueio para garantir a segurança do thread.
