Thread: Bit Shift in a Byte

Originally Posted by xArt

The best I can think of is using logical operation to split the byte into
a pair of four bit nibbles, shift each of them in either direction,
and then another operation to superimpose them back to a byte.

This seems a lot of time.. Is there a better way?

It seems like five bitwise operations to me, but I could be mistaken:

Code:

x = ((x >> 1) & 0xf0) | ((x << 1) & 0x0f); /* assuming 8-bit bytes */

Have you tested and found that such an approach really is too slow for your requirements? If so, then given that there are 256 possible values, perhaps you could try with a lookup table.

Hi, that is similar approach that I have so far.
No I’m not complaining it’s too slow yet, just checking I’m not doing anything stupid
There will be a lot of these operations.

Here is a problem though.. .what if it were only five bits?
There I am stuck at the moment because there is a middle bit.

EDIT,,, I think I have it... just leave the middle bit alone when separating the nibbles.

Code:

    unsigned char bitbyte = 0b11110101;
    unsigned char opabyte = 0;
    unsigned char opbbyte = 0;
    unsigned char outbyte = 0;


    if (cntone == 0) {


        bitbyte = bitbyte & 0x1F; // clear most significant three bits

        //

        opabyte = bitbyte & 0x0F; // seperate nibble pairs
        opbbyte = bitbyte & 0xF0; //

        opabyte = opabyte << 1; // shift nibbles left and right
        opbbyte = opbbyte >> 1; //

        outbyte = opabyte | opbbyte; // superimpose nibbles to new byte


        NSLog(@":%02x ",opabyte); // working nibble values
        NSLog(@":%02x ",opbbyte); //

        NSLog(@":%02x ",outbyte); // result byte value

        cntone = 1; // send to log only once

    }

Originally Posted by xArt

Here is a problem though.. .what if it were only five bits?
There I am stuck at the moment because there is a middle bit.

EDIT,,, I think I have it... just leave the middle bit alone when separating the nibbles.

I am a little confused though: your solution is essentially the same as mine, which is an implementation of what you described for an 8-bit byte, i.e., you are not treating the case of 5 bits any different from 8 bits, except that coincidentally three of the bits are always zero.

Hi, yes sorry I didn’t explain well, that was just my eight bit example to show I was essentially doing the same thing,
and the clearing of the first three bits was thrown in there when I realised I’m dealing with five bits instead of eight.

I aim to rotate 5x7 monocrome text vertically so that when done to a whole line,
it’s supposed to appear like a demo effect where the old characters individually spin around their vertical axis
and the new character is revealed as if the new character was behind the old character the whole time.

It might get more complicated though.. I’m not sure that just compressing them horizontally and restoring them
will look like spinning at all. It might also require the character is tilted also (which will be a pain in the bum).

Code:

 xxx   xxxx    xxx
x   x  x   x  x   x
x   x  x   x  x
xxxxx  xxxx   x
x   x  x   x  x
x   x  x   x  x   x
x   x  xxxx    xxx

Two steps of squashing them would be this.. and I’m not sure it will be so simple...

Code:

 x   xx    x
x x  x x  x x
x x  x x  x
xxx  xx   x
x x  x x  x
x x  x x  x x
x x  xx    x

Hi again
So I haven’t had much programming time, but recently finished that step handling five bits.
I went for... if the bit either side of the centre bit was set, the new middle bit will be set in the output byte.

The next question I would like to ask is, say I have an array of “bitbyte[s]”, how do I bitwise rotate the LS bit
of each byte in the array? like a two dimensional array that would be easy if it was done with bigger variable types.

The best I can think of is iterate the array, checking with & ,then writing the next bit with | in sequence,
essentially doing a similar thing as the first step?

Code:

    unsigned char bitbyte = 0b11111011;
    unsigned char opabyte = 0;
    unsigned char opbbyte = 0;
    unsigned char outbyte = 0;
unsignedchar midbyte = 0; // buffer to store middle bit


    if (cntone == 0) {

        bitbyte = bitbyte & 0x1F; // clear most significant three bits

        opabyte = bitbyte & 0x03; // seperate nibble pairs
        opbbyte = bitbyte & 0x18; // leaving middle bit alone
        midbyte = bitbyte & 0x0A; // store bits surrounding middle bit

        NSLog(@":%02x ",opabyte); // working nibble values
        NSLog(@":%02x ",opbbyte); //

        opabyte = opabyte << 1; // shift nibbles left and right
        opbbyte = opbbyte >> 1; //

        outbyte = opabyte | opbbyte; // superimpose nibbles to new byte

        if (midbyte != 0) { // correct the middle bit
        outbyte = outbyte | 0x04; // set middle bit
        } else { // cycle time balance
        bitbyte = bitbyte | 0x04; // don't need the input value anymore
        } // midbyte

        NSLog(@":%02x ",opabyte); // working nibble values
        NSLog(@":%02x ",opbbyte); //

        NSLog(@":%02x ",outbyte); // result byte value

        NSLog(@"    "); // spacer

if (cntone < 1) { // not needed for cyclic implementation
        cntone++; // calculate and send to log only once
        }
    }

next step I’m asking about:

Code:

  x x    x x    x x
 x  x  xx  x   x  
x  xx  x  x   x
x x x  x x x  x
xx  x  xx  x  x   x
x      x  x   x  x 
x      x      x

Or what about this overly complicated one liner, complete with error checking?
The first value is the byte you wish to rotate, and the second is by how much. if 'i' is 0, you it will return the value with no changes, if 4, it will return 0, and if above 7 will also return 0, as an error. It's not much of an error, but we have to return something.

Code:

inline uint8_t rotate( uint8_t b, unsigned int i )
{
    return (i < 8) ? ( ( ( b << ( ( i <= 4 ) ? ( i ) : ( 8 -i ) ) ) & 0xf ) | ( ( b >> ( ( i <= 4 ) ? ( i ) : ( 8 - i ) ) ) & 0xf0 ) ) : ( 0 );
}

Edit:

or to go completely overboard:

Code:

typedef uint8_t rotate_type;
inline rotate_type rotate( rotate_type b, unsigned int i )
{
    return (i < ( sizeof( rotate_type ) * 8 )) ? ( ( ( b << ( ( i <= ( sizeof( rotate_type ) *4 ) ) ? ( i ) : ( ( sizeof( rotate_type ) * 8 ) - i ) ) ) & 0xf ) | ( ( b >> ( ( i <= ( sizeof( rotate_type ) * 4 ) ) ? ( i ) : ( ( sizeof( rotate_type ) * 8 ) - i ) ) ) & 0xf0 ) ) : ( 0 );
}

Best of luck figuring it out.