C# da doppia a decimale perdita di precisione

Question

Ho un doppio "138630.78380386264" e voglio convertirlo in un decimale, tuttavia quando lo faccio lo faccio sia colando o usando Convert.ToDecimal() e perdo la precisione.

Cosa sta succedendo? Sia decimale e doppia può contenere questo numero:

double doub = double.Parse("138630.78380386264"); 
decimal dec = decimal.Parse("138630.78380386264"); 
string decs = dec.ToString("F17"); 
string doubse =DoubleConverter.ToExactString(doub); 
string doubs = doub.ToString("F17"); 

decimal decC = (decimal) doub; 
string doudeccs = decC.ToString("F17"); 
decimal decConv = Convert.ToDecimal(doub); 
string doudecs = decConv.ToString("F17"); 

anche: come posso ottenere il ToString() sulla doppia stampare lo stesso risultato come mostra il debugger? per esempio. 138630.78380386264?

Answer 1

138630.78380386264 non è esattamente rappresentabile per la precisione doppia. Il numero di precisione doppia più vicino (come si trova here) è 138630.783803862635977566242218017578125, che concorda con i risultati.

Si chiede perché la conversione in decimale non contenga più precisione. Il documentation for Convert.ToDecimal() ha la risposta:

il valore decimale restituito da questo metodo contiene un massimo di 15 cifre significative. Se il parametro value contiene più di 15 cifre significative, viene arrotondato con arrotondamento al più vicino. Nell'esempio seguente viene illustrato come il metodo Convert.ToDecimal (Double) utilizza l'arrotondamento al più vicino per restituire un valore decimale con 15 cifre significative.

Il doppio valore, arrotondato al più vicino a 15 cifre significative è 138630.783803863, esattamente come mostrate sopra.

Answer 2

È uno sfortunato, penso. Vicino a 139.000, uno Decimal ha una precisione molto migliore di uno Double. Tuttavia, a causa di questo problema, abbiamo diversiDouble s proiettati su lo stessoDecimal. Ad esempio

double doub1 = 138630.7838038626; 
double doub2 = 138630.7838038628; 
Console.WriteLine(doub1 < doub2);     // true, values differ as doubles 
Console.WriteLine((decimal)doub1 < (decimal)doub2); // false, values projected onto same decimal 

In realtà ci sono sei diversi rappresentabili Double valori tradoub1 e doub2 sopra, quindi non sono gli stessi.

Qui è un po 'stupido lavoro-aronud:

static decimal PreciseConvert(double doub) 
{ 
    // Handle infinities and NaN-s first (throw exception) 
    // Otherwise: 
    return Decimal.Parse(doub.ToString("R"), NumberStyles.AllowExponent | NumberStyles.AllowDecimalPoint); 
} 

La stringa di formato "R" assicura che le cifre in più sufficienti sono inclusi per rendere l'iniettiva mappatura (nel dominio in cui Decimal ha precisione superiore).

---

Si noti che in qualche intervallo, un long (Int64) ha una precisione che è superiore a quello di Double. Quindi ho controllato se le conversioni qui sono fatte nello stesso modo (prima arrotondando a 15 cifre decimali significative). Non sono! Quindi:

double doub3 = 1.386307838038626e18; 
double doub4 = 1.386307838038628e18; 

Console.WriteLine(doub3 < doub4);    // true, values differ as doubles 
Console.WriteLine((long)doub3 < (long)doub4); // true, full precision of double used when converting to long 

Sembra incoerente di utilizzare una "regola" diverso quando il bersaglio è decimal.

Si noti che a causa di ciò, (decimal)(long)doub3 produce un risultato più accurato di appena (decimal)doub3.