Velocity Reviews > C++ > floating point bitwise & and >> operations

# floating point bitwise & and >> operations

jawilson2@gmail.com
Guest
Posts: n/a

 04-18-2006
Hello,
I have some data that stores two 16-bit integers in a 32-bit float, and
I would like to extract the data. I want to do something like

//-----------------------------------------------------------------
float *data;
short *buff;
int dataLen; //number of points in data

//other code...

for (i = 0; i < dataLen; i++)
{
buff[2*i] = (data[i] & 0x0F); // place the lower 16 bits in the
first sample
buff[2*i + 1] = (data[i] & 0xF0) >> 16; //place the upper 16 bits
(and bit shifted)in the second sample
}
//------------------------------------------------------------------

Does this make sense? I'm thinking it will involve casting the data
variable as an int/short somehow, using something like:

buff[2*i] = ( *(int*)&data[i] ...); //found this on another forum, does
this work?

Any ideas?
Thanks!

Victor Bazarov
Guest
Posts: n/a

 04-18-2006
http://www.velocityreviews.com/forums/(E-Mail Removed) wrote:
> I have some data that stores two 16-bit integers in a 32-bit float,

WHY??? Can't you store those integers in a 32-bit _integer_? Use
'long' or 'unsigned long'.

> and I would like to extract the data. I want to do something like
>
> //-----------------------------------------------------------------
> float *data;
> short *buff;
> int dataLen; //number of points in data
>
> //other code...
>
> for (i = 0; i < dataLen; i++)
> {
> buff[2*i] = (data[i] & 0x0F); // place the lower 16 bits in the
> first sample

That's not 16 bits. That's 4 bits. 0x0F == 0b00001111.

> buff[2*i + 1] = (data[i] & 0xF0) >> 16; //place the upper 16 bits
> (and bit shifted)in the second sample

That's not "upper 16 bits". That's 0.

> }
> //------------------------------------------------------------------
>
> Does this make sense?

No.

> I'm thinking it will involve casting the data
> variable as an int/short somehow, using something like:
>
> buff[2*i] = ( *(int*)&data[i] ...); //found this on another forum,
> does this work?
>
> Any ideas?

Don't do it.

V
--

jawilson2@gmail.com
Guest
Posts: n/a

 04-18-2006
>WHY??? Can't you store those integers in a 32-bit _integer_? Use
>'long' or 'unsigned long'.

Ok, let me clarify. I am reading data from hardware that compresses two
16-bit integer values into a single 32-bit float. I do not have any
control over this; the data is read into my program as a float.

> That's not 16 bits. That's 4 bits. 0x0F == 0b00001111.

Oops. It is correct in my program (i.e. 0x0000FFFF).

So, given that the data must be stored in a float, and that the float
contains 2 16-bit integers, how do I get to the integers?

Victor Bazarov
Guest
Posts: n/a

 04-18-2006
(E-Mail Removed) wrote:
>> WHY??? Can't you store those integers in a 32-bit _integer_? Use
>> 'long' or 'unsigned long'.

>
> Ok, let me clarify. I am reading data from hardware that compresses
> two 16-bit integer values into a single 32-bit float. I do not have
> any control over this; the data is read into my program as a float.

OK... Really? Wow. Floats, eh? Well, fine.

>> That's not 16 bits. That's 4 bits. 0x0F == 0b00001111.

>
> Oops. It is correct in my program (i.e. 0x0000FFFF).
>
> So, given that the data must be stored in a float, and that the float
> contains 2 16-bit integers, how do I get to the integers?

Non-portable way would be to extract chars (unsigned are probably better)

void float_to_2_ints(float f, int i[2])
{
char* pc = static_cast<char*>(&f);
i[0] = (((unsigned char)pc[0]) << | ((unsigned char)pc[1]);
i[1] = (((unsigned char)pc[2]) << | ((unsigned char)pc[3]);
}

If the order of integers and/or chars in the float is different than the
one assumed here, you'd need to swap "pc[0/2]" with "pc[1/3]" and/or "i[0]"
with "i[1]". It all depends on the endianness of the hardware and your
system.

V
--

dan2online
Guest
Posts: n/a

 04-18-2006
> Ok, let me clarify. I am reading data from hardware that compresses two
> 16-bit integer values into a single 32-bit float. I do not have any
> control over this; the data is read into my program as a float.
>
> > That's not 16 bits. That's 4 bits. 0x0F == 0b00001111.

>
> Oops. It is correct in my program (i.e. 0x0000FFFF).
>
> So, given that the data must be stored in a float, and that the float
> contains 2 16-bit integers, how do I get to the integers?

At first, the question seems to be a topic of C programming not C++.

bitwise and shift perhaps depend on the compression format. I think you
need to clarify:
(1) two 16bit intergers only occupy the space of 32-bit float , or
(2) two 16bit integers stored in the float format (some hardwares

In the first case, bitwise and >> are not correct in your code.
e.g. buff[2*i] = (data[i] & 0x0000FFFF)
you cannot bitwise between float and short.
one simple way is to move or copy the memory content between them
directly.

for (i = 0; i < dataLen; i++)
{
/* data[i] 32bit -> buff[2*i], buff[2*i+1] */
memmov( (char *) &(buff[2*i]), (char *) &data[i], sizeof(short) * 2)
.....
}

Alex Buell
Guest
Posts: n/a

 04-19-2006
On Tue, 18 Apr 2006 12:44:25 -0400 "Victor Bazarov"
<(E-Mail Removed)> waved a wand and this message magically
appeared:

> > Ok, let me clarify. I am reading data from hardware that compresses
> > two 16-bit integer values into a single 32-bit float. I do not have
> > any control over this; the data is read into my program as a float.

>
> OK... Really? Wow. Floats, eh? Well, fine.

I *really* would like to know what sort of braindamaged hardware
does this and who the hardware designers were so I can shoot them.

--
http://www.munted.org.uk

Take a nap, it saves lives.

Victor Bazarov
Guest
Posts: n/a

 04-19-2006
Alex Buell wrote:
> On Tue, 18 Apr 2006 12:44:25 -0400 "Victor Bazarov"
> <(E-Mail Removed)> waved a wand and this message magically
> appeared:
>
>>> Ok, let me clarify. I am reading data from hardware that compresses
>>> two 16-bit integer values into a single 32-bit float. I do not have
>>> any control over this; the data is read into my program as a float.

>>
>> OK... Really? Wow. Floats, eh? Well, fine.

>
> I *really* would like to know what sort of braindamaged hardware
> does this and who the hardware designers were so I can shoot them.

I bet it's not hardware designers. Hardware just sends integers, two in
a row, probably. It's software designers who develop the interface to
expose them as 'float' types. Which actually kindof makes me think, what
if you instead of declaring the 'float*' on the receiving side, declare
'long*'? It's so much easier to unpack. And the sizes are most likely
the same... If you don't care about portability, cheat _them_ and right
there, where it all begins, instead of cheating yourself later.

V
--

 Posting Rules You may not post new threads You may not post replies You may not post attachments You may not edit your posts BB code is On Smilies are On [IMG] code is On HTML code is OffTrackbacks are On Pingbacks are On Refbacks are Off Forum Rules

 Similar Threads Thread Thread Starter Forum Replies Last Post Saraswati lakki ASP .Net 0 01-06-2012 06:39 AM MariuszK VHDL 8 10-04-2008 03:50 PM alex C++ 4 12-22-2006 10:47 AM alex C Programming 3 12-22-2006 10:46 AM H aka N VHDL 0 01-18-2006 08:09 AM