bit-manipulation

I have a very typical situation. We have a table called Users which has a column called Branches (varchar 1000). The organization can have 1000 branches. So if a user has access to branch 1, 5, and 10, the branches string would look like: 1000100001000000000...... (i.e. 1 for a position a User has branch access to based on the branch's number). Please do not advise better data storage options, this is coming to me from a legacy application that is deployed across continents. Now given this background (and considering that there can be > 10000 users), I want to search for all Users who have

Let me start with some background: By "tribool" I understand a variable which can hold one of the following values: true , false or null . In question Copying array of ints vs pointers to bools , the OP wanted to have an array of tribools (more or less) which would be as small as possible. With "a bit of" most basic bit-fu I came up a solution which used 2 bits per tribool and allowed to store the OP's array of 64 tribools in 16 bytes, which is OK. The tribool mechanics I used were simple, like: boolean A means "null or not null", boolean B means "true or false if not null". But then I thought

In the golang color package, there is a method to get r,g,b,a values from an RGBA object: func (c RGBA) RGBA() (r, g, b, a uint32) { r = uint32(c.R) r |= r << 8 g = uint32(c.G) g |= g << 8 b = uint32(c.B) b |= b << 8 a = uint32(c.A) a |= a << 8 return } If I were to implement this simple function, I would just write this func (c RGBA) RGBA() (r, g, b, a uint32) { r = uint32(c.R) g = uint32(c.G) b = uint32(c.B) a = uint32(c.A) return } What's the reason r |= r << 8 is used? From the the excellent " The Go image package " blogpost: [...] the channels have a 16-bit effective range: 100% red is

Let's say you have a uint64_t and care only about the high order bit for each byte in your uint64_t. Like so: uint32_t: 0000 ... 1000 0000 1000 0000 1000 0000 1000 0000 ---> 0000 1111 Is there a faster way than: return ( ((x >> 56) & 128)+ ((x >> 49) & 64)+ ((x >> 42) & 32)+ ((x >> 35) & 16)+ ((x >> 28) & 8)+ ((x >> 21) & 4)+ ((x >> 14) & 2)+ ((x >> 7) & 1) ) Aka shifting x, masking, and adding the correct bit for each byte? This will compile to a lot of assembly and I'm looking for a quicker way... The machine I'm using only has up to SSE2 instructions and I failed to find helpful SIMD ops.

I need to make uint64_t out of 2 uint32_t interleaving the bits: if A=a0a1a2...a31 and B=b0b1...b31 , I need C= a0b0a1b1...a31b31 . Is there a way to do this efficiently? So far I've got only the naive approach with a for loop of 32 iterations, where each iteration does C|=((A&(1<<i))<<i)|((B&(1<<i))<<(i+1)) . I guess there should be some mathematical trick like multiplying A and B by some special number which results in interleaving their bits with zeros in the resulting 64-bit number, so that what only remains is to or these products. But I can't find such multiplier. Another potential way

I would like to manipulate the bitwise representation of floating-point numbers in C#. BinaryWriter and BinaryReader do it this way: public virtual unsafe void Write(double value) { ulong num = *((ulong*) &value); ... } public virtual unsafe double ReadDouble() { ... ulong num3 = ...; return *((double*) &num3); } Is there a way to do this without unsafe code, and without the overhead of actually using BinaryWriter and BinaryReader? Are you trying to avoid unsafe code altogether, or do you just want an alternative to those specific methods on BinaryReader and BinaryWriter ? You could use