Why is 0.1f's last binary bit rounded to 1?

I'm following an operating system course at college and we recently learned how floating point numbers are represented in memory.

Our homework is about converting floating numbers(floats) to their binary representations by hand.

e.g. 200,0234375 would give 01000011010010000000011000000000 after the long conversion process.

One of the questions is about how 0.1f would be represented in memory. So I did the whole conversion process and I ended up with this:

00111101110011001100110011001100

With what we've learned so far, this is the correct answer to the question (I 开发者_如何学Goasked the teacher).

But, on the next question, we are asked to verify the answer with a program to see the actual binary representation of 0.1f. The real representation is this:

00111101110011001100110011001101

(Notice the last bit)

We are then asked to try to guess why this is happening.

I noticed the periodic 0011 while converting the number and since the next bit after the final 0 would be a 1, I would assume that the computer would round that final 0 to a 1, which would explain the difference.

So, what I want to know is, am I correct? Is the computer rounding the last bit based on what would be the next bit when the 23 bits of the mantissa are used?

This is a homework, so if you could simply guide me towards the answer if I'm wrong I would appreciate.

Also, I couldn't find the answer to my question by Googling with the keywords I could think of. Pardon me if this is a duplicate.

Is the computer rounding the last bit based on what would be the next bit when the 23 bits of the mantissa are used?

Yes, of course. By default, the compiler and the floating-point arithmetic system tries to give you correctly rounded results.

As an analogy, if I asked you to write 2/3 to three decimal places, would you answer with 0.666 or 0.667? It should be 0.667, because it's closer to the true answer.

I am not quite sure how to guide you without just giving the answer here, but yes, you're on to it. The IEEE standard includes specific provisions for this kind of rounding. Look up guard, round, and sticky bits.

This will depend on your platform, the particular floating point hardware, and the particular settings on that hardware.

In particular, on x86 platforms, the particular behavior will depend on the contents of the FPU or SSE Control Word registers.

There are several rounding modes.

You can read about it in wikipedia.

It's just a matter of implementation. C++ doesn't have a standard for that.