Question

I’m trying to convert a floating point number to binary representation; how can I achieve this?
My goal is, however, not to be limited by 2m so I’m hoping for something that could be easily extended to any base (3, 4, 8) ecc.

I’ve got a straightforward implementation so far for integers:

import string

LETTER = '0123456789' + string.ascii_lowercase
def convert_int(num, base):
    if base == 1:
        print "WARNING! ASKING FOR BASE = 1"
        return '1' * num if num != 0 else '0'

    if base > 36: raise ValueError('base must be >= 1 and <= 36')

    num, rest = divmod(num, base)
    rest = [LETTER[rest]]
    while num >= base:
        num, r = divmod(num, base)
        rest.append(LETTER[r])
    rest.reverse()
    return (LETTER[num] if num else '') + ''.join(str(x) for x in rest)

any help appreciated 🙂

edit:

def convert_float(num, base, digits=None):
    num = float(num)
    if digits is None: digits = 6

    num = int(round(num * pow(base, digits)))
    num = convert_int(num, base)
    num = num[:-digits] + '.' + num[:digits]
    if num.startswith('.'): num = '0' + num
    return num

is that right? why do i get this behaviour?

>>> convert_float(1289.2893, 16)
'509.5094a0'
>>> float.hex(1289.2983)
'0x1.42531758e2196p+10'

p.s.
How to convert float number to Binary?

I’ve read that discussion, but I don’t get the answer.. I mean, does it work only for 0.25, 0.125? and I dont understand the phrase ‘must be in reverse order’…

Answer 1

Next answer with a bit of theory.

Explanation below does not explain IEEE Floating Point standard only general ideas concerning representation of floating point numbers

Every float number is represented as a fractional part multiplied by an exponent multiplied by a sign. Additionally there is so called bias for exponent, which will be explained bellow.

So we have

1. Sign bit
2. Fractional part digits
3. Exponent part digits

Example for base 2 with 8 bit fraction and 8 bit exponent

Bits in fraction part tell us which summands (numbers to be added) from sequence below are to be included in represented number value

2^-1 + 2^-2 + 2^-3 + 2^-4 + 2^-5 + 2^-6 + 2^-7 + 2^-8

So if you have say 01101101 in fractional part it gives

0*2^-1 + 1*2^-2 + 1*2^-3 + 0*2^-4 + 1*2^-5 + 1*2^-6 + 0*2^-7 + 1*2^-8 = 0.42578125

Now non-zero numbers that are representable that way fall between
2 ** -8 = 0.00390625 and 1 – 2**-8 = 0.99609375

Here the exponent part comes in. Exponent allows us to represent very big numbers by multiplying the fraction part by exponent. So if we have an 8bit exponent we can multiply the resulting fraction by numbers between 0 and 2^255.

So going back to example above let’s take exponent of 11000011 = 195.

We have fractional part of 01101101 = 0.42578125 and exponent part 11000011 = 195. It gives us the number 0.42578125 * 2^195, this is really big number.

So far we can represent non-zero numbers between 2^-8 * 2^0 and (1-2^-8) * 2^255. This allows for very big numbers but not for very small numbers. In order to be able to represent small numbers we have to include so called bias in our exponent. It is a number that will be always subtracted from exponent in order to allow for representation of small numbers.

Let’s take a bias of 127. Now all exponents are subtracted 127. So numbers that can be represented are between 2^-8 * 2^(0 – 127) and (1-2^-8) * 2^(255 – 127 = 128)

Example number is now 0.42578125 * 2^(195-127 = 68) which is still pretty big.

Example ends

In order to understand this better try to experiment with different bases and sizes for fractional and exponential part. At beginning don’t try with odd bases because it only complicates things necessary.

Once you grasp how this representation works you should be able to write code to obtain representation of any number in any base, fractional/exponential part combination.