Double Struct
Definizione
Importante
Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.
Rappresenta un numero in virgola mobile a doppia precisione.
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- Ereditarietà
- Attributi
- Implementazioni
-
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>
Esempio
Nell'esempio di codice seguente viene illustrato l'uso di 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
Commenti
Il Double tipo di valore rappresenta un numero a 64 bit a precisione doppia con valori compresi tra negativo 1,79769313486232e308 e 1,79769313486232e308, nonché zero positivo o negativo, PositiveInfinity, NegativeInfinitye non un numero (NaN). È destinato a rappresentare valori estremamente grandi (ad esempio distanze tra pianeti o galassie) o estremamente piccole (come la massa molecolare di una sostanza in chilogrammi) e che spesso sono imprecise (come la distanza dalla terra a un altro sistema solare). Il tipo Double è conforme allo standard IEC 60559:1989 (IEEE 754) per l'aritmetica a virgola mobile binaria.
Rappresentazione a virgola mobile e precisione
Il Double tipo di dati archivia i valori a virgola mobile a precisione doppia in un formato binario a 64 bit, come illustrato nella tabella seguente:
| Parte | Bit |
|---|---|
| Significato o mantissa | 0-51 |
| Exponent | 52-62 |
| Segno (0 = Positivo, 1 = Negativo) | 63 |
Proprio come le frazioni decimali non sono in grado di rappresentare con precisione alcuni valori frazionari (ad esempio 1/3 o Math.PI), le frazioni binarie non sono in grado di rappresentare alcuni valori frazionari. Ad esempio, 1/10, rappresentato esattamente da .1 come frazione decimale, è rappresentato da .001100110011 come frazione binaria, con il modello "0011" ripetuto all'infinito. In questo caso, il valore a virgola mobile fornisce una rappresentazione imprecisa del numero rappresentato. L'esecuzione di operazioni matematiche aggiuntive sul valore a virgola mobile originale tende spesso ad aumentare la sua mancanza di precisione. Ad esempio, se si confronta il risultato della moltiplicazione di .1 per 10 e l'aggiunta di .1 a .1 nove volte, si noterà che l'aggiunta, perché ha coinvolto otto altre operazioni, ha prodotto il risultato meno preciso. (Prima di .NET 10, questa disparità è evidente solo se vengono visualizzati i due valori Double usando la stringa di formato numerico "R" standard numeric, che visualizza fino a 17 cifre di precisione supportate dal 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
Poiché alcuni numeri non possono essere rappresentati esattamente come valori binari frazionari, i numeri a virgola mobile possono solo approssimare numeri reali.
Tutti i numeri a virgola mobile hanno anche un numero limitato di cifre significative, che determina anche quanto accuratamente un valore a virgola mobile approssima un numero reale. Un Double valore ha fino a 15 cifre decimali di precisione, anche se un massimo di 17 cifre viene mantenuto internamente. Ciò significa che alcune operazioni a virgola mobile potrebbero non avere la precisione necessaria per modificarne il valore. Di seguito ne viene illustrato un esempio. Definisce un valore a virgola mobile molto grande e aggiunge il prodotto di Double.Epsilon e un quadrilione. Il prodotto, tuttavia, è troppo piccolo per modificare il valore a virgola mobile originale. La sua cifra meno significativa è nei millesimi di unità, mentre la cifra più significativa del prodotto è 10-309.
using System;
public class Example14
{
public static void Main()
{
Double value = 123456789012.34567;
Double additional = Double.Epsilon * 1e15;
Console.WriteLine($"{value} + {additional} = {value + additional}");
}
}
// The example displays the following output:
// 123456789012.346 + 4.94065645841247E-309 = 123456789012.346
open System
let value = 123456789012.34567
let additional = Double.Epsilon * 1e15
printfn $"{value} + {additional} = {value + additional}"
// The example displays the following output:
// 123456789012.346 + 4.94065645841247E-309 = 123456789012.346
Module Example15
Public Sub Run()
Dim value As Double = 123456789012.34567
Dim additional As Double = Double.Epsilon * 1.0E+15
Console.WriteLine("{0} + {1} = {2}", value, additional,
value + additional)
End Sub
End Module
' The example displays the following output:
' 123456789012.346 + 4.94065645841247E-309 = 123456789012.346
La precisione limitata di un numero a virgola mobile ha diverse conseguenze:
Due numeri a virgola mobile che appaiono uguali per una particolare precisione potrebbero non essere uguali, perché le cifre meno significative sono diverse. Nell'esempio seguente vengono sommati una serie di numeri e il totale viene confrontato con il totale previsto.
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).I due valori sono diversi a causa di una perdita di precisione durante le operazioni di addizione. In questo caso, il problema può essere risolto chiamando il metodo Math.Round(Double, Int32) per arrotondare i valori Double alla precisione desiderata prima di eseguire il confronto.
Un'operazione matematica o di confronto che utilizza un numero a virgola mobile potrebbe non restituire lo stesso risultato se viene utilizzato un numero decimale, perché il numero a virgola mobile binario potrebbe non essere uguale al numero decimale. Un esempio precedente illustra questa operazione visualizzando il risultato della moltiplicazione di .1 per 10 e l'aggiunta di .1 volte.
Quando l'accuratezza nelle operazioni numeriche con valori frazionari è importante, è possibile usare il Decimal tipo anziché il Double tipo . Quando l'accuratezza nelle operazioni numeriche con valori integrali oltre l'intervallo dei Int128UInt128 tipi è importante, usare il BigInteger tipo .
I valori di Single hanno una precisione inferiore rispetto ai valori di Double. Un Single valore convertito in un valore apparentemente equivalente Double spesso non è uguale al Double valore a causa delle differenze di precisione. Nell'esempio seguente, il risultato di operazioni di divisione identiche viene assegnato a un valore Double e a un valore Single. Dopo il cast del valore Single a un Double, un confronto tra i due valori mostra che non sono uguali.
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: FalsePer evitare questo problema, usare il Double al posto del tipo di dati Single, oppure utilizzare il metodo Round in modo che entrambi i valori abbiano la stessa precisione.
Inoltre, il risultato di operazioni aritmetiche e di assegnazione con Double valori può essere leggermente diverso dalla piattaforma a causa della perdita di precisione del Double tipo. Ad esempio, il risultato dell'assegnazione di un valore letterale Double potrebbe differire nelle versioni a 32 bit e a 64 bit di .NET. L'esempio seguente illustra questa differenza quando il valore letterale -4.42330604244772E-305 e una variabile il cui valore è -4.42330604244772E-305 vengono assegnati a una Double variabile. Si noti che il risultato del Parse(String) metodo in questo caso non subisce una perdita di precisione.
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
Verificare l'uguaglianza
Per essere considerati uguali, due valori Double devono rappresentare valori identici. Tuttavia, a causa delle differenze di precisione tra valori o a causa di una perdita di precisione di uno o entrambi i valori, i valori a virgola mobile che si prevede siano identici spesso risultano diversi a causa delle differenze nelle cifre meno significative. Di conseguenza, le chiamate al metodo Equals per determinare se due valori sono uguali o chiamate al metodo CompareTo per determinare la relazione tra due valori Double, spesso producono risultati imprevisti. Questo è evidente nell'esempio seguente, dove due valori apparentemente uguali Double risultano diversi perché il primo ha 15 cifre di precisione, mentre il secondo ha 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
Nei casi in cui è probabile che una perdita di precisione influisca sul risultato di un confronto, è possibile adottare una delle alternative seguenti alla chiamata al Equals metodo o CompareTo :
Chiamare il metodo Math.Round per assicurarsi che entrambi i valori abbiano la stessa precisione. Nell'esempio seguente viene modificato un esempio precedente per usare questo approccio in modo che due valori frazionari siano equivalenti.
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: TrueIl problema della precisione si applica ancora all'arrotondamento dei valori del punto intermedio. Per altre informazioni, vedere il metodo Math.Round(Double, Int32, MidpointRounding).
Verificare l'uguaglianza approssimativa anziché l'uguaglianza. Ciò richiede che si definisci una quantità assoluta in base alla quale i due valori possono essere diversi ma comunque uguali o che definisci una quantità relativa in base alla quale il valore più piccolo può divergere dal valore più grande.
Avvertimento
Double.Epsilon viene talvolta usato come misura assoluta della distanza tra due valori Double durante il test dell'uguaglianza. Tuttavia, Double.Epsilon misura il valore più piccolo possibile a cui è possibile aggiungere o sottrarre un Double il cui valore è zero. Per la maggior parte dei valori di Double positivi e negativi, il valore di Double.Epsilon è troppo piccolo da rilevare. Pertanto, ad eccezione dei valori pari a zero, non è consigliabile usarlo nei test per verificarne l'uguaglianza.
Nell'esempio seguente viene usato il secondo approccio per definire un metodo
IsApproximatelyEqualche verifica la differenza relativa tra due valori. Il metodo divide perMath.Max(value1, value2)in modo che il confronto sia relativo al più grande (per grandezza) dei due valori, che posiziona il risultato nell'ordine di grandezza corretto. SeMath.Maxrestituisce zero (che si verifica quando un valore è zero e l'altro è negativo), il metodo si affida aMath.Min(value1, value2)per usare il valore diverso da zero come divisore. Confronta anche i risultati delle chiamate al metodoIsApproximatelyEquale al metodo 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
Valori a virgola mobile ed eccezioni
A differenza delle operazioni con tipi integrali, che generano un'eccezione DivideByZeroException per divisione per zero o un'eccezione OverflowException per overflow in un contesto verificato, le operazioni con valori a virgola mobile non generano eccezioni. In situazioni eccezionali, invece, il risultato di un'operazione a virgola mobile è zero, infinito positivo, infinito negativo o non un numero (NaN):
Se il risultato di un'operazione a virgola mobile è troppo piccolo per il formato di destinazione, il risultato è zero. Ciò può verificarsi quando vengono moltiplicati due numeri molto piccoli, come illustrato nell'esempio seguente.
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 la grandezza del risultato di un'operazione a virgola mobile supera l'intervallo del formato di destinazione, il risultato dell'operazione è PositiveInfinity o NegativeInfinity, come appropriato per il segno del risultato. Il risultato di un'operazione che esegue l'overflow Double.MaxValue è PositiveInfinitye il risultato di un'operazione che esegue l'overflow Double.MinValue è NegativeInfinity, come illustrato nell'esempio seguente.
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 risulta anche da una divisione per zero con un dividendo positivo, e NegativeInfinity risulta da una divisione per zero con un dividendo negativo.
Se un'operazione in virgola mobile è invalida, il risultato dell'operazione è NaN. Ad esempio, NaN risulta dalle seguenti operazioni:
Divisione per zero con dividendo pari a zero. Si noti che altri casi di divisione per zero comportano PositiveInfinity o NegativeInfinity.
Qualsiasi operazione a virgola mobile con un input non valido. Ad esempio, la chiamata al Math.Sqrt metodo con un valore negativo restituisce NaN, così come chiama il Math.Acos metodo con un valore maggiore di uno o minore di uno negativo.
Qualsiasi operazione con un argomento con valore pari a Double.NaN.
Conversioni di tipo
La struttura Double non definisce operatori di conversione espliciti o impliciti; Le conversioni vengono invece implementate dal compilatore.
La conversione del valore di qualsiasi tipo numerico primitivo in Double è una conversione ad un tipo di dati più ampio e pertanto non richiede un operatore di cast esplicito o una chiamata a un metodo di conversione, a meno che un compilatore non lo richieda espressamente. Ad esempio, il compilatore C# richiede un operatore di cast per le conversioni da Decimal a Double, mentre il compilatore Visual Basic non lo fa. Nell'esempio seguente viene convertito il valore minimo o massimo di altri tipi numerici primitivi in un oggetto 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)
Inoltre, i valori di SingleSingle.NaN, Single.PositiveInfinitye Single.NegativeInfinity vengono convertiti rispettivamente in Double.NaN, Double.PositiveInfinitye Double.NegativeInfinity.
Si noti che la conversione del valore di alcuni tipi numerici in un valore Double può comportare una perdita di precisione. Come illustrato nell'esempio, una perdita di precisione è possibile quando si converteno Decimalvalori , Int64e UInt64 in Double valori .
La conversione di un valore Double in un valore di qualsiasi altro tipo di dati numerici primitivi è una conversione di restringimento e richiede un operatore di cast (in C#), un metodo di conversione (in Visual Basic) o una chiamata a un metodo Convert. I valori che non rientrano nell'intervallo del tipo di dati di destinazione, definiti dalla MinValue del tipo di destinazione e dalle proprietà MaxValue, si comportano come illustrato nella tabella seguente.
| Tipo di destinazione | Result |
|---|---|
| Qualsiasi tipo integrale | Eccezione OverflowException se la conversione si verifica in un contesto controllato. Se la conversione si verifica in un contesto non controllato (impostazione predefinita in C#), l'operazione di conversione ha esito positivo ma il valore va in overflow. |
| Decimal | Un'eccezione OverflowException. |
| Single |
Single.NegativeInfinity per i valori negativi. Single.PositiveInfinity per i valori positivi. |
Inoltre, Double.NaN, Double.PositiveInfinitye Double.NegativeInfinity generano un OverflowException per le conversioni in numeri interi in un contesto controllato, ma questi valori vanno in overflow quando vengono convertiti in numeri interi in un contesto non controllato. Per le conversioni in Decimal, lanciano sempre un OverflowException. Per le conversioni in Single, vengono convertite rispettivamente in Single.NaN, Single.PositiveInfinitye Single.NegativeInfinity.
Una perdita di precisione può comportare la conversione di un Double valore in un altro tipo numerico. Nel caso della conversione in uno dei tipi integrali, come illustrato nell'output dell'esempio, il componente frazionaria viene perso quando il valore Double viene arrotondato (come in Visual Basic) o troncato (come in C#). Per le conversioni ai valori Decimal e Single, il valore Double potrebbe non avere una rappresentazione precisa nel tipo di dati di destinazione.
Nell'esempio seguente viene convertito un numero di valori Double in diversi altri tipi numerici. Le conversioni si verificano in un contesto controllato in Visual Basic (impostazione predefinita), in C# (a causa della parola chiave checked ) e in F# (a causa del modulo Checked ). L'output dell'esempio mostra il risultato per le conversioni sia in un contesto verificato che non verificato. È possibile eseguire conversioni in un contesto non selezionato in Visual Basic compilando con l'opzione del compilatore /removeintchecks+, in C# commentando l'istruzione checked e in F# commentando l'istruzione 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)
Per ulteriori informazioni sulla conversione dei tipi numerici, vedere Conversione di tipi in .NET e Tabelle di conversione di tipi.
Funzionalità a virgola mobile
La Double struttura e i tipi correlati forniscono metodi per eseguire operazioni nelle aree seguenti:
Confronto dei valori. È possibile chiamare il metodo Equals per determinare se due valori Double sono uguali o il metodo CompareTo per determinare la relazione tra due valori.
La struttura Double supporta anche un set completo di operatori di confronto. Ad esempio, è possibile verificare l'uguaglianza o la disuguaglianza oppure determinare se un valore è maggiore o uguale a un altro. Se uno degli operandi è un tipo numerico diverso da Double, viene convertito in un Double prima di eseguire il confronto.
Avvertimento
A causa delle differenze di precisione, due Double valori che si prevede siano uguali potrebbero risultare diversi, che influiscono sul risultato del confronto. Per informazioni sul confronto di due Double valori, vedere la sezione Test per l'uguaglianza .
È anche possibile chiamare i metodi IsNaN, IsInfinity, IsPositiveInfinitye IsNegativeInfinity per testare questi valori speciali.
Operazioni matematiche. Le operazioni aritmetiche comuni, ad esempio addizione, sottrazione, moltiplicazione e divisione, vengono implementate da compilatori del linguaggio e istruzioni CIL (Common Intermediate Language), anziché da Double metodi. Se uno degli operandi in un'operazione matematica è un tipo numerico diverso da Double, viene convertito in un Double prima di eseguire l'operazione. Il risultato dell'operazione è anche un valore Double.
È possibile eseguire altre operazioni matematiche chiamando metodi
static(Sharedin Visual Basic) nella classe System.Math. Includere metodi aggiuntivi comunemente usati per l'aritmetica (ad esempio Math.Abs, Math.Sign, e Math.Sqrt), la geometria (ad esempio Math.Cos e Math.Sin) e il calcolo (ad esempio Math.Log).È anche possibile modificare i singoli bit in un valore Double. Il BitConverter.DoubleToInt64Bits metodo mantiene il modello di bit di un Double valore in un intero a 64 bit. Il metodo BitConverter.GetBytes(Double) restituisce il modello di bit in una matrice di byte.
Arrotondamento. L'arrotondamento viene spesso usato come tecnica per ridurre l'impatto delle differenze tra valori causati da problemi di rappresentazione a virgola mobile e precisione. È possibile arrotondamento di un valore Double chiamando il metodo Math.Round.
Formattazione. È possibile convertire un Double valore nella relativa rappresentazione di stringa chiamando il ToString metodo o usando la funzionalità di formattazione composita. Per informazioni su come le stringhe di formato controllano la rappresentazione delle stringhe di valori a virgola mobile, vedere Stringhe di Formato Numerico Standard e Stringhe di Formato Numerico Personalizzato.
Analisi delle stringhe. È possibile convertire la rappresentazione di stringa di un valore a virgola mobile in un valore Double chiamando il metodo Parse o il metodo TryParse. Se l'operazione di analisi non riesce, il metodo Parse genera un'eccezione, mentre il metodo TryParse restituisce
false.Conversione di tipo. La struttura Double fornisce un'implementazione esplicita dell'interfaccia per l'interfaccia IConvertible, che supporta la conversione tra due tipi di dati .NET standard. I compilatori del linguaggio supportano anche la conversione implicita di valori di tutti gli altri tipi numerici standard in Double valori. La conversione di un valore di qualsiasi tipo numerico standard in un Double è una conversione verso un tipo più ampio e non richiede l'uso di un operatore di cast o di un metodo di conversione.
Tuttavia, la conversione di Int64 valori e Single può comportare una perdita di precisione. Nella tabella seguente sono elencate le differenze di precisione per ognuno di questi tipi:
TIPO Precisione massima Precisione interna Double 15 17 Int64 19 cifre decimali 19 cifre decimali Single 7 cifre decimali 9 cifre decimali Il problema della precisione influisce più frequentemente sui valori Single convertiti in valori Double. Nell'esempio seguente due valori prodotti da operazioni di divisione identiche non sono uguali perché uno dei valori è un valore a virgola mobile a precisione singola convertito in un oggetto 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
Campi
| Nome | Descrizione |
|---|---|
| E |
Rappresenta la base logaritmica naturale, specificata dalla costante, e. |
| Epsilon |
Rappresenta il valore positivo Double più piccolo maggiore di zero. Questo campo è costante. |
| MaxValue |
Rappresenta il valore massimo possibile di un oggetto Double. Questo campo è costante. |
| MinValue |
Rappresenta il valore più piccolo possibile di un oggetto Double. Questo campo è costante. |
| NaN |
Rappresenta un valore che non è un numero ( |
| NegativeInfinity |
Rappresenta l'infinito negativo. Questo campo è costante. |
| NegativeZero |
Rappresenta il numero negativo zero (-0). |
| Pi |
Rappresenta il rapporto tra la circonferenza di un cerchio e il relativo diametro, specificata dalla costante π. |
| PositiveInfinity |
Rappresenta l'infinito positivo. Questo campo è costante. |
| Tau |
Rappresenta il numero di radianti in un turno, specificato dalla costante, τ. |
Metodi
| Nome | Descrizione |
|---|---|
| Abs(Double) |
Calcola l'assoluto di un valore. |
| Acos(Double) |
Calcola l'arco-coseno di un valore. |
| Acosh(Double) |
Calcola l'arco-coseno iperbolico di un valore. |
| AcosPi(Double) |
Calcola l'arco coseno di un valore e divide il risultato per |
| Asin(Double) |
Calcola il seno arco di un valore. |
| Asinh(Double) |
Calcola il seno dell'arco iperbolico di un valore. |
| AsinPi(Double) |
Calcola il seno arco di un valore e divide il risultato per |
| Atan(Double) |
Calcola l'arco-tangente di un valore. |
| Atan2(Double, Double) |
Calcola l'arco tangente del quoziente di due valori. |
| Atan2Pi(Double, Double) |
Calcola l'arco-tangente per il quoziente di due valori e divide il risultato per |
| Atanh(Double) |
Calcola l'arco-tangente iperbolica di un valore. |
| AtanPi(Double) |
Calcola l'arco-tangente di un valore e divide il risultato per pi. |
| BitDecrement(Double) |
Restituisce il valore più grande che confronta meno di un valore specificato. |
| BitIncrement(Double) |
Restituisce il valore più piccolo che confronta un valore maggiore di un valore specificato. |
| Cbrt(Double) |
Calcola la radice del cubo di un valore. |
| Ceiling(Double) |
Calcola il limite massimo di un valore. |
| Clamp(Double, Double, Double) |
Blocca un valore a un valore minimo e massimo inclusivo. |
| ClampNative(Double, Double, Double) |
Blocca un valore a un valore minimo e massimo inclusivo usando un comportamento specifico della piattaforma per |
| CompareTo(Double) |
Confronta questa istanza con un numero a virgola mobile e precisione doppia specificato e restituisce un intero che indica se il valore di questa istanza è minore, uguale o maggiore del valore del numero a virgola mobile a precisione doppia specificato. |
| CompareTo(Object) |
Confronta questa istanza con un oggetto specificato e restituisce un numero intero che indica se il valore di questa istanza è minore, uguale o maggiore del valore dell'oggetto specificato. |
| ConvertToInteger<TInteger>(Double) |
Converte un valore in un tipo integer specificato utilizzando la saturazione in caso di overflow |
| ConvertToIntegerNative<TInteger>(Double) |
Converte un valore in un tipo integer specificato utilizzando un comportamento specifico della piattaforma in caso di overflow. |
| CopySign(Double, Double) |
Copia il segno di un valore nel segno di un altro valore. |
| Cos(Double) |
Calcola il coseno di un valore. |
| Cosh(Double) |
Calcola il coseno iperbolico di un valore. |
| CosPi(Double) |
Calcola il coseno di un valore che è stato multiplo da |
| CreateChecked<TOther>(TOther) |
Crea un'istanza del tipo corrente da un valore, generando un'eccezione di overflow per tutti i valori che non rientrano nell'intervallo rappresentabile del tipo corrente. |
| CreateSaturating<TOther>(TOther) |
Crea un'istanza del tipo corrente da un valore, saturando tutti i valori che non rientrano nell'intervallo rappresentabile del tipo corrente. |
| CreateTruncating<TOther>(TOther) |
Crea un'istanza del tipo corrente da un valore, troncando tutti i valori che non rientrano nell'intervallo rappresentabile del tipo corrente. |
| DegreesToRadians(Double) |
Converte un valore specificato da gradi a radianti. |
| Equals(Double) |
Restituisce un valore che indica se questa istanza e un oggetto specificato Double rappresentano lo stesso valore. |
| Equals(Object) |
Restituisce un valore che indica se questa istanza è uguale a un oggetto specificato. |
| Exp(Double) |
|
| Exp10(Double) |
|
| Exp10M1(Double) |
|
| Exp2(Double) |
|
| Exp2M1(Double) |
|
| ExpM1(Double) |
|
| Floor(Double) |
Calcola il piano di un valore. |
| FusedMultiplyAdd(Double, Double, Double) |
Calcola il moltiplicatore fuso di tre valori. |
| GetHashCode() |
Restituisce il codice hash per questa istanza. |
| GetTypeCode() |
Restituisce l'oggetto per il TypeCode tipo di Doublevalore . |
| Hypot(Double, Double) |
Calcola l'ipotenusa data due valori che rappresentano le lunghezze dei lati più corti in un triangolo con angolo destro. |
| Ieee754Remainder(Double, Double) |
Calcola il resto di due valori come specificato da IEEE 754. |
| ILogB(Double) |
Calcola il logaritmo intero di un valore. |
| IsEvenInteger(Double) |
Determina se un valore rappresenta un numero integrale pari. |
| IsFinite(Double) |
Determina se il valore specificato è finito (zero, sottonormato o normale). |
| IsInfinity(Double) |
Restituisce un valore che indica se il numero specificato restituisce un infinito negativo o positivo. |
| IsInteger(Double) |
Determina se un valore rappresenta un valore integrale. |
| IsNaN(Double) |
Restituisce un valore che indica se il valore specificato non è un numero (NaN). |
| IsNegative(Double) |
Determina se il valore specificato è negativo. |
| IsNegativeInfinity(Double) |
Restituisce un valore che indica se il numero specificato restituisce un infinito negativo. |
| IsNormal(Double) |
Determina se il valore specificato è normale. |
| IsOddInteger(Double) |
Determina se un valore rappresenta un numero integrale dispari. |
| IsPositive(Double) |
Determina se un valore è positivo. |
| IsPositiveInfinity(Double) |
Restituisce un valore che indica se il numero specificato restituisce un infinito positivo. |
| IsPow2(Double) |
Determina se un valore è una potenza di due. |
| IsRealNumber(Double) |
Determina se un valore rappresenta un numero reale. |
| IsSubnormal(Double) |
Determina se il valore specificato è sottonormaale. |
| Lerp(Double, Double, Double) |
Esegue un'interpolazione lineare tra due valori in base al peso specificato. |
| Log(Double, Double) |
Calcola il logaritmo di un valore nella base specificata. |
| Log(Double) |
Calcola il logaritmo naturale |
| Log10(Double) |
Calcola il logaritmo di base 10 di un valore. |
| Log10P1(Double) |
Calcola il logaritmo in base 10 di un valore più uno. |
| Log2(Double) |
Calcola il log2 di un valore. |
| Log2P1(Double) |
Calcola il logaritmo in base 2 di un valore più uno. |
| LogP1(Double) |
Calcola il logaritmo naturale ( |
| Max(Double, Double) |
Confronta due valori con il calcolo maggiore. |
| MaxMagnitude(Double, Double) |
Confronta due valori con il calcolo maggiore. |
| MaxMagnitudeNumber(Double, Double) |
Confronta due valori con il calcolo con la grandezza maggiore e restituendo l'altro valore se un input è |
| MaxNative(Double, Double) |
Confronta due valori con il calcolo, maggiore è l'uso del comportamento specifico della piattaforma per |
| MaxNumber(Double, Double) |
Confronta due valori con il calcolo maggiore e restituendo l'altro valore se un input è |
| Min(Double, Double) |
Confronta due valori con il calcolo minore. |
| MinMagnitude(Double, Double) |
Confronta due valori con il calcolo minore. |
| MinMagnitudeNumber(Double, Double) |
Confronta due valori con il calcolo con la grandezza minore e restituendo l'altro valore se un input è |
| MinNative(Double, Double) |
Confronta due valori con il calcolo che è minore usando il comportamento specifico della piattaforma per |
| MinNumber(Double, Double) |
Confronta due valori con il calcolo minore e restituendo l'altro valore se un input è |
| MultiplyAddEstimate(Double, Double, Double) |
Calcola una stima di ( |
| Parse(ReadOnlySpan<Byte>, IFormatProvider) |
Analizza un intervallo di caratteri UTF-8 in un valore. |
| Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider) |
Analizza un intervallo di caratteri UTF-8 in un valore. |
| Parse(ReadOnlySpan<Char>, IFormatProvider) |
Analizza un intervallo di caratteri in un valore. |
| Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider) |
Converte un intervallo di caratteri che contiene la rappresentazione di stringa di un numero in uno stile specificato e in un formato specifico delle impostazioni cultura nel numero a virgola mobile e precisione doppia equivalente. |
| Parse(String, IFormatProvider) |
Converte la rappresentazione di stringa di un numero in un formato specifico delle impostazioni cultura specificato nel relativo numero a virgola mobile a precisione doppia equivalente. |
| Parse(String, NumberStyles, IFormatProvider) |
Converte la rappresentazione di stringa di un numero in uno stile specificato e in un formato specifico delle impostazioni cultura nel numero a virgola mobile a precisione doppia equivalente. |
| Parse(String, NumberStyles) |
Converte la rappresentazione di stringa di un numero in uno stile specificato nel relativo numero a virgola mobile e precisione doppia equivalente. |
| Parse(String) |
Converte la rappresentazione di stringa di un numero nell'equivalente numero a virgola mobile e precisione doppia. |
| Pow(Double, Double) |
Calcola un valore elevato a una determinata potenza. |
| RadiansToDegrees(Double) |
Converte un determinato valore da radianti a gradi. |
| ReciprocalEstimate(Double) |
Calcola una stima del reciproco di un valore. |
| ReciprocalSqrtEstimate(Double) |
Calcola una stima della radice quadrata reciproca di un valore. |
| RootN(Double, Int32) |
Calcola la radice n-th di un valore. |
| Round(Double, Int32, MidpointRounding) |
Arrotonda un valore a un numero specificato di cifre frazionarie usando la modalità di arrotondamento predefinita (ToEven). |
| Round(Double, Int32) |
Arrotonda un valore a un numero specificato di cifre frazionarie usando la modalità di arrotondamento predefinita (ToEven). |
| Round(Double, MidpointRounding) |
Arrotonda un valore all'intero più vicino utilizzando la modalità di arrotondamento specificata. |
| Round(Double) |
Arrotonda un valore all'intero più vicino usando la modalità di arrotondamento predefinita (ToEven). |
| ScaleB(Double, Int32) |
Calcola il prodotto di un valore e il relativo base-radix elevato alla potenza specificata. |
| Sign(Double) |
Calcola il segno di un valore. |
| Sin(Double) |
Calcola il seno di un valore. |
| SinCos(Double) |
Calcola il seno e il coseno di un valore. |
| SinCosPi(Double) |
Calcola il seno e il coseno di un valore. |
| Sinh(Double) |
Calcola il seno iperbolico di un valore. |
| SinPi(Double) |
Calcola il seno di un valore moltiplicato per |
| Sqrt(Double) |
Calcola la radice quadrata di un valore. |
| Tan(Double) |
Calcola la tangente di un valore. |
| Tanh(Double) |
Calcola la tangente iperbolica di un valore. |
| TanPi(Double) |
Calcola la tangente di un valore che è stato multiplo da |
| ToString() |
Converte il valore numerico di questa istanza nella rappresentazione di stringa equivalente. |
| ToString(IFormatProvider) |
Converte il valore numerico di questa istanza nella rappresentazione di stringa equivalente usando le informazioni sul formato specifiche delle impostazioni cultura specificate. |
| ToString(String, IFormatProvider) |
Converte il valore numerico di questa istanza nella rappresentazione di stringa equivalente utilizzando il formato specificato e le informazioni sul formato specifiche delle impostazioni cultura. |
| ToString(String) |
Converte il valore numerico di questa istanza nella rappresentazione di stringa equivalente utilizzando il formato specificato. |
| Truncate(Double) |
Tronca un valore. |
| TryFormat(Span<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider) |
Prova a formattare il valore dell'istanza corrente come UTF-8 nell'intervallo di byte specificato. |
| TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider) |
Tenta di formattare il valore dell'istanza doppia corrente nell'intervallo di caratteri specificato. |
| TryParse(ReadOnlySpan<Byte>, Double) |
Prova a convertire un intervallo di caratteri UTF-8 contenente la rappresentazione di stringa di un numero nel numero a virgola mobile a precisione doppia equivalente. |
| TryParse(ReadOnlySpan<Byte>, IFormatProvider, Double) |
Prova ad analizzare un intervallo di caratteri UTF-8 in un valore. |
| TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, Double) |
Prova ad analizzare un intervallo di caratteri UTF-8 in un valore. |
| TryParse(ReadOnlySpan<Char>, Double) |
Converte la rappresentazione dell'intervallo di un numero in uno stile specificato e in un formato specifico delle impostazioni cultura nel relativo numero a virgola mobile e precisione doppia equivalente. Un valore restituito indica se la conversione ha avuto esito positivo o negativo. |
| TryParse(ReadOnlySpan<Char>, IFormatProvider, Double) |
Tenta di analizzare un intervallo di caratteri in un valore. |
| TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Double) |
Converte un intervallo di caratteri contenente la rappresentazione di stringa di un numero in uno stile specificato e in un formato specifico delle impostazioni cultura nel numero a virgola mobile e precisione doppia equivalente. Un valore restituito indica se la conversione ha avuto esito positivo o negativo. |
| TryParse(String, Double) |
Converte la rappresentazione di stringa di un numero nell'equivalente numero a virgola mobile e precisione doppia. Un valore restituito indica se la conversione ha avuto esito positivo o negativo. |
| TryParse(String, IFormatProvider, Double) |
Tenta di analizzare una stringa in un valore. |
| TryParse(String, NumberStyles, IFormatProvider, Double) |
Converte la rappresentazione di stringa di un numero in uno stile specificato e in un formato specifico delle impostazioni cultura nel numero a virgola mobile a precisione doppia equivalente. Un valore restituito indica se la conversione ha avuto esito positivo o negativo. |
Operatori
| Nome | Descrizione |
|---|---|
| Equality(Double, Double) |
Restituisce un valore che indica se due valori specificati Double sono uguali. |
| GreaterThan(Double, Double) |
Restituisce un valore che indica se un valore specificato Double è maggiore di un altro valore specificato Double . |
| GreaterThanOrEqual(Double, Double) |
Restituisce un valore che indica se un valore specificato Double è maggiore o uguale a un altro valore specificato Double . |
| Inequality(Double, Double) |
Restituisce un valore che indica se due valori specificati Double non sono uguali. |
| LessThan(Double, Double) |
Restituisce un valore che indica se un valore specificato Double è minore di un altro valore specificato Double . |
| LessThanOrEqual(Double, Double) |
Restituisce un valore che indica se un valore specificato Double è minore o uguale a un altro valore specificato Double . |
Implementazioni dell'interfaccia esplicita
| Nome | Descrizione |
|---|---|
| IAdditionOperators<Double,Double,Double>.Addition(Double, Double) |
Aggiunge due valori insieme per calcolare la somma. |
| IAdditiveIdentity<Double,Double>.AdditiveIdentity |
Ottiene l'identità aggiuntiva del tipo corrente. |
| IBinaryNumber<Double>.AllBitsSet |
Ottiene un'istanza del tipo binario in cui vengono impostati tutti i bit. |
| IBitwiseOperators<Double,Double,Double>.BitwiseAnd(Double, Double) |
Calcola i valori bit per bit e di due valori. |
| IBitwiseOperators<Double,Double,Double>.BitwiseOr(Double, Double) |
Calcola i valori bit per bit o di due valori. |
| IBitwiseOperators<Double,Double,Double>.ExclusiveOr(Double, Double) |
Calcola il valore esclusivo o di due valori. |
| IBitwiseOperators<Double,Double,Double>.OnesComplement(Double) |
Calcola la rappresentazione di complemento di un determinato valore. |
| IComparable.CompareTo(Object) |
Confronta l'istanza corrente con un altro oggetto dello stesso tipo e restituisce un numero intero che indica se l'istanza corrente precede, segue o si trova nella stessa posizione nell'ordinamento dell'altro oggetto. |
| IConvertible.GetTypeCode() |
Restituisce l'oggetto TypeCode per questa istanza. |
| IConvertible.ToBoolean(IFormatProvider) |
Per una descrizione di questo membro, vedere ToBoolean(IFormatProvider). |
| IConvertible.ToByte(IFormatProvider) |
Per una descrizione di questo membro, vedere ToByte(IFormatProvider). |
| IConvertible.ToChar(IFormatProvider) |
Questa conversione non è supportata. Il tentativo di utilizzare questo metodo genera un'eccezione InvalidCastException. |
| IConvertible.ToDateTime(IFormatProvider) |
Questa conversione non è supportata. Il tentativo di utilizzare questo metodo genera un'eccezione InvalidCastException. |
| IConvertible.ToDecimal(IFormatProvider) |
Per una descrizione di questo membro, vedere ToDecimal(IFormatProvider). |
| IConvertible.ToDouble(IFormatProvider) |
Per una descrizione di questo membro, vedere ToDouble(IFormatProvider). |
| IConvertible.ToInt16(IFormatProvider) |
Per una descrizione di questo membro, vedere ToInt16(IFormatProvider). |
| IConvertible.ToInt32(IFormatProvider) |
Per una descrizione di questo membro, vedere ToInt32(IFormatProvider). |
| IConvertible.ToInt64(IFormatProvider) |
Per una descrizione di questo membro, vedere ToInt64(IFormatProvider). |
| IConvertible.ToSByte(IFormatProvider) |
Per una descrizione di questo membro, vedere ToSByte(IFormatProvider). |
| IConvertible.ToSingle(IFormatProvider) |
Per una descrizione di questo membro, vedere ToSingle(IFormatProvider). |
| IConvertible.ToType(Type, IFormatProvider) |
Per una descrizione di questo membro, vedere ToType(Type, IFormatProvider). |
| IConvertible.ToUInt16(IFormatProvider) |
Per una descrizione di questo membro, vedere ToUInt16(IFormatProvider). |
| IConvertible.ToUInt32(IFormatProvider) |
Per una descrizione di questo membro, vedere ToUInt32(IFormatProvider). |
| IConvertible.ToUInt64(IFormatProvider) |
Per una descrizione di questo membro, vedere ToUInt64(IFormatProvider). |
| IDecrementOperators<Double>.Decrement(Double) |
Decrementa un valore. |
| IDivisionOperators<Double,Double,Double>.Division(Double, Double) |
Divide un valore per un altro per calcolare il quoziente. |
| IFloatingPoint<Double>.GetExponentByteCount() |
Ottiene il numero di byte che verranno scritti come parte di TryWriteExponentLittleEndian(Span<Byte>, Int32). |
| IFloatingPoint<Double>.GetExponentShortestBitLength() |
Ottiene la lunghezza, espressa in bit, della rappresentazione di complemento più breve dell'esponente corrente. |
| IFloatingPoint<Double>.GetSignificandBitLength() |
Ottiene la lunghezza, espressa in bit, del significando corrente. |
| IFloatingPoint<Double>.GetSignificandByteCount() |
Ottiene il numero di byte che verranno scritti come parte di TryWriteSignificandLittleEndian(Span<Byte>, Int32). |
| IFloatingPoint<Double>.TryWriteExponentBigEndian(Span<Byte>, Int32) |
Prova a scrivere l'esponente corrente, in formato big-endian, in un determinato intervallo. |
| IFloatingPoint<Double>.TryWriteExponentLittleEndian(Span<Byte>, Int32) |
Prova a scrivere l'esponente corrente, in formato little-endian, in un intervallo specificato. |
| IFloatingPoint<Double>.TryWriteSignificandBigEndian(Span<Byte>, Int32) |
Prova a scrivere il significando corrente, in formato big-endian, in un intervallo specificato. |
| IFloatingPoint<Double>.TryWriteSignificandLittleEndian(Span<Byte>, Int32) |
Prova a scrivere il significando corrente, in formato little-endian, in un intervallo specificato. |
| IFloatingPointConstants<Double>.E |
Ottiene la costante |
| IFloatingPointConstants<Double>.Pi |
Ottiene la costante |
| IFloatingPointConstants<Double>.Tau |
Ottiene la costante |
| IFloatingPointIeee754<Double>.Epsilon |
Ottiene il valore più piccolo che può essere aggiunto a |
| IFloatingPointIeee754<Double>.NaN |
Ottiene un valore che rappresenta |
| IFloatingPointIeee754<Double>.NegativeInfinity |
Ottiene un valore che rappresenta un valore negativo |
| IFloatingPointIeee754<Double>.NegativeZero |
Ottiene un valore che rappresenta un valore negativo |
| IFloatingPointIeee754<Double>.PositiveInfinity |
Ottiene un valore che rappresenta un valore positivo |
| IIncrementOperators<Double>.Increment(Double) |
Incrementa un valore. |
| IMinMaxValue<Double>.MaxValue |
Ottiene il valore massimo del tipo corrente. |
| IMinMaxValue<Double>.MinValue |
Ottiene il valore minimo del tipo corrente. |
| IModulusOperators<Double,Double,Double>.Modulus(Double, Double) |
Divide due valori insieme per calcolare il modulo o il resto. |
| IMultiplicativeIdentity<Double,Double>.MultiplicativeIdentity |
Ottiene l'identità moltiplicativa del tipo corrente. |
| IMultiplyOperators<Double,Double,Double>.Multiply(Double, Double) |
Moltiplica due valori insieme per calcolare il prodotto. |
| INumberBase<Double>.IsCanonical(Double) |
Determina se un valore è nella relativa rappresentazione canonica. |
| INumberBase<Double>.IsComplexNumber(Double) |
Determina se un valore rappresenta un numero complesso. |
| INumberBase<Double>.IsImaginaryNumber(Double) |
Determina se un valore rappresenta un numero immaginario puro. |
| INumberBase<Double>.IsZero(Double) |
Determina se un valore è zero. |
| INumberBase<Double>.One |
Ottiene il valore |
| INumberBase<Double>.Radix |
Ottiene la radice o la base del tipo. |
| INumberBase<Double>.TryConvertFromChecked<TOther>(TOther, Double) |
Rappresenta un numero in virgola mobile a doppia precisione. |
| INumberBase<Double>.TryConvertFromSaturating<TOther>(TOther, Double) |
Rappresenta un numero in virgola mobile a doppia precisione. |
| INumberBase<Double>.TryConvertFromTruncating<TOther>(TOther, Double) |
Rappresenta un numero in virgola mobile a doppia precisione. |
| INumberBase<Double>.TryConvertToChecked<TOther>(Double, TOther) |
Tenta di convertire un'istanza del tipo corrente in un altro tipo, generando un'eccezione di overflow per tutti i valori che non rientrano nell'intervallo rappresentabile del tipo corrente. |
| INumberBase<Double>.TryConvertToSaturating<TOther>(Double, TOther) |
Tenta di convertire un'istanza del tipo corrente in un altro tipo, saturando tutti i valori che non rientrano nell'intervallo rappresentabile del tipo corrente. |
| INumberBase<Double>.TryConvertToTruncating<TOther>(Double, TOther) |
Tenta di convertire un'istanza del tipo corrente in un altro tipo, troncando tutti i valori che non rientrano nell'intervallo rappresentabile del tipo corrente. |
| INumberBase<Double>.Zero |
Ottiene il valore |
| ISignedNumber<Double>.NegativeOne |
Ottiene il valore |
| ISubtractionOperators<Double,Double,Double>.Subtraction(Double, Double) |
Sottrae due valori per calcolare la differenza. |
| IUnaryNegationOperators<Double,Double>.UnaryNegation(Double) |
Calcola la negazione unaria di un valore. |
| IUnaryPlusOperators<Double,Double>.UnaryPlus(Double) |
Calcola il plus unario di un valore. |
Si applica a
Thread safety
Tutti i membri di questo tipo sono thread-safe. I membri che sembrano modificare lo stato dell'istanza restituiscono effettivamente una nuova istanza inizializzata con il nuovo valore. Come per qualsiasi altro tipo, la lettura e la scrittura in una variabile condivisa contenente un'istanza di questo tipo devono essere protette da un blocco per garantire la thread safety.
