Velocity Reviews > reversing a byte

# reversing a byte

Ajay
Guest
Posts: n/a

 03-22-2006
Hi all,can you please tell the most efficient method to reverse a
byte.Function should return a byte that is reversed.

Keith Thompson
Guest
Posts: n/a

 03-22-2006
"Ajay" <(E-Mail Removed)> writes:
> Hi all,can you please tell the most efficient method to reverse a
> byte.Function should return a byte that is reversed.

By writing a function to do it. C would be a good choice of language

Good luck.

If you want somebody else to do it for you, I'm sure you can find
someone willing to discuss consulting rates. If this is homework,
solutions directly.

--
Keith Thompson (The_Other_Keith) http://www.velocityreviews.com/forums/(E-Mail Removed) <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <*> <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.

Charles Mills
Guest
Posts: n/a

 03-22-2006
Ajay wrote:
> Hi all,can you please tell the most efficient method to reverse a
> byte.Function should return a byte that is reversed.

Use a look up table (untested generated code below):

static unsigned char
reverse_byte(unsigned char b)
{
static const unsigned char b_tbl[] = {
0xff, 0xfe, 0xfd, 0xfc, 0xfb, 0xfa, 0xf9, 0xf8,
0xf7, 0xf6, 0xf5, 0xf4, 0xf3, 0xf2, 0xf1, 0xf0,
0xef, 0xee, 0xed, 0xec, 0xeb, 0xea, 0xe9, 0xe8,
0xe7, 0xe6, 0xe5, 0xe4, 0xe3, 0xe2, 0xe1, 0xe0,
0xdf, 0xde, 0xdd, 0xdc, 0xdb, 0xda, 0xd9, 0xd8,
0xd7, 0xd6, 0xd5, 0xd4, 0xd3, 0xd2, 0xd1, 0xd0,
0xcf, 0xce, 0xcd, 0xcc, 0xcb, 0xca, 0xc9, 0xc8,
0xc7, 0xc6, 0xc5, 0xc4, 0xc3, 0xc2, 0xc1, 0xc0,
0xbf, 0xbe, 0xbd, 0xbc, 0xbb, 0xba, 0xb9, 0xb8,
0xb7, 0xb6, 0xb5, 0xb4, 0xb3, 0xb2, 0xb1, 0xb0,
0xaf, 0xae, 0xad, 0xac, 0xab, 0xaa, 0xa9, 0xa8,
0xa7, 0xa6, 0xa5, 0xa4, 0xa3, 0xa2, 0xa1, 0xa0,
0x9f, 0x9e, 0x9d, 0x9c, 0x9b, 0x9a, 0x99, 0x98,
0x97, 0x96, 0x95, 0x94, 0x93, 0x92, 0x91, 0x90,
0x8f, 0x8e, 0x8d, 0x8c, 0x8b, 0x8a, 0x89, 0x88,
0x87, 0x86, 0x85, 0x84, 0x83, 0x82, 0x81, 0x80,
0x7f, 0x7e, 0x7d, 0x7c, 0x7b, 0x7a, 0x79, 0x78,
0x77, 0x76, 0x75, 0x74, 0x73, 0x72, 0x71, 0x70,
0x6f, 0x6e, 0x6d, 0x6c, 0x6b, 0x6a, 0x69, 0x68,
0x67, 0x66, 0x65, 0x64, 0x63, 0x62, 0x61, 0x60,
0x5f, 0x5e, 0x5d, 0x5c, 0x5b, 0x5a, 0x59, 0x58,
0x57, 0x56, 0x55, 0x54, 0x53, 0x52, 0x51, 0x50,
0x4f, 0x4e, 0x4d, 0x4c, 0x4b, 0x4a, 0x49, 0x48,
0x47, 0x46, 0x45, 0x44, 0x43, 0x42, 0x41, 0x40,
0x3f, 0x3e, 0x3d, 0x3c, 0x3b, 0x3a, 0x39, 0x38,
0x37, 0x36, 0x35, 0x34, 0x33, 0x32, 0x31, 0x30,
0x2f, 0x2e, 0x2d, 0x2c, 0x2b, 0x2a, 0x29, 0x28,
0x27, 0x26, 0x25, 0x24, 0x23, 0x22, 0x21, 0x20,
0x1f, 0x1e, 0x1d, 0x1c, 0x1b, 0x1a, 0x19, 0x18,
0x17, 0x16, 0x15, 0x14, 0x13, 0x12, 0x11, 0x10,
0xf, 0xe, 0xd, 0xc, 0xb, 0xa, 0x9, 0x8,
0x7, 0x6, 0x5, 0x4, 0x3, 0x2, 0x1, 0x0
};
return b_tbl[b];
}

-Charlie

Charles Mills
Guest
Posts: n/a

 03-22-2006

Charles Mills wrote:
> Ajay wrote:
> > Hi all,can you please tell the most efficient method to reverse a
> > byte.Function should return a byte that is reversed.

>
> Use a look up table (untested generated code below):
>
> static unsigned char
> reverse_byte(unsigned char b)
> {
> static const unsigned char b_tbl[] = {

---8<---- sniped totally wrong lookup table ---8<----
> };
> return b_tbl[b];
> }
>
> -Charlie

probably want something like this:
static const unsigned char b_tbl[] = {
0x0, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0,
0x10, 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 0xf0,
...,
0xf, 0x8f, 0x4f, 0xcf, 0x2f, 0xaf, 0x6f, 0xef,
0x1f, 0x9f, 0x5f, 0xdf, 0x3f, 0xbf, 0x7f, 0xff
};

you can fill in the blanks.

-Charlie

Charles Mills
Guest
Posts: n/a

 03-22-2006

Charles Mills wrote:
> Ajay wrote:
> > Hi all,can you please tell the most efficient method to reverse a
> > byte.Function should return a byte that is reversed.

>
> Use a look up table (untested generated code below):
>
> static unsigned char
> reverse_byte(unsigned char b)
> {
> static const unsigned char b_tbl[] = {

---8<---- sniped totally wrong lookup table ---8<----
> };
> return b_tbl[b];
> }
>
> -Charlie

probably want something like this:
static const unsigned char b_tbl[] = {
0x0, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0,
0x10, 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 0xf0,
...,
0xf, 0x8f, 0x4f, 0xcf, 0x2f, 0xaf, 0x6f, 0xef,
0x1f, 0x9f, 0x5f, 0xdf, 0x3f, 0xbf, 0x7f, 0xff
};

you can fill in the blanks.

-Charlie

sudharsan
Guest
Posts: n/a

 03-22-2006
Hi
I give here a piece of code to reverse a byte but iam not sure how good
it is...

unsigned int n=0x01;
unsinged int c=0x00;
int i;
/* b is given byte */
for( i=0; i<8 ;i++)
{
if( b & n) { c=c + 1;}
c<<1;
n<<1;
}
/* the reversed value is stored in c */
--------------------
any one please correct this if any wrong.

Ajay wrote:
> Hi all,can you please tell the most efficient method to reverse a
> byte.Function should return a byte that is reversed.

CBFalconer
Guest
Posts: n/a

 03-22-2006
Charles Mills wrote:
> Charles Mills wrote:
> > Ajay wrote:

>
>>> Hi all,can you please tell the most efficient method to reverse
>>> a byte.Function should return a byte that is reversed.

>>
>> Use a look up table (untested generated code below):
>>
>> static unsigned char
>> reverse_byte(unsigned char b)
>> {
>> static const unsigned char b_tbl[] = {

> ---8<---- sniped totally wrong lookup table ---8<----
>> };
>> return b_tbl[b];
>> }

>
> probably want something like this:
> static const unsigned char b_tbl[] = {
> 0x0, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0,
> 0x10, 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 0xf0,
> ...,
> 0xf, 0x8f, 0x4f, 0xcf, 0x2f, 0xaf, 0x6f, 0xef,
> 0x1f, 0x9f, 0x5f, 0xdf, 0x3f, 0xbf, 0x7f, 0xff
> };
>
> you can fill in the blanks.

Works like a charm, NOT, when CHAR_BIT > 8. i.e. document hidden
assumptions. In order of execution:

unsigned char* b_tbl = malloc(1 + UCHAR_MAX);
...
/* code to initialize table, after checking it is non-NULL. */
...
/* code that uses the table */

--
"If you want to post a followup via groups.google.com, don't use
the broken "Reply" link at the bottom of the article. Click on
"show options" at the top of the article, then click on the

Guest
Posts: n/a

 03-22-2006

sudharsan wrote:

Don't top-post. I've corrected it here...

> Ajay wrote:
> > Hi all,can you please tell the most efficient method to reverse a
> > byte.Function should return a byte that is reversed.

> Hi
> I give here a piece of code to reverse a byte but iam not sure how good
> it is...

Why bother posting untested and uncompilable code in response to
someone's question?

#include <stdio.h>
#include <stdlib.h>

int main(void)
{

> unsigned int n=0x01;
> unsinged int c=0x00;

You surely mean:

unsigned int c = 0x00;

unsigned int b = 15;

> int i;
> /* b is given byte */
> for( i=0; i<8 ;i++)
> {
> if( b & n) { c=c + 1;}

You never declare `b`, let alone assign it value.

> c<<1;
> n<<1;

These two do precisely nothing (useful);

> }
> /* the reversed value is stored in c */

printf("b = %d, c = %d\n", b, c);

return 0;
}

So the result is "b = 15, c = 8", `c` being 8 for any `b`.

> any one please correct this if any wrong.

I've corrected above it so it will compile and run. Now it's your turn
to correct the logic. You did have an idea how to do this, didn't you?

--

santosh
Guest
Posts: n/a

 03-22-2006
Ajay wrote:
> Hi all,can you please tell the most efficient method to reverse a
> byte.Function should return a byte that is reversed.

Your question is not very clear. Do you need to reverse the *value* of
the bits in a byte or do you need to reverse their *position*? If you
need to do the former, you can use C's complement operator, (~). If the
latter, you'll need to write a function to do it. If you want it to be
very fast, probably using a 256 byte look-up table is the way to go.

Pedro Graca
Guest
Posts: n/a

 03-22-2006
sudharsan wrote:
> I give here a piece of code to reverse a byte but iam not sure how good
> it is...

Well, I'm not commenting on how good it is ... but
a) it's not portable.
b) you could have posted the full function definition
c) it's very poorly indented.
d) your use of whitespace is very strange.

#include <limits.h> /* for CHAR_BIT */

unsigned int reverse_byte(unsigned int b) {
> unsigned int n=0x01;
> unsinged int c=0x00;
> int i;
> /* b is given byte */

#if 0
> for( i=0; i<8 ;i++)

#endif

/* Why do you assume a byte is 8 bits? */
for( i=0; i<CHAR_BIT ;i++)

> {
> if( b & n) { c=c + 1;}
> c<<1;
> n<<1;
> }
> /* the reversed value is stored in c */

return c;
}

> --------------------
> any one please correct this if any wrong.

--