Is it safe to compare decimals casted from doubles

Question

It is commonly known that it is not safe to compare double values with == operator. In this example it returns false:

double d1 = 0.11;
double d2 = 0.44 - 0.33;
Console.WriteLine(d1 == d2);

But, if we cast values to decimal, it returns true:

double d1 = 0.11;
double d2 = 0.44 - 0.33;
Console.WriteLine((decimal)d1 == (decimal)d2);

Is it always safe to compare decimals casted from double, or there are some cases where can give unexpected result?

Update: Hossein's example is good, it shows that it can be wrongly true. But I'm more interested to see if there are opposite examples, when we expect decimal values to be equal and they are not. Even wider, what exactly happens when we cast from double to decimal.

Answer 1

It is commonly known that it is not safe to compare double values in .net. In this example it returns false

You are mistaken about what is not safe.

It is not safe to assume that an arbitrary decimal representation, even if it is short (written in decimal), is represented exactly in binary floating-point. It is not safe to assume that - between binary floating-point values produces anything other than the nearest representable floating-point value to the mathematical result (and in particular, it is not safe to assume that it always produces the mathematical result).

d1 == d2 is perfectly safe, and so is (decimal)d1 == (decimal)d2. The first one will not always return what you appear to want, but neither will the second, because it has no reason to according to the principles laid out above. Once d1 and d2 have been computed, the approximations have already been done:

• representation approximation, because you appear to think that 0.11 should be the mathematical value 11/100, and it's not, it's the nearest representable value;
• operation approximation, because the mathematical result of 0.44 minus 0.33 may not be representable exactly, in which case the nearest representable value will be used.

The fact that these approximations compound and, when adding the third approximation of converting to decimalin C#, result in the value you expected is pure coincidence. If anything should be commonly known, it should be that it is too late to fix an approximation after it has occurred and that adding another approximation will not really help. See the first example in this article, Excel, another programmable product from Microsoft.

Answer 2

In this case you may get the desired result but generally your answer is NO. When you store a value in a double then casting it to a decimal do not enhance its precision (link).

Consider the below example. The equality returns true but we expect false.

double myDouble1 = 0.11;
double myDouble2 = 0.10999999999999999;
Console.WriteLine((decimal)myDouble1 == (decimal)myDouble2); //true, but we expect false

But if you store those values as decimal, then the you will get the proper result.

decimal myDecimal1 = 0.11M;
decimal myDecimal2 = 0.10999999999999999M;
Console.WriteLine(myDecimal1 == myDecimal2); //false

Answer 3

It's always safe, provided you know the conversion semantics between floating point and decimal types, and recognize the impact on the implementing code.

Which is to say, unless you have a good reason for the cast, you are safer following the standard approach of checking equality for some given tolerance. (E.g. (0.999 - 1.00) < 0.01.)

From Explicit Numeric Conversions Table (C# Reference):

• When you convert float or double to decimal, the source value is converted to decimal representation and rounded to the nearest number after the 28th decimal place if required. Depending on the value of the source value, one of the following results may occur:

  • If the source value is too small to be represented as a decimal, the result becomes zero.

  • If the source value is NaN (not a number), infinity, or too large to be represented as a decimal, an OverflowException is thrown.

  • When you convert decimal to float or double, the decimal value is rounded to the nearest double or float value.

Answer 4

The MSDN says:

The decimal type has 29 digits of precision, whereas a difference between these two values can be detected only with 30 digits of precision.

There is example that demonstrates comparison trouble for decimal values. For details see https://msdn.microsoft.com/library/system.decimal.compare(v=vs.110).aspx

Answer 5

double stores approximate values and thus this case will not be equal:

double d1 = 0.11;
double d2 = 0.44 - 0.33;
Console.WriteLine(d1 == d2);

decimal stores values more closer to what they are than does a double so this will be equal:

Console.WriteLine((decimal)d1 == (decimal)d2);

But it is important to note that even decimal is an approximate value. For example, you could not store the Pi's exact value using a decimal.

It is commonly known that it is not safe to compare double values in .net.

It all depends on the level of precision your calculation needs. For some calculations it is fine to use it, for others it is not.

System.Double (double in C#) and System.Single (float in C#) are stored as approximate values. For example:

double x = 0.1d;

x will store the closest available double to that value.

---

Important Distinction

It is very important to note that unlike double, a decimal will not store itself by normalizing but it will remember the zeros. For example, try the following code:

decimal dec1 = 1.000000000m;
double dbl11 = 1.000000000;

Console.WriteLine(dec1);  // outputs: 1.000000000 (remembers all 9 zeros)
Console.WriteLine(dbl11); // outputs: 1

<==Try Me==>

A decimal is stored as base 10 in memory but double and float are stored in base 2. All of them have the following components: a mantissa, an exponent and a sign. For example:

44.5 could be represented in "decimal floating point" as mantissa 4.45 with an exponent of 1, whereas 4450 would have the same mantissa but an exponent of 3.

You can read more on Floating Points and Decimals if are curious.

---

Kind of off-topic but Interesting Question

I was talking to someone about decimals and approximations etc. and they brought up this question: Imagine you own a store and you buy 3 items for $1.00. You want to cut even so which customer will have to take the hit and pay the extra penny?