Thread: Bitwise rotate array

One gold star please

Code:

void shiftr(void *object, size_t size) {
    
    unsigned char *byte;
    for ( byte = object; size--; ++byte ) {
        
    unsigned char bit = 0;
    if ( size ) {
    bit = byte[1] & (1 >> (CHAR_BIT + 1)) ? 1 : 0;
    }
        
    *byte >>= 1;
    *byte  |= bit;
    }
}

EDIT,,,, bah! it's still not correct!

Just for simplicity, I'll use a variable of 4 bits

Is this what you need to do?

(notation value[element])

Before
1001[0] 1101[1] 0010[2]

after
0100[0] 1110[1] 1001[2]


If so, the algorithm should be easy to figure out...
if last element was odd before being shifted, then n = (n>>1) + 1000
otherwise n = n>>1

Yes, but looking at the results further,
it doesn't look like the original function carries the bit that drops off the left,
and feeds it into the right of the array, so it's not exactly what I'm after.
If you rotate it enough, the array will end up all zeros.

EDIT,,

this is the big rotate I really wanted (shift left though), but I didn't do it.

Code:

void shiftl(void *object, size_t size) {
    
    unsigned char *byte;
    
    byte = object;  // NEW
    unsigned char leftbit = byte[1] & (1 << (CHAR_BIT - 1)) ? 1 : 0;   // NEW
    for ( byte = object; size--; ++byte ) {
        
        
        unsigned char bit = 0;
        if ( size ) {


            bit = byte[1] & (1 << (CHAR_BIT - 1)) ? 1 : 0;
        }
        else {
            bit = leftbit;  // NEW
        }  // NEW
        *byte <<= 1;
        *byte  |= bit;
    }
}

I'm having a hard time trying to figure out what you want to do.

Can you post your most current "shiftr()" and I'll have a look at what could be going wrong.

Now you've created a problem if the size of the buffer is less than 2 bytes.
I'd remove the conditional out of the loop. The following should perform correct rotates, both intentionally processing the bytes in the same order, as you had it:

Code:

void shiftl(void *object, size_t size) {
    unsigned char *byte, *last;
    unsigned char firstBit;
    if (size != 0) {
        byte = object;
        last = byte + size-1;
        firstBit = byte[0] >> (CHAR_BIT-1);
        while (byte < last) {
            byte[0] = (byte[0] << 1) | (byte[1] >> (CHAR_BIT-1));
            ++byte;
        }
        (*last) = (*last) << 1 | firstBit;
    }
}

void shiftr(void *object, size_t size) {
    unsigned char *byte, *end;
    unsigned char bit, nextBit;
    if (size != 0) {
        byte = object;
        end = byte + size;
        bit = *(end-1) & 1;
        while (byte < end) {
            nextBit = byte[0] & 1;
            byte[0] = (byte[0] >> 1) | (bit << (CHAR_BIT-1));
            ++byte;
            bit = nextBit;
        }
    }
}

I read the rules, and thought you weren't supposed to do handouts...
Thanks tho

The last function posted is the most current because it feeds the bits dropped from
the left end of the array back into the right end so it's a big rotate rather than a big shift.

Oh was this not for work reasons?
Well, you pretty much had a solution anyway, and I didn't actually test mine either so it might have horrible bugs in it.