CODEWITHSUNDEEP
c#.netbitwise-operatorsfixedbit-shift
Jason
Jason

Reputation: 2197

Odd bit shifting results in C#

Given that i have a uint value of 2402914, and i would like to grab the leftmost 17 bits, where is the fault in my logic by doing this code:

int testop = 0;
byte[] myArray = BitConverter.GetBytes(2402914);    
fixed (byte* p = &myArray[0])    
{   
    testop = *p >> 15;    
}

my expected output is

50516.

Upvotes: 3

Views: 628

Answers (4)

Aasmund Eldhuset
Aasmund Eldhuset

Reputation: 38010

*p just gives you the first byte; it is equivalent to p[0]. You'll have to use shifting and ORing to combine bits from the first three bytes (or the last three bytes, depending on endianness...)

If this code is not a simplified version of something more complicated and you're actually trying to just extract the leftmost 17 bits from an int, this should do:

int testop = (someInt >> 15) & 0x1ffff;

(Edit: Added & 0x1ffff to make it work for negative integers too; thanks to @James.)

Upvotes: 1

Jason Goemaat
Jason Goemaat

Reputation: 29234

Wow, this has been a really fun puzzle to figure out. Not the programming part, but trying to figure out where you got the number 50516 and what you are trying to do with your code. It looks like you are taking the 16 least significant bits and ROTATING them LEFT 9 bits.

2402914: 0000 0000 0010 0100 1010 1010 0110 0010
 left 9: 0100 1001 0101 0100 1100 010 
  match:                     ^^^^ ^^^  
>>50516:                     1100 0101 0101 0100
  match:                             ^ ^^^^ ^^^^
right 7:                             1 0101 0100 110 0010

int value2 = value & 0xffff;
int rotate9left = ((value2 << 9) & 0xffff) | ((value2) >> (16 - 9));

I don't know why you are using a byte array, but it seems like you think your fixed() statement is looping through the array, which it is not. Your statement in the fixed block is taking the byte value at myArray[0] and SHIFTing it right 15 bits (shifting fills with 0s as opposed to rotating which wraps the front bits around to the back). Any thing over 8 would give you zero.

Upvotes: 1

Jon Egerton
Jon Egerton

Reputation: 41589

From what I understand, you can apply the bit-shift operator directly to the int datatype, rather than going through the trouble of the unsafe code.

For example:

2402914 >> 15 = 73

This ties to the result predicted by Jason.

Further, I note that

2402914 >> 5 = 75091
and 2402914 >> 6 = 37545

This suggests that your required result cannot be achieved by any similar right shift.

Upvotes: 0

jason
jason

Reputation: 241789

You might want to get your expectations to match reality. A right-shift is equivalent to dividing by 2. You are effectively dividing by 2 fifteen times, which is the same as saying you are dividing by 2^15 = 32768. Note that 2402914 / 32768 = 73 (truncating the remainder).

Therefore, I would expect the result to be 73, not 50516.

In fact,

2402914_10 = 0000 0000 0010 0100 1010 1010 0110 0010_2

So that the left-most seventeen bits are

             0000 0000 0010 0100 1

Note that

0000 0000 0010 0100 1 = 1 * 1 + 0 * 2 + 0 * 4 + 1 * 8 + 0 * 16 + 0 * 32 + 1 * 64 
                      = 73

Note that you can obtain this result more simply with

int testop = 2402914 >> 15;

Upvotes: 3

Related Questions