Reversing Bit Order.. i.e. MSB becomes bit 0, LSB becomes bit 15

I

Ian Collins

Anyone know of an efficient way of reversing the bits of a word??
Not portably, some instructions sets may have a quick way to do this,
otherwise shift and add.
 
B

BobR

Anyone know of an efficient way of reversing the bits of a word??

{ using std::cout; // for NG post
size_t num( 12345 );
// std::bitset<32> Bits( num ); // #include <bitset>
std::bitset<std::numeric_limits<size_t>::digits> Bits( num );

cout<<"size_t num="<<num<<std::endl;
cout<<"bitset<32> Bits="<<Bits<<std::endl;
Bits.flip();
cout<<"bitset<32> Bits="<<Bits<<std::endl;
num = Bits.to_ulong(); // be careful with sizes.
cout<<"size_t num="<<num<<std::endl;

size_t num2( 12345 );
cout<<"size_t num2="<<num2<<std::endl;
num2 = ~num2;
cout<<"size_t num2="<<num2<<std::endl;
}
/* -output-
size_t num=12345
bitset<32> Bits=00000000000000000011000000111001
bitset<32> Bits=11111111111111111100111111000110
size_t num=4294954950
size_t num2=12345
size_t num2=4294954950
*/
 
R

Ron Natalie

Ian said:
Nope, where these are available, they reverse the byte order.
Where they are available they convert the native byte order to
the network (big end) ordering. Whether it is a swap or not
depends whether the machine is already in the network order.
 
J

Juha Nieminen

Anyone know of an efficient way of reversing the bits of a word??

Reverse all the bits in a 32 bit word:

n = ((n >> 1) & 0x55555555) | ((n << 1) & 0xaaaaaaaa) ;
n = ((n >> 2) & 0x33333333) | ((n << 2) & 0xcccccccc) ;
n = ((n >> 4) & 0x0f0f0f0f) | ((n << 4) & 0xf0f0f0f0) ;
n = ((n >> 8) & 0x00ff00ff) | ((n << 8) & 0xff00ff00) ;
n = ((n >> 16) & 0x0000ffff) | ((n << 16) & 0xffff0000) ;
 
B

benn686

Wow! That is slick, and it worked nicely too!

Not quite sure how it works, but for 16 bits, would it work something
like:

n = ((n >> 1) & 0x5555) | ((n << 1) & 0xaaaa) ;
n = ((n >> 2) & 0x3333) | ((n << 2) & 0xcccc) ;
n = ((n >> 4) & 0x0f0f) | ((n << 4) & 0x0f0f) ;
 
H

hurcan solter

Wow! That is slick, and it worked nicely too!

Not quite sure how it works, but for 16 bits, would it work something
like:

n = ((n >> 1) & 0x5555) | ((n << 1) & 0xaaaa) ;
n = ((n >> 2) & 0x3333) | ((n << 2) & 0xcccc) ;
n = ((n >> 4) & 0x0f0f) | ((n << 4) & 0x0f0f) ;

Textbook example; and please dont top-post...
template<typename T>
T reverseBits(T inval){

T retval=0;
numberofbits= sizeof(T) * CHAR_BITS;
for ( int i = 0; i < numberofbits; ++i ) {
retval = ( retval << 1 ) | ( inval & 1 );
inval >>= 1;
}
return retval;
}
 
J

Juha Nieminen

Wow! That is slick, and it worked nicely too!

Not quite sure how it works, but for 16 bits, would it work something
like:

n = ((n >> 1) & 0x5555) | ((n << 1) & 0xaaaa) ;
n = ((n >> 2) & 0x3333) | ((n << 2) & 0xcccc) ;
n = ((n >> 4) & 0x0f0f) | ((n << 4) & 0x0f0f) ;

I believe it additionally needs:

n = ((n >> 8) & 0x00ff) | ((n << 8) & 0xff00) ;
 

Ask a Question

Want to reply to this thread or ask your own question?

You'll need to choose a username for the site, which only take a couple of moments. After that, you can post your question and our members will help you out.

Ask a Question

Members online

Forum statistics

Threads
473,733
Messages
2,569,440
Members
44,832
Latest member
GlennSmall

Latest Threads

Top