bit-manipulation

Assuming I have a register reg [15:0] my_reg , which contains a 16-bit signed sample: How can I find the place where the first bit change is located? Meaning, that if assuming that my_reg = 16'b0001011011010111 , how can I know that the first change from 0 to 1 is at my_reg [12] ? Same for numbers starting with 1 ,negative numbers, e.g. my_reg = 16'b1111011011010111 would be interested in the position of the first appearing 0 (which is 11 in this case). The ultimate goal (to add a little bit of context) is to implement a digital FPGA built-in automatic gain control (AGC). Guy Same technique as

I want to count the bits that are set in an extremely large bit-vector (i.e. 100,000 bits). What I am currently doing is using a pointer to char (i.e. char *cPtr) to point to the beginning of the array of bits. I then: 1. look at each element of the array (i.e. cPtr[x]), 2. convert it to an integer (i.e. (int) cPtr[x]) 3. use a 256 element look-up table to see how many bits are set in the given byte (i.e. cPtr[x]). It occurs to me that if I use a short int pointer instead (i.e. short int * sPtr), then I will only need half as many look-ups, but with a 65534 element look-up table, which will

To answer How to store binary data when you only care about speed? , I am trying to write some to do comparisons, so I want to use std::bitset . However, for fair comparison, I would like a 1D std::bitset to emulate a 2D. So instead of having: bitset<3> b1(string("010")); bitset<3> b2(string("111")); I would like to use: bitset<2 * 3> b1(string("010111")); to optimize data locality. However, now I am having problem with How should I store and compute Hamming distance between binary codes? , as seen in my minimal example: #include <vector> #include <iostream> #include <random> #include <cmath>

I have an integer input that is power of 2 (1, 2, 4, 8 etc). I want the function to return bit position without using log(). For example, for inputs above will return {0, 1, 2, 3} respectively This for C#. Plus if this can be done in SQL. Thanks! The fastest code I found to do this is from the Bit Twiddling Hacks site. Specifically, the lookup based on the DeBruijn sequence. See http://graphics.stanford.edu/~seander/bithacks.html#IntegerLogDeBruijn I tested a naive method, a switch-based method, and two of the Bit Twiddling Hacks methods: the DeBruijn sequence, and the other that says, "if you

we can do the following to convert: var a = "129.13"|0, // becomes 129 var b = 11.12|0; // becomes 11 var c = "112"|0; // becomes 112 This seem to work but not sure if this is a standard JS feature. Does any one have any idea if this is safe to use for converting strings and decimals to integers ? Yes, it is standard behavior. Bitwise operators only operate on integers, so they convert whatever number they're give to signed 32 bit integer. This means that the max range is that of signed 32 bit integer minus 1, which is 2147483647 . (Math.pow(2, 32) / 2 - 1)|0; // 2147483647 (Math.pow(2, 32) /

what does this mean? #define WS_RECURSIVE (1 << 0) I understand that it will define WS_Recursive (1 << 0) but what does << mean? Thanks! << is the left shift operator . It is shifting the number 1 to the left 0 bits, which is equivalent to the number 1 . It is commonly used to create flags , numbers that can be combined together with | (bit or) and various operations can be applied to them, such as testing whether a flag is set, setting a flag, removing a flag, etc. The reason that they can be combined together without interfering with each other is that each one is a power of two , and that