Home/ Questions/Q 7769181
In Process

The Archive Base Latest Questions

Editorial Team
  • 0
Asked: 2026-06-01T16:05:42+00:00

First, we see the code below: result = 0.1 + 0.2; alert(result===0.3);// false result=100.1+100.2;

  • 0

First, we see the code below:

result = 0.1 + 0.2;     
alert(result===0.3);// false
result=100.1+100.2;
alert(result===200.3);//true

I believe that 0.1 and 100.1 (100+0.1) are stored similarly in memory, since the decimal is .1 in both of them.

So, why is the result of the addition different?

Share

Leave an answer

You must login to add an answer.

Need An Account,

1 Answer

  1. Editorial Team

    They are not stored the same in memory: http://steve.hollasch.net/cgindex/coding/ieeefloat.html

    0.1 in binary:

    0.1 * 2 = 0 + 0.2
    0.2 * 2 = 0 + 0.4
    0.4 * 2 = 0 + 0.8
    0.8 * 2 = 1 + 0.6
    0.6 * 2 = 1 + 0.2
    0.2 * 2 = 0 + 0.4
    0.4 * 2 = 0 + 0.8
    0.8 * 2 = 1 + 0.6
    0.6 * 2 = 1 + 0.2

    As you can see, after the 0.2 repeated the whole pattern (0011) will just keep repeating, so 0.1 is 0.0001100110011001100110011... repeating forever

    To represent that in a 23 bit mantissa we have to shift it left until we have a 1 before the decimal point (after shifting the bits left 4 places and removing the 1 before the decimal we have 100110011...) and then round at the 23rd bit, and we get: 10011001100110011001101.

    Since we shifted 4 places our exponent is 127-4 (127 is the 32 bit bias). 123 in 8 bits of binary is 01111011, all that’s left is the sign bit, which we know is 0 since 0.1 is a positive number. So each component of the 32 bit binary number is:

    sign: 0
    exponent: 01111011
    mantissa: 10011001100110011001101

    0.1 is represented as 00111101110011001100110011001101 in a floating point number.

    Converting back we have to break it back apart and then convert the exponent back to a decimal integer (123). We shift the mantissa (with an assumed 1 in front) to the right (127 – 123 = 4) times and get : 0.00011001100110011001101101 then we convert this back to decimal:

    0*1/2 + 0*1/4 + 0*1/8 + 1/16 + 1/32 + 0*1/64 + 0*1/128 + 1/256 + 1/512 + 
0 + 1/4096 + 1/8192 + 0 + 1/65536 + 1/131072 + 0 + 1/1048576 + 1/2097152 + 
0 + 1/16777216 + 1/33554432 + 0 + 1/134217728

    Which if you do the math gives you something closer to 0.100000001, than to 0.1. That’s because we rounded at the 23rd bit. 0.1 cannot be stored in binary since it repeats forever, so after the 23rd bit we have inaccuracies. When you do arithmetic on a number those inaccuracies are carried through, and the errors can grow to be much larger.

    If you do the same thing with 100.1 you get:

    1100100.0001100110011001100… repeating forever:

    Shift right 6 times and removing the 1 before the decimal round to 23rd bit: 10010000011001100110011

    Exponent is 127+6 = 133 (1000 0101)

    Sign is 0 again, so you have:

    01000010110010000011001100110011
    • 0