BCL Refresher: Floating Point Types - The Good, The Bad and The Ugly [Inbar Gazit, Matthew Greig]

re: BCL Refresher: Floating Point Types - The Good, The Bad and The Ugly [Inbar Gazit, Matthew Greig]

Wesner Moise — Wed, 30 May 2007 08:30:27 GMT

Decimals can more precisely represent fractions entered by the user, since the base 10 values entered by user matched the base of the representation.

Doubles seem to work better than with division operation, as repeating decimals (non-divisible by 10) are represented more closely. For example, with doubles (1.0/3)*3 == 1. With decimals, (1m/3)*3 = .9999{28 times}. The repeating fraction gets chopped off.

Also, if any of the other complex math operations are used, trig, exp, logs, etc, since they often involve irrational or nonterminating values.

re: BCL Refresher: Floating Point Types - The Good, The Bad and The Ugly [Inbar Gazit, Matthew Greig]

Chris Nahr — Wed, 30 May 2007 10:34:39 GMT

Nice trick with the BitConverter and GetBits calls... I'll have to remember that.

You mixed up the terms "fixed point" and "floating point" in your third paragraph, by the way (the one starting with "So here's a question"). The method used by the BCL is the first described, which is floating-point representation.

re: BCL Refresher: Floating Point Types - The Good, The Bad and The Ugly [Inbar Gazit, Matthew Greig]

Jeffrey Sax — Wed, 30 May 2007 17:12:47 GMT

1. In the last example comparing the three types, I think you have the values for Single and Double reversed.

2. You say the decimal type has 'limited precision.' Near the end you again put decimal nd 'little precision' in the same sentence Decimal is actually the type with the highest precision: 96 bits.

3. A drawback of the Decimal type is that it is an order of magnitude slower than the other types. Using a consistent rounding policy can eliminate nearly all the problems with inexact representations.

4. Another reason to use Singles is that it takes less time to load them into the CPU, and they take up less room in the cache. This makes a significant difference only with arrays.

re: BCL Refresher: Floating Point Types - The Good, The Bad and The Ugly [Inbar Gazit, Matthew Greig]

C. Watford — Wed, 30 May 2007 20:32:41 GMT

IEEE754 is the relevant standard for the Single and Double data types and does have a (fairly) good set of rules governing rounding. Many older formats had no such nice rules and left a lot to be desired.

An interesting issue to note which choosing Single, Double, or Decimal is that Single and Double are native and more importantly operations on Single and Double can be atomic. On some architectures the bit-representation of the Decimal structure cannot be modified atomically. Interesting thread safety implications there.

re: BCL Refresher: Floating Point Types - The Good, The Bad and The Ugly [Inbar Gazit, Matthew Greig]

Matthew Greig — Wed, 30 May 2007 21:19:33 GMT

Jeff, thanks for your feedback. Here are my comments on it.

1) Yes, you are right. Should be fixed now.

2) Decimal does have limited precision. It has a higher precision than Single or Double, but still limited. I will discuss the two mentions of presion seperately.

"limited precision":

It may seem somewhat strange to mention that it has limited precision since it has the highest precision of the three types, but necessary when talking about how it represents numbers exactly if it is in the given range (limited range) and given number of base-10 digits (limited precision).

"relatively little precision":

Maybe this was a little misleading so I will try to explain better what was meant here. Generally we were talking about that Decimal will suffer from greater problems with underflow than Single or Double. Consider the output of:

Double d3 = Double.Parse("1e-30");

Double d4 = d3/10;

Decimal e3 = (Decimal) d3;

Decimal e4 = (Decimal) d4;

Console.WriteLine("Double (1e-30): " + d3);

Console.WriteLine("Double (1e-31): " + d4);

Console.WriteLine("Decimal (1e-30): " + e3);

Console.WriteLine("Decimal (1e-31): " + e4);

with values in this range Double is more precise than Decimal since it will underflow and be masked to zero.

3) Agree that Decimal is generally slower than the other types but we are not really trying to focus on the performance of the types here although this may be important in the choice when using them. The consistent rounding policy definitely helps with inexact representations, but not sure I would go as far as to say it “eliminates nearly all the problems”

4) I agree with your statements. These are typical side effects of using less memory and not anything intrinsic about the way Singles are stored.

re: BCL Refresher: Floating Point Types - The Good, The Bad and The Ugly [Inbar Gazit, Matthew Greig]

Jon Skeet — Fri, 01 Jun 2007 01:29:16 GMT

(Fixed/floating still appears to be wrong at the moment in the third paragraph, btw.)

Oh dear - I'm constantly fighting against things like this:

"The difference between Decimal and Single/Double is that Decimal is an exact representation of the number whereas Single/Double only gives us the closest estimate."

Both of them give closest estimates to a particular real number. It's just that a literal expressed as a decimal within the appropriate range and precision can always be exactly represented as a decimal. Now, your statement is correct within the context of storing 231.312, but when taken out of context (as statements often are) it's incorrect. If "the number" is a third, both of them will only store an approximation. (Both will store an exact number, but it'll be an approximation to the original one.)

Statements like the one quoted give rise to the myth that decimal is "accurate" and double/single are "approximate" - as if they're very different, with decimal never losing data. Decimal and float/double are more similar than most people realise, basically being an integer and a point - it's mostly the base of point (10 or 2) and the limits on precision/scaling which differ. (Yes, there are some other differences in terms of remembering "extra" digits, denormal values, infinite values etc - but the biggest difference is the base of the point, IMO.)

Still, at least MS does seem firmly behind the idea that decimal is a floating point type. It was documented in MSDN as being a fixed point type, and I spent *many* messages arguing with a documentation maintainer about whether it was floating or not. The fact that there was a mantissa and an exponent as part of the value didn't seem to be evidence enough ;)

Jon

re: BCL Refresher: Floating Point Types - The Good, The Bad and The Ugly [Inbar Gazit, Matthew Greig]

Chris Nahr — Fri, 01 Jun 2007 09:38:14 GMT

Matthew, you've still got fixed-point and floating-point confused in the third paragraph...

re: BCL Refresher: Floating Point Types - The Good, The Bad and The Ugly [Inbar Gazit, Matthew Greig]

Matthew Greig — Fri, 01 Jun 2007 20:05:54 GMT

Thanks to everyone who pointed out the errors in the third paragraph (they should be corrected now). I reworded it somewhat to better describe the Single/Double vs Decimal differences.

re: BCL Refresher: Floating Point Types - The Good, The Bad and The Ugly [Inbar Gazit, Matthew Greig]

Jon Skeet — Sat, 02 Jun 2007 20:44:24 GMT

Much better - thanks for being so responsive :)

BCL Team Blog : BCL Refresher: Floating Point Types - The Good, The Bad and The Ugly [Inbar Gazit, Matthew Greig]

Dating — Sat, 31 May 2008 08:58:40 GMT

So here is another BCL refresher on the topic of floating point types in the BCL. Believe it or not, we have 3 different floating point types: Single (float) Double and Decimal. Each has their own characteristics and abilities and so let’s try to lear

BCL Team Blog : BCL Refresher: Floating Point Types - The Good, The Bad and The Ugly [Inbar Gazit, Matthew Greig]

Weddings — Thu, 05 Jun 2008 13:24:00 GMT