bit-manipulation

I have some critical branching code inside a loop that's run about 2^26 times. Branch prediction is not optimal because m is random. How would I remove the branching, possibly using bitwise operators? bool m; unsigned int a; const unsigned int k = ...; // k >= 7 if(a == 0) a = (m ? (a+1) : (k)); else if(a == k) a = (m ? 0 : (a-1)); else a = (m ? (a+1) : (a-1)); And here is the relevant assembly generated by gcc -O3 : .cfi_startproc movl 4(%esp), %edx movb 8(%esp), %cl movl (%edx), %eax testl %eax, %eax jne L15 cmpb $1, %cl sbbl %eax, %eax andl $638, %eax incl %eax movl %eax, (%edx) ret L15:

I try to implement a bitwise filter using MYSQL (with udf if needed) The filter is something like a AND but I want to use the mask to build a new bit string... Let me explain you with a sample : Suppose I have a table with blob storing 8 bit streams: data1: 10110110 data2: 01100010 data3: 00010011 Then I have a mask to apply to get the bits from data when mask value is 1 MASK: 00101011 And so get the following expected results: data1: 1010 data2: 1010 data3: 0011 Is there a way to optimize the filtering, without looping on each bit of "mask" to get the corresponding value in "data" row...

How do you explain that line 7 gets a warning, but not line 5 or line 6? int main() { unsigned char a = 0xFF; unsigned char b = 0xFF; a = a | b; // 5: (no warning) a = (unsigned char)(b & 0xF); // 6: (no warning) a = a | (unsigned char)(b & 0xF); // 7: (warning) return 0; } GCC 4.6.2 output when compiled on 32-bit architecture (Windows PC): gcc -c main.c --std=c89 -Wall -Wextra -Wconversion -pedantic main.c: In function 'main': main.c:7:11: warning: conversion to 'unsigned char' from 'int' may alter its value [-Wconversion] If this helps you understand my question, here is how I see this

I'm trying to write a function to return the number of bits a positive integer less that the Javascript limit of (2^53)-1 is. However im being hit by precision problems, and want to avoid big integer libraries. Method 1: function bitSize(num) { return Math.floor( Math.log(num) / Math.log(2) ) + 1; } Pass: bitSize( Math.pow(2, 16) -1 ) = 16 Pass: bitSize( Math.pow(2, 16) ) = 17 Fail (Should be 48): bitSize( Math.pow(2, 48) -1 ) = 49 Pass: bitSize( Math.pow(2, 48) ) = 49 Method 2: function bitSize(num) { var count = 0; while(num > 0) { num = num >> 1; count++; } return count; } Pass: bitSize(

I'm working on some C++ code for an embedded system. The I/O interface the code uses requires that the size of each message (in bytes) is a power of two. Right now, the code does something like this (in several places): #pragma pack(1) struct Message { struct internal_ { unsigned long member1; unsigned long member2; unsigned long member3; /* more members */ } internal; char pad[64-sizeof(internal_)]; }; #pragma pack() I'm trying to compile the code on a 64-bit Fedora for the first time, where long is 64-bits. In this case, sizeof(internal_) is greater than 64, the array size expression

I found some interesting bit twiddling in "source\common\unicode\utf.h" file of ICU library (International Components for Unicode). The bit twiddling is intended for checking whether a number is in a particular range. // Is a code point in a range of U+d800..U+dbff? #define U_IS_LEAD(c) (((c)&0xfffffc00)==0xd800) I have figured out the magic number (0xfffffc00) come from: MagicNumber = 0xffffffff - (HighBound - LowBound) However, I also found that the formula doesn't apply to every arbitrary range. Does somebody here know in what circumstance the formula works? Is there another bit twiddling

I need to mask certain string values read from a database by setting a specific bit in an int value for each possible database value. For example, if the database returns the string "value1" then the bit in position 0 will need to be set to 1, but if the database returns "value2" then the bit in position 1 will need to be set to 1 instead. How can I ensure each bit of an int is set to 0 originally and then turn on just the specified bit? If you have an int value " intValue " and you want to set a specific bit at position " bitPosition ", do something like: intValue = intValue | (1 <<