Bit twiddling floating point numbers

[Jeff.Goldfinkle]

Hi All

Is there a simple way to twiddle the bits of a float? In particular, I
would like to round my float to the n most significant bits.

For example - 0.123 in binary is 0.000111111
Rounding to 4 bits I get 0.0001.

I can pack and unpack a float into a long
e.g.
struct.unpack('I',struct.pack('f',0.123))[0]
but then I'm not sure how to work with the resulting long.

Any suggestions?

[Grant Edwards]

On 2008-03-05, Je*************@gmail.com <Je*************@gmail.comwrote:

Is there a simple way to twiddle the bits of a float? In particular, I
would like to round my float to the n most significant bits.

For example - 0.123 in binary is 0.000111111
Rounding to 4 bits I get 0.0001.

I can pack and unpack a float into a long
e.g.
struct.unpack('I',struct.pack('f',0.123))[0]
but then I'm not sure how to work with the resulting long.

Any suggestions?

Just use the bitwise and/or/not operators: & | ~

--
Grant Edwards grante Yow! Half a mind is a
at terrible thing to waste!
visi.com

[Grant Edwards]

On 2008-03-05, Grant Edwards <gr****@visi.comwrote:

On 2008-03-05, Je*************@gmail.com <Je*************@gmail.comwrote:

>Any suggestions?

Just use the bitwise and/or/not operators: & | ~

Oh, I forgot to mention the shift operators << and >>

--
Grant Edwards grante Yow! All of life is a blur
at of Republicans and meat!
visi.com

[Jeff.Goldfinkle]

On Mar 5, 10:48 pm, Grant Edwards <[e-mail]:

On 2008-03-05, Grant Edwards <[e-mail]:

On 2008-03-05, [e-mail] <[e-mail]:

Any suggestions?

Just use the bitwise and/or/not operators: & | ~

Oh, I forgot to mention the shift operators << and >>

--
Grant Edwards grante Yow! All of life is a blur
at of Republicans and meat!
visi.com

thanks for the reply but I'm still unsure as to how to continue. Using
the bitwise operators will help me deal with integers but I really
want to work with floats. For instance - which bits do I twiddle to
round my float to the nearest number of bits?

Jeff

[Grant Edwards]

On 2008-03-05, Je*************@gmail.com <Je*************@gmail.comwrote:

thanks for the reply but I'm still unsure as to how to
continue. Using the bitwise operators will help me deal with
integers but I really want to work with floats.

In your original post, you said that you've got the values as
integers.

For instance - which bits do I twiddle to round my float to
the nearest number of bits?

The format of a float (actually Python uses doubles) depends on
your platform, but in all likelihood it's the IEEE-754 64-bit
format.

googling for "IEEE-754 format" finds some good references:

http://en.wikipedia.org/wiki/IEEE_fl...point_standard
http://steve.hollasch.net/cgindex/coding/ieeefloat.html
http://www.psc.edu/general/software/...ieee/ieee.html

--
Grant Edwards grante Yow! Well, I'm INVISIBLE
at AGAIN ... I might as well
visi.com pay a visit to the LADIES
ROOM ...

[Mark Dickinson]

On Mar 5, 3:25*pm, "[e-mail]"
<[e-mail]:

I can pack and unpack a float into a long
e.g.
struct.unpack('I',struct.pack('f',0.123))[0]
but then I'm not sure how to work with the resulting long.

Any suggestions?

One alternative to using struct is to use math.ldexp and math.frexp:

>>m, e = frexp(pi)
m

0.78539816339744828

>>e

2

>>int(m*2**53)

7074237752028440L

Then you can do your bit twiddling on int(m*2**53), before using
ldexp to 'repack' the float.

Mark

[Bryan Olson]

Mark Dickinson wrote:

Jeff Goldfin wrote:

>I can pack and unpack a float into a long
e.g.
struct.unpack('I',struct.pack('f',0.123))[0]
but then I'm not sure how to work with the resulting long.

Any suggestions?

One alternative to using struct is to use math.ldexp and math.frexp:

>>>m, e = frexp(pi)
m

0.78539816339744828

>>>e

2

>>>int(m*2**53)

7074237752028440L

Then you can do your bit twiddling on int(m*2**53), before using
ldexp to 'repack' the float.

Ah, those are handy. Jeff described his problem: "In particular,
I would like to round my float to the n most significant bits."
I think this works:

from math import frexp, ldexp, floor

def round_mantissa(x, nbits):
shifter = 1 << nbits
(m, e) = frexp(x)
m = floor(m * shifter + 0.5) / shifter
return ldexp(m, e)
--
--Bryan

[Jeff.Goldfinkle]

On Mar 6, 11:00 am, Bryan Olson <[e-mail]:

Mark Dickinson wrote:

Jeff Goldfin wrote:

I can pack and unpack a float into a long
e.g.
struct.unpack('I',struct.pack('f',0.123))[0]
but then I'm not sure how to work with the resulting long.

Any suggestions?

One alternative to using struct is to use math.ldexp and math.frexp:

>>m, e = frexp(pi)
m

0.78539816339744828

>>e

2

>>int(m*2**53)

7074237752028440L

Then you can do your bit twiddling on int(m*2**53), before using
ldexp to 'repack' the float.

Ah, those are handy. Jeff described his problem: "In particular,
I would like to round my float to the n most significant bits."
I think this works:

from math import frexp, ldexp, floor

def round_mantissa(x, nbits):
shifter = 1 << nbits
(m, e) = frexp(x)
m = floor(m * shifter + 0.5) / shifter
return ldexp(m, e)

--
--Bryan

Thanks for the help - your function seems to fit the bill even better
than gmpy since I don't need an external module. In my case I'll use
m = floor(m * shifter) / shifter instead of m = floor(m * shifter +
0.5) / shifter

Jeff