Karl Heinz Buchegger wrote:

I doubt that.

The only difference between 0.3 and 30 as a floating point number

is the exponent.

0.3 is stored (of course in binary) as 0.3 E 0

30.0 is stored as 0.3 E 2

so if the same mantissa is used and we know that 0.3

cannot be represented exactly by a binary floating point

number, then 30 also cannot be represented exactly.

Of course the real thing is different, since the exponent

usually is not base 10, but base 2, but the principle is the

same.

It looks like you've worked it out (I didn't totally follow the

discussion), but let me explain my logic, and show how integers are

represented in IEEE doubles.

First, the IEEE double is 64 bits. 1 sign bit, 11 exponent bits, and 52

mantissa bits. The mantissa actually has one more 'implied' bit - it's

value is always 1, and it is logically placed to the left of the other

52 bits. Now, integer value 1 is represented like this:

1|.0000[...]0000

Where the 1 is not actually stored, but is implied (represented here by

using a vertical bar to separate it from the physical bits). All the

physical mantissa bits are zero ([...] is used so I don't have to type

all 52 bits), and the binary point (represented with a dot) is placed

between the implied 1 bit and the 'real' mantissa bits. The exponent

isn't shown, but it is implied by the position of the binary point (you

run out of mantissa long before you run out of exponent, so there's no

need to watch for exponent overflow in this example).

Moving on, the integer 2 is represented this way:

1|0.0000[...]0000

Only the exponent (position of the binary point) changes. 3 looks like this:

1|1.0000[...]0000

4-9:

1|00.000[...]0000

1|01.000[...]0000

1|10.000[...]0000

1|11.000[...]0000

1|000.00[...]0000

1|001.00[...]0000

If you continue this for a very, very long time, you arrive at this:

1|1111[...]1111.

All the mantissa bits are set to 1. This isn't quite the end, though.

You can add one more to get this:

1|0000[...]0000|0.

Now there's an implied 0 on the right side of the mantissa. Actually,

there's a lot of implied zeros over there, they just haven't come into

play until now. This should give the value I listed as the upper limit

(pow(2, 53)).

At this point, you can't add 1 and get anything different. It would

require flipping the implied 0 bit, which you can't do. You can add 2

and get this, though:

1|0000[...]0001|0.

There are obviously many more integers that can be precisely

represented, but none of them are contiguous - given two contiguous

integers, one must have it's least significant bit set to 1 (in other

words, must be odd), but all integers above this point use an implied 0

bit for their least significant bit. As you go higher, more implied 0

bits are used, making the distance from one exact integer to the next

even greater. For a while, you have only even integers. Then, only

integers that are divisible by 4, then 8, 16, etc. (until you run out of

exponent, a very long time later).

-Kevin

--

My email address is valid, but changes periodically.

To contact me please use the address from a recent posting.