Can someone help me explain this code that is converting decimal fractions into a binary?

Question

Can someone help me explain this code that is converting decimal fractions into a binary?

Convert the decimal fractions into a binary form:

x = float(raw_input('Enter a decimal number between 0 and 1: '))

p = 0
while ((2**p)*x)%1 != 0:
    print('Remainder = ' + str((2**p)*x - int((2**p)*x)))
    p += 1

num = int(x*(2**p))

result = ''
if num == 0:
    result = '0'
while num > 0:
    result = str(num%2) + result
    num = num/2

for i in range(p - len(result)):
    result = '0' + result

result = result[0:-p] + '.' + result[-p:]
print('The binary representation of the decimal ' + str(x) + ' is ' + str(result))

Answer 1

I don't think this code is written all that well, but here's a rough idea. The first while loop:

while ((2**p)*x)%1 != 0: ...

is figuring out how many places in binary to the right of the decimal point will the result be. To use a familiar analogy let's work with base 10. If the number is 1.234 and I want to convert to base 10 (a no brainer), there will clearly be 3 places to the right of the decimal point in the answer. But how do I know this? Well I multiply by 10, 100, 1000 and so on until I have a number that has no fractional part left. (...)%1 is giving the fractional part of (...) and it is zero when ... is whole number.

Now that I know the smallest power of 2 that turns the input value into a whole number, we multiply by that to get a whole number. That value is called num in the program. Just as you do in decimal when you peform mathematical operations, you can ignore the decimal point and put that in after the calculation is done. Technically this is doing these steps

• multiplying by a power of 10,
• work on the number
• divide by that power of 10 after your are done.

And the same is true for a power of 2. Mathematically:

  conversion(x) == conversion(x*2**p)/2**p

From here using num, we compute the bits in the output from least-significant to the most significant. This is the part that starts:

  while num > 0:

If the number is odd, then clearly that the last digit of the number converted to binary will also be odd. Otherwise the last digit will be 0. Having figured out the least significant bit, we then move to the next most significant bit and so on.

Here is an example. Suppose the number is 5. That's odd, so we now know the last digit in binary will be 1. Now to consider the remaining part 4 (since 4 = 5-1) shift that to the right one place to be able consider its least-significant bit. Don't worry about the shifting right one place because in the answer we will shift one place left before when inserting it into the final result.

4 shifted one place is 2. It is even so that's a '0'. To the left of the the '1' we had before, we now place that '0'. 2 still remains (2 = 2 - 0), so we shift 2 one place to the right again consider the remaining part, which is now 1. And that's odd, so add another '1' to the left of '01'. What remains ins now 0 (1-1=0) So we stop. And all in all we got '101'.

Previously we had computed how many places to the right of the decimal point, p. So the part that starts:

 for i in range(p - len(result)):
    result = '0' + result

is adding 0's to the beginning of the number in excess of p. And the rightmost p characters are then added after the decimal point:

  result = result[0:-p] + '.' + result[-p:]