Floating point dramatic error (fractional part is completely lost)

Question

quotient = 43156414f / 3;

I got quotient == 14385472 here (totally not as true value should be: 14385471,333...). It completely lost all fractional part!

I know about floating point calculations inacuracy (it seems, not all, that I should to know), but, as I informed, the error could appear at much farther significant digits. But the dividend here is only 8-digits number. Why so dramatic error happens?

Optional sub-question: What rules should I keep in mind to foresee such errors in future?

Just to note: Changing type of divident from float to double fixes this problem.

use decimal type, it can hold bigger values than float and don't lose presicion — Bloodday, Jul 10 '20 at 19:08

Hans Keﬆing · Accepted Answer · 2020-07-14T06:41:48.317

7

float has a precision of 6-9 digits. Your value is just too large to fit into a float without loss.

double has a precision of about 15-17 digits.

As an illustration, inspect the value of (int)43156414f or (double)43156414f - they are both 43156416

edited Jul 14 '20 at 06:41

answered Jul 10 '20 at 19:06

Hans Keﬆing

38,117
9
79
111

For some reason there was _"something like 12 digits percision"_ in my head. Apparently, I messed up something. Thank you! – user1234567 Jul 10 '20 at 19:27
[It does not make any sense to describe `float` precision as 6-9 digits.](https://stackoverflow.com/a/61614323/298225) – Eric Postpischil Jul 10 '20 at 20:09

Dmitry Bychenko · Answer 2 · 2020-07-10T20:11:51.427

Well, float (Single) uses 23 bits for mantissa

https://en.wikipedia.org/wiki/Single-precision_floating-point_format

So float can represent integers up to 2**24 - 1 == 16777215 which is close to 14385471. The possibilities we have are:

 01001011 01011011 10000001 00111111 correponds to 14385471f (let's add 1 bit)
 01001011 01011011 10000001 01000000 correponds to 14385472f

So as we can see we have only 14385471f and 14385472f to choose from; no place for 14385471.33333f in case of floate. Let's have a look

 float x = 14385471.3333333333f;

 byte[] data = BitConverter.GetBytes(x);

 Console.Write(" ", string.Join(" ", data
   .Reverse()
   .Select(b => Convert.ToString(b, 2).PadLeft(8, '0'))));

We'll have

 01001011 01011011 10000001 00111111

which corresponds to 14385471f. Even more problems we have with

 quotient = 43156414f / 3;

Now, 43156414f > 2**24 - 1 (16777215) and 43156414f can't be represented as float but

 01001100 00100100 10100000 11110000 corresponds to 43156416

So the actual value of quotient is

 43156416 / 3 == 14385472

Finally, if you want to have 14385471.33, Single is not enough, try double:

 // 14385471.333333334
 double quotient = 43156414d / 3;

Floating point dramatic error (fractional part is completely lost)

2 Answers2