How can I get first n bits of floating point number as integer in python

Question

Suppose I have 0.625 as a floating point is 0b.101, so if I want the first two bits of that as an integer i.e. 0b10 = 2, how can I achieve this in python?

I've tried taking the number to a power of 2 and casting to an int, so if I want n bits I do int(0.625*(2**n)). But that is not working for me.

The problem occurs when I have a number greater than 1 so 24.548838022726972 will give me 392 rather than 12 for the first four bits. (24.548838022726972 = 0b11000.100011001...)

Answer 1

If you want the n most significant bits, one way to start is to use math.frexp to normalise your number to lie in the range [0.5, 1.0). Then multiplying by 2**n and taking the integer part will give you what you need.

>>> import math
>>> math.frexp(24.54883)  # significand and exponent
(0.7671509375, 5)
>>> math.frexp(24.54883)[0]  # just the significand
0.7671509375
>>> int(math.frexp(24.54883)[0] * 2**4)  # most significant 4 bits
12

Instead of explicitly computing a power of 2 to scale by, you could use the math.ldexp function to do the second part of the operation.

>>> int(math.ldexp(math.frexp(24.54883)[0], 4))
12

Answer 2

You can use struct.pack() to convert a floating point number to a list of bytes, and then extract the bits you're interested in from there.

Answer 3

While the number is greater than or equal to 1, divide by 2.
Multiply by 2**n
Round or truncate to an integer.

Here is a simplified Java program for the test case:

public class Test {
  public static void main(String[] args) {
    double in = 24.548838022726972;
    while (in >= 1) {
      in /= 2;
      System.out.println(in);
    }
    in *= 16;
    System.out.println(in);
    System.out.println((int) in);
  }
}

Output:

12.274419011363486
6.137209505681743
3.0686047528408715
1.5343023764204358
0.7671511882102179
12.274419011363486
12

Answer 4

A direct way to obtain the significant bits of the mantissa in the IEEE 754 format with builtin functions is:

In [2]: u=24.54883

In [3]: bin(u.as_integer_ratio()[0])
Out[3]: '0b11000100011001000000000011111011101010001000001001101'

In [4]: u=.625

In [5]: bin(u.as_integer_ratio()[0])
Out[5]: '0b101'

You obtain 0b1 + mantissa without non significant 0.