bit-manipulation

I'm getting results from left shift to which I could not find an explanation. unsigned char value = 0xff; // 1111 1111 unsigned char = 0x01; // 0000 0001 std::cout << "SIZEOF value " << sizeof(value) << "\n"; // prints 1 as expected std::cout << "SIZEOF shift " << sizeof(shift) << "\n"; // prints 1 as expected std::cout << "result " << (value << shift) << "\n"; // prints 510 ??? std::cout << "SIZEOF result " << sizeof(value << shift) << "\n"; // prints 4 ??? I was expecting result to be 1111 1110 but instead I get int (?) with value of 1 1111 1110 . How can the bits of an unsigned char be

This fails, not surprisingly: >>> 'abc' << 8 Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: unsupported operand type(s) for <<: 'str' and 'int' >>> With ascii abc being equal to 011000010110001001100011 or 6382179 , is there a way to shift it some arbitrary amount so 'abc' << 8 would be 01100001011000100110001100000000 ? What about other bitwise operations? 'abc' & 63 = 100011 etc? What you probably want is the bitstring module (see http://code.google.com/p/python-bitstring/ ). It seems to support bitwise operations as well as a bunch of other manipulations

In Go's crytography library, I found this function ConstantTimeByteEq . What does it do, how does it work? // ConstantTimeByteEq returns 1 if x == y and 0 otherwise. func ConstantTimeByteEq(x, y uint8) int { z := ^(x ^ y) z &= z >> 4 z &= z >> 2 z &= z >> 1 return int(z) } x ^ y is x XOR y , the result has 1 for the bits x and y are different and 0 for the bits they are same: x = 01010011 y = 00010011 x ^ y = 01000000 ^(x ^ y) negates this, i.e., you get 0 for the bits they are different and 1 otherwise: ^(x ^ y) = 10111111 => z Then we start shifting z to right for masking its bits by itself.

I'm trying to implement a data compression idea I've had, and since I'm imagining running it against a large corpus of test data, I had thought to code it in C (I mostly have experience in scripting languages like Ruby and Tcl.) Looking through the O'Reilly 'cow' books on C, I realize that I can't simply index the bits of a simple 'char' or 'int' type variable as I'd like to to do bitwise comparisons and operators. Am I correct in this perception? Is it reasonable for me to use an enumerated type for representing a bit (and make an array of these, and writing functions to convert to and from

Question says it all. If I have this for a 96-bit field: uint32_t flags[3]; //(thanks @jalf!) How do I best go about accessing this, given that my subfields therein may lie over the 32-bit boundaries (eg. a field that runs from bit 29 to 35)? I need my accesses to be as fast as possible, so I'd rather not iterate over them as 32-bit elements of an array. [This answer is valid for C (and by extension, for C++ as well).] The platform-independent way is to apply bit-masks and bit-shifts as appropriate. So to get your field from 29 to 35 (inclusive): (flags[1] & 0xF) << 3 | (flags[0] & 0xE0000000)

I am trying to find the parity of a bitstring so that it returns 1 if x has an odd # of 0's. I can only use basic bitwise operations and what I have so far passes most of the tests, but I'm wondering 2 things: Why does x ^ (x + ~1) work? I stumbled upon this, but it seems to give you 1 if there are an odd number of bits and something else if even. Like 7^6 = 1 because 7 = 0b0111 Is this the right direction of problem solving for this? I'm assuming my problem is stemming from the first operation, specifically (x + ~1) because it would overflow certain 2's complement numbers. Thanks Code: int

I am looking for a bit-wise test equivalent to (num%2) == 0 || (num%3) == 0 . I can replace num%2 with num&1 , but I'm still stuck with num%3 and with the logical-or. This expression is also equivalent to (num%2)*(num%3) == 0 , but I'm not sure how that helps. Yes, though it's not very pretty, you can do something analogous to the old "sum all the decimal digits until you have only one left" trick to test if a number is divisible by 9, except in binary and with divisibility by 3. You can use the same principle for other numbers as well, but many combinations of base/divisor introduce annoying

I am using a technology called DDS and in the IDL, it does not support int . So, I figured I would just use short . I don't need that many bits. However, when I do this: short bit = 0; System.out.println(bit); bit = bit | 0x00000001; System.out.println(bit); bit = bit & ~0x00000001; bit = bit | 0x00000002; System.out.println(bit); It says "Type mismatch: Cannot convert from int to short". When I change short to long , it works fine. Is it possible to perform bitwise operations like this on a short in Java? Nayuki When doing any arithmetic on byte , short , or char , the numbers are promoted to