Now Reading
Demystifying bitwise operations, a mild C tutorial

Demystifying bitwise operations, a mild C tutorial

2023-03-03 09:01:15

This tutorial is in early draft. When you see any errors, suggestions is vastly appreciated.

Bitwise operations are a elementary a part of Pc Science. They assist Software program Engineers to have a deeper understanding of how computer systems symbolize and manipulate information, and they’re essential when writing performance-critical code. Reality being mentioned, these days, they’re not often used within the enterprise code we write, and so they keep hidden in libraries, frameworks, or low-level system programming codebases. The reason being easy: writing code that operates on bits could be tedious, much less readable, not at all times moveable, and, most significantly, error-prone. Trendy programming languages these days have higher-level abstractions that substitute the necessity for bitwise operations and “constructs”, and buying and selling (potential) small efficiency and reminiscence positive factors for readability shouldn’t be such a nasty deal. Plus, compilers are extra clever these days and might optimise your code in methods you (and I) can’t even think about.

To raised perceive my arguments, not so way back, I’ve written a snake in C that makes use of solely bitwise operations and squeezes every little thing into solely a handful of uint32_t and uint64_t variables. The results (after macro expansions) will not be that readable, even for an initiated eye.

In any case, this text shouldn’t be about why we shouldn’t ever contact them; quite the opposite, it’s about why they’re cool and the way they will make particular code snippets orders of magnitude quicker than the “higher-level-readable-modern strategy”. In case you are a programmer who enjoys competitive programming, realizing bitwise operations (in case you don’t find out about them already) will assist you write extra environment friendly code.

Once more, realizing how one can cope with bitwise operations is critical in the event you plan a profession in systems programming, community programming or embedded software development.


Nature gifted humankind ten fingers. As a direct consequence of Nature’s choice, our Math (and numbers) are nearly at all times expressed in base 10. If an alien specie (with eight fingers) discovers arithmetic, they’ll most likely use base 8 (octal) to symbolize their numbers. In the meantime, computer systems love base 2 (binary) as a result of computer systems have solely two fingers: 1 and 0, or one and none.


In arithmetic, a base refers back to the variety of distinct symbols we use to symbolize and retailer numbers.

In our case (decimal), these symbols are 0, 1, 2, 3, 4, 5, 6, 7, 8, and 9. We should “recombine” the prevailing symbols to specific extra important numbers. For instance, 127 is outlined by re-using 1, 2, and 7. The three symbols are mixed to specific a larger amount that can’t be described utilizing mere fingers.

By far, the most well-liked quantity system bases are:

Quantity System Base Symbols
Binary 2 [0, 1]
Octal 8 [0, 1, 2, 3, 4, 5, 6, 7 ]
Decimal 10 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Hexadecimal 16 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F]

To make issues extra generic, if (b) is the bottom, to put in writing the quantity pure quantity (a) in base (b) (notation is (a_{b})), then the components is: (a_{b}=a_{0}*b^{0}+a_{1}*b^{1}+a_{2}*b^{2}+…+a_{n}*b^{n}), the place (a_{n}), (a_{n-1}), …, (a_{2}), (a_{1}), (a_{0}) are the symbols in descending order, and (a_{i} lt b).

For instance, 1078 in base 10 ((b=10), so (a_{i} in {0,1,2,3,4,5,6,7,8,9})) could be written as:

[1078_{10} = 1 * 10^3 + 0 * 10^2 + 7 * 10^1 + 8 * 10^0]

If we had been to vary the bottom and write 1078 from base 10 to base 7, then (b=7) and (a_{i} in {0,1,2,3,4,5,6}) (we solely have seven fingers numerotated from 0 to 6):

[1078_{10} = 3 * 7^3 + 1 * 7^2 + 0 * 7^1 + 0 * 7^0 = 3100_{7}]

If we’re to vary the bottom and write 1078 from base 10 to base 2, then (b=2) and (a_{i} in {0,1}):

[1078_{10} =
1 * 2^{10} + 0 * 2^9 + 0 * 2^8 + 0 * 2^7 + 0 * 2^6 +
1 * 2^5 + 1 * 2^4 + 0 * 2^3 + 1 * 2^2 + 1 * 2^1 + 0 * 2^0
= 10000110110_{2}]

As we’ve mentioned earlier, laptop retailer numbers in binary, so higher visualise how our reminiscence seems to be like, let’s check out the next diagram:


As you may see, to establish the bits (the sequence of zeroes and ones that are the suitable symbols in binary) comprising the quantity, now we have to seek out an algorithm to find out the numbers (a_{i}). Fortunately, such an algorithm exists, and it’s easy to implement. It really works the identical, it doesn’t matter what base we decide.

Primarily based on the above image, one other vital statement is that to symbolize the quantity 1078 in binary, we’d like at the least ten reminiscence cells (bits) for it (take a look at essentially the most important energy of two used, which is 10). As a facet rule, the less symbols now we have for our base, the extra now we have to repeat current symbols. If we need to go excessive and decide b=1, we could have a Unary Numeral System, the place representing a quantity N is equal to repeating the distinctive image of the system N occasions.

The algorithm for transitioning a quantity to any base (b) is as follows:

  1. We convert the quantity to the decimal base;
  2. We divide the decimal illustration of the quantity by the bottom (b);
  3. We file the reminder to the division (this can be a digit within the base (b) illustration);
  4. We proceed dividing the quotient with base (b) and hold recording the rest;
  5. If the quotient turns into 0 in some unspecified time in the future, we cease.

The bottom (b) illustration of the decimal quantity would be the sequence of remainders (in reverse order).

For instance, let’s convert 35 to base 2:


After making use of the algorithm, (35_{10}=100011_{2}). It’s simple to check if issues are appropriate. We take every bit and multiply its corresponding energy of b=2: (35_{10}=1*2^{5}+0*2^{4}+0*2^{3}+0*2^{2}+1*2^{1}+1*2^{0}).

Changing a quantity from the decimal system to the hexadecimal quantity system is somewhat bit trickier; the algorithm stays the identical, however as a result of the hexadecimal system has 16 symbols, and we solely have ten digits (0, 1,…, 9) we have to add extra characters to our set, the letters from A to F. A corresponds to 10, B corresponds to 11, C corresponds to 12, D corresponds to 13, E corresponds to 14, and F corresponds to 15.

For instance, let’s convert 439784 to hexadecimal to see the way it seems to be:


As you may see, (439784_{10}=6B5E8_{16}). One other in style notation for hexadecimal numbers is 0x6B5E8; you will note the 0x prefix earlier than the quantity. Equally, for binary, there’s the 0b prefix earlier than the precise quantity illustration (C doesn’t help this).

As a result of numbers within the binary numerical system take a lot “area” to be represented, you’ll not often see them printed in binary, however you will note them in hexadecimal.

Personally, when I’ve to “translate” from binary to hexadecimal, and vice-versa, I don’t apply any “mathematical” algorithm. There’s a easy “visible” correspondence we will use:


As you may see, every image from the hexadecimal format could be represented as a sequence of 4 bits in binary. 8 is 1000, E is 1110, and so forth… Whenever you concatenate every little thing, you could have the binary illustration of the quantity from hexadecimal to binary. The reverse operation additionally works. With somewhat bit of expertise (no pun supposed), you are able to do the “transformation” in your head and turn out to be one of many guys from The Matrix.


When you don’t have expertise with the hexadecimal quantity programs, write the digits on a bit of paper just a few occasions till you memorise them:


Numbers, particularly when represented in binary, have a sure symmetry related to them. The obvious sample is the best way odd and even numbers need to alternate 0 and 1 as their final (least important) bit:


There’s no magic; that is the best way numbers function. If we transfer one column to the left (the bits akin to (2^1)), you will note each two ((2^1)) bits alternating: 00 alternates with 11.

If we transfer another column to the left (to the bits akin to (2^2)), you will note each 4 bits ((2^2)) alternating: 0000 alternates with 1111.

If we transfer simply one other column to the left (to the bits akin to (2^3)), you will note each eight bits ((2^3)) alternating: 00000000 alternates with 11111111.


One other fascinating manner to have a look at the numbers in binary is to “lower” their illustration in half and observe a “mirroring” impact:


If we had been to make use of our creativeness, we may even fold the “bit floor”; we might get solely a “floor” of 1 bits, because the higher chunk will refill the gaps within the decrease one:


One other fascinating sample is taking a look at a “ladder” forming up, the place every step is double the dimensions of the earlier one (take a look at the inexperienced line from the picture under):


“The ladder” adjustments its step at any time when it encounters an influence of two. Additionally, in the event you look nearer, each energy of two has just one little bit of 1 on the energy’s place within the quantity.

The C programming language supplies numeric information varieties to retailer numbers within the laptop’s reminiscence. As beforehand talked about, they’re saved in binary (as a sequence of zeroes and ones). I’m positive you’ve heard about char, int, unsigned int, lengthy, lengthy lengthy, float, and so on. If you wish to revamp your data on this space, I suppose this Wikipedia article is greater than sufficient. The most important downside with the “basic” varieties was that their dimension may differ from one machine to a different.

For instance, char is outlined in the usual as an integer kind (that may be signed or unsigned) that incorporates CHAR_BIT bits of knowledge. On most machines, CHAR_BIT is 8, however there have been machines the place for causes past the scope of this text, CHAR_BIT was 7. Engaged on the bits of a char and assuming they’re 8 (99.99% of the instances) would create portability issues on the a lot fewer programs the place CHAR_BIT is 7. (Notice: CHAR_BIT is a macro outlined in limits.h)

The identical goes for the standard int. Within the C normal, int doesn’t have a set dimension by way of the bits it incorporates, solely a decrease certain, which means it ought to be a least 16 bits lengthy; on my machine is 32, so once more, portability points are in sight.

With C99, new fixed-length information varieties had been launched to extend the portability of the software program we write. They are often discovered within the header file inttypes.h (and in stdint.h). These are the kinds I desire to make use of these days after I write C code:

  • int8_t : signed integer with 8 bits;
  • int16_t : signed integer with 16 bits;
  • int32_t : signed integer with 32 bits;
  • int64_t : signed integer with 64 bits;

For every intN_t signed integer, there may be additionally an uintN_t counterpart (unsigned integer, N=8,16,32,64). For that reason, we are going to use the fixed-size integers from stdint.h in our code.

Letting signed integers apart for a second (as we are going to talk about later how detrimental numbers are represented), if we had been to visually symbolize uint8_t, uint16_t and uint32_t (skipping uint64_t), they appear to be this:


The utmost worth an uint8_t variable can take is when all its bits are set to 1:


To find out the utmost unsigned integer we will maintain in a variable of kind uint8_t, we add all of the powers of two like this:

[m = 1 * 2^7 + 1 * 2^6 + 1 * 2^5 + 1 * 2^4 + 1 * 2^3 + 1 * 2^2 + 1 * 2^1 + 1 * 2^0 =
= 128 + 64 + 32 + 16 + 8 + 4 + 2 + 1 =
= 255]

Or, we will use this components: (sum_{i=0}^{n} 2^i =2^{n+1}-1), so for every uintN_t we will up with this desk:

Unsigned Mounted Sort Most Worth C Macro
uint8_t 28-1=255 UINT8_MAX
uint16_t 216-1=65535 UINT16_MAX
uint32_t 232-1=4294967295 UINT32_MAX
uint64_t 264-1=18446744073709551615 UINT64_MAX

Sure, you’ve learn effectively; there are additionally macros for all the utmost values. When you find yourself programming, you don’t need to compute something; it is going to be a waste of CPU time to redo the mathematics yet again. So every little thing is saved as macro constants (if such a factor exists):

#embrace <stdio.h>
#embrace <stdint.h> // macros are included right here

int primary(void) {
    printf("%hhun", UINT8_MAX);
    printf("%hun", UINT16_MAX);
    printf("%un", UINT32_MAX);
    printf("%llun", UINT64_MAX);
    return 0;



For this train, we are going to write a C perform that takes an uint16_t and prints its illustration in different numerical programs to stdout.

For every little thing larger than base 10, we are going to use the letters from the alphabet. If the bottom is greater than 36 (10 digits + 26 letters), we are going to print an error to the stderr. We are going to begin by defining an “alphabet” of symbols that map each quantity from 0..35 to the digits and letters that now we have accessible:

#outline MAX_BASE 36
char symbols[MAX_BASE] = {
    '0', '1', '2', '3', '4', '5', '6', '7', '8',
    '9', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
    'I', 'J', 'Okay', 'L', 'M', 'N', 'O', 'P', 'Q',
    'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'
// For 0, symbols[0] = '0'
// ...
// For 11, image[11] = 'B'
// ...
// For 35, image[35] = 'Z'

The subsequent step is to put in writing a perform that implements the essential algorithm described within the first part of the article.

#outline MAX_BASE 36
char symbols[MAX_BASE] = { /** numbers and letters right here */ };
void print_base_iter1(uint16_t n, uint8_t base) {
    // Sanity examine
    if (base >= MAX_BASE){
        fprintf(stderr, "Base %d is greater than the potential accepted base", base);
    uint16_t r;
    whereas (n>0) { // Whereas quotient is greater than 0
        r = n % base; // Compute the rest
        n /= base; // Divide with base once more
        fprintf(stdout, "%c", symbols[r]); // Print the image
                                           // Related to the rest

All the pieces seems to be good, but when we run the perform, we are going to see a slight inconvenience; the symbols are printed within the reverse order we would like them to be. For instance, calling: print_base_iter1(1078, 2); will yield the consequence: 01101100001, which is technically appropriate, however provided that we learn the quantity from proper to left or use a mirror. Jokes apart, the proper reply is 10000110110.

Now let’s attempt to convert a quantity from decimal to hexadecimal to see some letters by printing print_base_iter1(44008, 16);, the consequence given by our perform is 8EBA, once more if we learn it from proper to left, it’s “the wonderful” consequence.

To repair this inconvenience, we will write the leads to an middleman, char* (string), to manage the order through which we present the characters. Or we will use a Stack information construction, the place we push the remainders individually after which print them whereas we pop them out.

One other easier resolution is to make use of recursion + the one stack actual programmers use (that was a joke!):

#outline MAX_BASE 36
char symbols[MAX_BASE] = { /** */ };
static void print_base_rec0(uint16_t n, uint8_t base, uint16_t rem) {
    if (n>0) {
        uint16_t r=n%base;
        print_base_rec0(n/base, base, r); // calls the strategy once more
                                          // printing the character from the subsequent line
                                          // does not occur till the earlier name to 
                                          // the strategy is completed
        fprintf(stdout, "%c",symbols[r]);
void print_base_rec(uint16_t n, uint8_t base) {
    if (base>=MAX_BASE) {
        fprintf(stderr, "Base %d is greater than the potential accepted base", base);
    print_base_rec0(n, base, 0);

To simplify issues, C helps hexadecimal literals (however not binary!), so we will assign numbers in hexadecimal to variables. In C, a hexadecimal literal is written with the prefix 0x (or 0X) adopted by a number of hexadecimal symbols (digits). Each uppercase and lowercase work.

For instance, we will write:

uint32_t x = 0x3Fu;    // 0x3F is 63  
                       // one other manner of writing: 
                       //            uint32_t x = 63

uint32_t y = 0xABCDu;  // 0xABCD is 43981
                       // one other manner of writing: 
                       //            uint32_t x = 43981

We will additionally print the hexadecimal illustration of a quantity utilizing "%X" (uppercase letters) or "%x" (lowercase letters) because the format specifier:

int primary(void) {
    printf("%xn", 63);
    printf("%Xn", 43981);
    return 0;

// Output;
// 3f

Hexadecimal literals enable us to insert easter eggs in our code base. For instance, this straightforward line can act as a warning for builders nearly to hitch your venture:

printf("%x %x %x %xn", 64206, 10, 2989, 49374);

// Output:
// face a nasty c0de  

Sadly, in C, there’s no binary literal…

Bitwise operations are mathematical operations that manipulate the person bits of a quantity (or set of numbers). Because the title suggests, they work on bits.

The operations are:

Image Operation
& bitwise AND
| bitwise OR
^ bitwise XOR
~ bitiwse NOT

Moreover, you could have two extra operations to shift bits (proper or left) inside a quantity.

Symbols Operation
<< left SHIFT
>> proper SHIFT

If we apply one of many binary operators on two numbers, A and B, we acquire a 3rd quantity , C, the place C = A OP B.


If (a_{7}, a_{6}, …, a_{0}) are the bits composing A, (b_{7}, b_{6}, …, b_{0}) are the bits composing B, and (c_{7}, c_{6}, …, c_{0}) are bits composing C, then we will say that:

  • (c_{7} = a_{7} textual content{ OP } b_{7});
  • (c_{6} = a_{6} textual content{ OP } b_{6});
  • … and so forth

Bitwise AND

Within the C programming language, the bitwise AND operator, denoted as & (to not be confused with &&), is a binary operator that operates on two integer operands and returns an integer operand. The operation is carried out for every pair of corresponding bits of the operands. The result’s a brand new integer through which every bit place is about to 1 provided that the corresponding bits of each operands are additionally 1. In any other case, the consequence bit is about to 0.


Let’s give it a attempt in code:

uint8_t a = 0x0Au, b = 0x0Bu;
printf("%x", a&b);

// Output
// a

Rationalization: 0x0Ais 0b00001010, whereas 0x0B is 0b00001011, and if we had been to place bits facet by facet and apply & between them, we might get the next:


As you may see, solely the 1 bits are chosen, so the result’s 0x0A.

Making an attempt to use bitwise operations to double or float varieties received’t work:

double a = 0.0;
printf("%x", a&1);


bits.c:120:19: error: invalid operands to binary & (have 'double' and 'double')
  120 |     printf("%x", a&1.0);
      |                   ^

One factor to consider is the truth that & is each associative and commutative.

The associative property implies that the grouping of operands doesn’t have an effect on the consequence. So, if now we have three or extra operands, we will group them in any manner we select, however the consequence will stay the identical:

// Associativity "smoke take a look at"
uint8_t a=0x0Au, b=0x30u, c=0x4Fu;
printf("%sn", (((a&b)&c) == (a&(b&c))) ? "True" : "False");

// Output:
// True

Visually it’s fairly an intuitive property, so let’s put a=0x0A, b=0x30, and c=0x4f facet by facet and see what issues appear to be:


Irrespective of how we group the operands, the outcomes will at all times be the identical: 0x00 as a result of there’s no column containing solely 1 bits. A single 0 in a column invalidates every little thing. Isn’t this demotivational?

The commutative property implies that the order of operands doesn’t have an effect on the consequence. So, for instance, writing a&b renders the identical consequence as writing b&a.

// Commutativity "smoke take a look at"
uint8_t a=0x0Au, b=0x30u;
printf("%sn", ((a&b)==(b&a)) ? "True" : "False");

// Output: 
// True

Bitwise OR

The bitwise OR (with its image: |) is a binary operator that compares the corresponding bits of two integer operands a produces a brand new worth through which every bit is about to 1 if both (or each) of the corresponding bits within the operand are one.


Once more, let’s attempt utilizing | in our code:

uint8_t a = 0xAAu, b=0x03u;
printf("%x", a|b);

// Output
// AB

Rationalization 0xAA is 0b10101010, whereas 0x03 is 0b00000011. When you put the 2 numbers facet by facet and apply | to their bits, we get the consequence 0xAB. Visually, issues appear to be this:


If we take a look at the columns, and there’s at the least one little bit of 1, the consequence on that column can be 1, whatever the potential 0 (zeroes).

Identical to &, | is each associative and commutative. Demonstrating that is exterior the scope of this text, however put it like this, if there’s a single 1 on the column, irrespective of what number of 0 bits we might encounter, the consequence will at all times be 1. A single 1 has the facility to change every little thing. Isn’t this motivational?

Bitwise XOR

The bitwise XOR operator (^) is a binary operator that compares the corresponding bits of two operands and returns a brand new worth the place every bit is about to 1 if the corresponding bits of the operand are totally different, and 0 if they’re the identical.


Two an identical numbers, a and b, will at all times XOR to 0 as a result of all of the matching bits will nullify themselves.

So, if a==b then a^b==0:

uint8_t a = 0xAFu, b=0xAFu;
printf("a==b is %sn", (a==b) ? "True" : "False");
printf("a^b=0xpercentxn", a^b);

// Output
// a==b is True
// a^b=0x0

As a result of we like patterns, we will additionally use 0xAA ^ 0x55 == 0xFF, visually it’s extra satisfying than another instance I may consider:


Like & and | earlier than, ^ is an associative and commutative operation. So, one other ineffective however fascinating statement we will make is that XORing all of the numbers in a loop as much as an influence of two (>=2) is at all times 0. Philosophically talking, XOR is the killer of symmetry:

void xoring_power_two() {
    // An array containing just a few powers of two
    uint8_t pof2[4] = {4, 8, 16, 32};
    // For every energy of two
    for(int i = 0; i < 4; i++) {
        uint8_t xored = 0;
        // XOR all numbers < the present energy of two
        for(int j = 0; j < pof2[i]; j++) {
            printf(" 0xpercentx %c", j, (j!=(pof2[i]-1)) ? '^' : 0);
        // Print the ultimate consequence `= xored`
        printf("= 0xpercentxn", xored);

// Output
// 0x0 ^ 0x1 ^ 0x2 ^ 0x3 = 0x0
// 0x0 ^ 0x1 ^ 0x2 ^ 0x3 ^ 0x4 ^ 0x5 ^ 0x6 ^ 0x7 = 0x0
// 0x0 ^ 0x1 ^ 0x2 ^ 0x3 ^ 0x4 ^ 0x5 ^ 0x6 ^ 0x7 ^ 0x8 ^ 0x9 ^ 0xa ^ 0xb ^ 0xc ^ 0xd ^ 0xe ^ 0xf = 0x0
// 0x0 ^ 0x1 ^ 0x2 ^ 0x3 ^ 0x4 ^ 0x5 ^ 0x6 ^ 0x7 ^ 0x8 ^ 0x9 ^ 0xa ^ 0xb ^ 0xc ^ 0xd ^ 0xe ^ 0xf ^ 0x10 ^ 0x11 ^ 0x12 ^ 0x13 ^ 0x14 ^ 0x15 ^ 0x16 ^ 0x17 ^ 0x18 ^ 0x19 ^ 0x1a ^ 0x1b ^ 0x1c ^ 0x1d ^ 0x1e ^ 0x1f = 0x0

If we image this in our heads, this consequence isn’t a surprise:


Each bit has a pair; all pairs are 0, XORing 0 with 0 is 0, and every little thing reduces to nothing.

Bitwise NOT

Within the C Programming language, the bitwise NOT it’s a unary operator denoted by the ~ character. It really works on a single operand, negating all of the operand bits by altering 1 to 0 and 0 to 1.


Negating 0b0001 is 0b1110, negating 0b0000 is 0b1111 and so forth…

For instance:

uint16_t a = 0xAAAAu; // a = 1010 1010 1010 1010 == 0xAAAA
uint16_t b = ~a;     // b = 0101 0101 0101 0101 == 0x5555
printf("0xpercentXn", a);
printf("0xpercentXn", b);

// Output
// 0xAAAA
// 0x5555

And visually issues appear to be this:


Left Shift

The left shift operation is a bitwise operation, denoted with the symbols <<, that shifts the bits of a binary quantity to the left by a specified quantity of positions.

So, for instance, if we need to shift the bits of 0b0000010 (or 0x02) with three positions, we will write one thing like this:

uint8_t a = 0x02u;   // 0b 0000 0010 = 0x02
uint8_t b = a << 3; // 0b 0001 0000 = 0x10 
printf("After shift: 0xpercentxn", b);

// Output
// After shift: 0x10

Visually issues appear to be this:


When shifting bits to the left, the bits that “fall off” the left finish are misplaced, and the ensuing bits on the proper are crammed with zeros.

Proper Shift

The appropriate shift operation is a bitwise operation, denoted with the symbols >>, that shifts the bits of a binary quantity to the proper by a given quantity of positions.

So for instance, if we need to shift 0xAA with 4 positions, by performing 0xAA>>4 we are going to acquire 0x0A:

uint8_t a = 0xAAu;   // 1010 1010 = 0xAA
uint8_t b = a >> 4; // 0000 1010 - 0x0A
printf("After shift: 0xpercentXn", b);

// Output
// After shift: 0xA

Visually issues appear to be this:



Studying by means of this level, you might really feel an elephant lurking within the server room. We haven’t touched on an important topic: How are signed integers represented in binary?

Within the C programming language, fixed-size signed integers are represented utilizing Two’s Complement. Probably the most important little bit of the quantity (additionally known as MSB) is used to the signal, and the remainder of the bits are used to retailer the quantity’s worth. The signal bit is 0 for optimistic numbers and 1 for detrimental numbers. By conference, the quantity 0 is taken into account a optimistic quantity.

In Two’s Complement, the detrimental quantity is obtained by flipping all of the bits of the optimistic worth (~) of the quantity after which including 1.

For instance, to acquire the binary illustration of -47, we should always do the next:

  1. Remodel 47 in binary: 00101111;
  2. We flip the bits of 47: 11010000;
  3. We add 1 to the results of the earlier step: 11010001.

So, -47 in binary is 11010001.

One other instance. To acquire the binary illustration of -36, we should always do the next:

  1. We rework 36 in binary: 00100100;
  2. We flip the bits of 36: 11011011;
  3. We add 1 to the consequence from the earlier step: 11011100.

There’s one bit much less to symbolize the precise numerical worth for signed integers as a result of the signal bit is reserved. The utmost optimistic worth a int8_t can maintain is: (2^7-1=127) and has the next illustration:


The minimal worth a signed integer of kind int8_t can maintain is (-2^7=128). At this level, you might surprise why is that for detrimental now we have -128 vs 127 for positives. This occurs as a result of 0 is taken into account to be optimistic by conference. -128 has the next illustration:


You don’t need to do any computations to find out the utmost and minimal values a signed fixed-length kind can get. The boundaries are already outlined as macro constants in "stdint.h":

#embrace <stdio.h>
#embrace <stdint.h> // fixed macros are included right here

int primary(void) {
    printf("int8_t is in interval: [%hhd, %hhd]n", INT8_MIN, INT8_MAX);
    printf("int16_t is in interval: [%hd, %hd]n", INT16_MIN, INT16_MAX);
    printf("int32_t is in interval: [%d, %d]n", INT32_MIN, INT32_MAX);
    printf("int64_t is in interval: [%lld, %lld]n", INT64_MIN, INT64_MAX);
    return 0;
// Output
// int8_t is within the interval: [-128, 127]
// int16_t is within the interval: [-32768, 32767]
// int32_t is within the interval: [-2147483648, 2147483647]
// int64_t is within the interval: [-9223372036854775808, 9223372036854775807]


Within the C programming language, UB (a cute acronym for Undefined Habits) refers to conditions (often nook instances, however not at all times) when the C Normal doesn’t cowl the anticipated consequence after executing a bit of code. In these instances, compilers can select to do issues their manner by crashing, giving faulty or platform-dependent outcomes (worse than crashing), or trolling us with Heisenbugs. Most instances of UB are ubiquitous, whereas others are extra refined and arduous to detect.

Within the C neighborhood, undefined behaviour could also be humorously known as “nasal demons” after a comp.std.c submit that defined undefined behaviour as permitting the compiler to do something it chooses, even “to make demons fly out of your nostril”.

Identical to managing the reminiscence your self, there are some things that you need to consider when writing C code that makes use of bitwise operations:

A. Don’t shift bits with extra (or equal) than the width of the kind:

uint8_t a = 32;
uint8_t b = a << 32; // undefined conduct
                     // code compiles simply positive
                     // do not assume the quantity is 0x0

When you attempt to compile this straightforward piece of code with -Wall, the compiler (each clang and gcc) will you warn concerning the potential issues, however the code will nonetheless compile:

bits.c:150:19: warning: left shift depend >= width of kind [-Wshift-count-overflow]
  150 |     uint8_t b = a << 32; // undefined conduct

If I execute the code after compiling it, b is 0. However don’t assume it is going to be 0 on all platforms or with all compilers. That’s incorrect.

Additionally, don’t depend on compiler warnings. They’ll solely be raised specifically instances. Check out this code that may result in UB:

uint8_t a = 32;
int shifter = rand();
uint8_t b = a << shifter;
printf("%hhun", b);

The code compiles with none warning and executes positive. The compiler couldn’t decide the worth of the shifter at compile time, so no warning was raised. So at any time when you’re performing bitwise operations (particularly shifts), you’d higher know what you’re doing.

B. Don’t shift bits utilizing detrimental quantities:

uint8_t a = 0x1u;
uint8_t b = a << -2; // undefined conduct
                     // code compiles simply positive

C.Don’t shift signed integers to trigger signal adjustments:

int8_t a = -1;
int8_t b = a << 1; // undefined conduct
                   // code compiles simply positive 

Now that we perceive the fundamentals of bitwise operations let’s resolve a classical Pc Science train known as: The solitary integer. In case you are curious, you may most likely discover it on leetcode and hackerrank (below the title The Lonely Integer).

The ask is easy:

Given an array of integer values, the place all parts **however one** happen twice, 
discover the distinctive factor, the so-called _solitary_ integer. 

For instance, if `L={1,2,3,3,8,1,9,2,9}`, the distinctive factor is `8`, 
as a result of the remainder of the weather are available pairs.

The primary reflex to unravel this train can be to brute drive the answer by verifying every factor with each different to seek out its pair. However the complexity of doing so is O(n2), the place n is the dimensions of the enter array – not wonderful. However, as a rule of thumb, in the event you obtain a query like this at an interview and don’t know how one can strategy it, mentioning the brute-force resolution is an effective start line and should purchase you a while till you provide you with one thing higher.

There are, after all, different different options:

  • Sorting the array in O(nlogn) after which iterate by means of it by i+=2. If L[i]!=L[i+1], you’ve simply discovered the lonely integer.
  • Utilizing a hashtable and depend the frequency of the numbers. If the frequency of a secret’s 1, the issue is solved; you’ve simply discovered the lonely integer.

However all these options are barely overkill if you already know about XOR. As we’ve mentioned earlier, XOR nullifies an identical bits. We additionally know that XOR is associative and commutative. So, why don’t we apply XOR between all of the numbers? Ultimately, solely the bits with out pairs will “survive”. These surviving bits maintain the reply to our downside.


  • The bits of array[0] will (finally) nullify themselves with the bits from array[5] => array[0] ^ array[1] == 0;
  • The bits of array[1] will (finally) nullify themselves with the bits from array[7] => array[1] ^ array[7] == 0;
  • The bits of array[2] will (finally) nullify themselves with the bits from array[3] => array[2] ^ array[3] == 0;
  • The bits of array[6] will (finally) nullify themselves with the bits from array[8] -> array[6] ^ array[8] == 0;
  • The bits of array[4] will stay unaltered; they symbolize the answer;

So, the answer of train turns into:

static int with_xor(int *array, size_t array_size) {
      int consequence = 0;
      for(int i = 0; i < array_size; ++i)
      return consequence;
int primary(void) {
    int array[9] = {1,2,3,3,8,1,9,2,9};
    printf("%dn", with_xor(array, 9));
    return 0;

// Output
// 8

In a earlier part of the article, we devised an answer to remodel numbers from one numeric system to a different. Likelihood is we are going to by no means need to convert to base 11. So why write a perform that transforms a quantity within the binary format utilizing bitwise operations?

The best resolution I may consider is the next:

void print_bits_simple_rec(FILE *out, uint16_t n) {
    if (n>>1)
        print_bits_simple_rec(out, n>>1);       
    fprintf(out, "%d", n&0x1u);                  

print_bits_simple_rec is a recursive perform that takes an uint16_t and it prints its bits. At every recursive name, we shrink the quantity by shifting one bit to the proper (n>>1). We cease the recursive calls as soon as the quantity reaches 0. After the recursive stack is constructed, we print the final little bit of the quantity for every name (n&0x1).

It’s not the scope of this text to clarify recursion, however let’s see how issues execute if we name the perform on n=0b00011011:


After which, as soon as n=0b00000001, we begin printing characters backwards:


That’s one concept. One other concept is to make use of a worth desk the place we hold the binary strings related to all of the binary numbers from 0 to 15:

const char* bit_rep[16] = {
    "0000", "0001", "0010", "0011",
    "0100", "0101", "0110", "0111",
    "1000", "1001", "1010", "1011",
    "1100", "1101", "1110", "1111",

We will then write just a few capabilities that re-use bit_rep. For instance, if we plan to print an uint8_t, all we have to do is to put in writing this perform:

void print_bits_uint8_t(FILE *out, uint8_t n) {
    fprintf(out, "%spercents", bit_rep[n >> 4], bit_rep[n & 0xF]);
int primary(void) {
    uint8_t n = 145;
    print_bits_uint8_t(stdout, n);

// Output
// 10010001

This new perform works like this:

  • uint8_t n has 8 bits in whole.
  • If we break up n into two halves of 4 bits every, we will use bit_rep[half1] and bit_rep[half2] to print the content material of n;
  • To separate n into two halves, now we have to:
    • n>>4 to get the primary 4 bits;
    • n & 0xF to get the final 4 bits;

In case you are confused about n>>4 and n & 0xF, let’s visualise what’s occurring and the way bits transfer. We are going to use n=145 to exemplify.


If we take into account the next:

  • One uint16_t variable can comprise two uint8_t variables;
  • One uint32_t variable can comprise two uint16_t variables;
  • One uint64_t variable can comprise two uint32_t variables;

We will then write the next code, the place every perform re-uses the perform of the lesser kind. The thought is similar: we break up the larger kind into two halves and cross it to the perform related to the lesser kind.

void print_bits_uint8_t(FILE *out, uint8_t n) {
    fprintf(out, "%spercents", bit_rep[n >> 4], bit_rep[n & 0xFu]);
void print_bits_uint16_t(FILE *out, uint16_t n) {
    print_bits_uint8_t(out, n >> 8); // first 8 bits
    print_bits_uint8_t(out, n & 0xFFu); // final 8 bits
void print_bits_uint32_t(FILE *out, uint32_t n) {
    print_bits_uint16_t(out, n >> 16); // first 16 bits
    print_bits_uint16_t(out, n & 0xFFFFu); // final 16 bits
void print_bits_uint64_t(FILE *out, uint64_t n) {
    print_bits_uint32_t(out, n >> 32); // first 32 bits
    print_bits_uint32_t(out, n & 0xFFFFFFFFu); // final 32 bits

Having separate capabilities for every kind shouldn’t be very best, however prevalent within the C programming language. Fortuitously, we will use the _Generic macro to group capabilities up.

#outline print_bits(the place, n) _Generic((n), 
                uint8_t: print_bits_uint8_t, 
                int8_t: print_bits_uint8_t, 
                uint16_t: print_bits_uint16_t, 
                int16_t: print_bits_uint16_t, 
                uint32_t: print_bits_uint32_t, 
                int32_t: print_bits_uint32_t, 
                uint64_t: print_bits_uint64_t, 
                int64_t: print_bits_uint64_t) 
            (the place, n)

So now, we will merely name print_bits() concerning the enter kind (! so long as the kind is roofed by a _Generic macro department):

uint8_t a = 145;
uint16_t b = 1089;
uint32_t c = 30432;
int32_t d = 3232;
print_bits(stdout, a); printf("n"); // works on uint8_t !
print_bits(stdout, b); printf("n"); // works on uint16_t !
print_bits(stdout, c); printf("n"); // works on uint32_t !
print_bits(stdout, d); printf("n"); // works on int32_t !

// Output
// 10010001
// 0000010001000001
// 00000000000000000111011011100000
// 00000000000000000000110010100000


In low-level programming, bitwise masking includes the manipulation of particular person bits of a quantity (represented in binary) utilizing the operations we’ve described within the earlier sections (&, |, ~, ^, >>, <<). A masks is a binary sample that extracts and manipulates particular bits of a given worth.

Utilizing bitmasking strategies, we will:

  • Set a selected bit to a price (0 or 1);
  • Clear a selected bit, or a bit portion from a quantity;
  • Flip the values of all of the bits of a quantity.
  • and so on.

Let’s check out the beforehand outlined perform, print_bits_uint8_t, that prints the binary illustration of a uint8_t:

void print_bits_uint8_t(FILE *out, uint8_t n) {
    fprintf(out, "%spercents", bit_rep[n >> 4], bit_rep[n & 0xFu]);

0xF is the masks we use to choose the final 4 bits of n. This occurs once we apply n&0xF: all of the bits of 1 from the masks are used to extract data from n, and all of the bits of 0 from the masks discard data from n:


After we create the masks, we will write the sample by hand, utilizing hexadecimal literals, or we will categorical them utilizing powers of 2. For instance, if you need a easy masks for one bit on the nth place, we will write: 1<<nth. 2^nth == 1<<nth:


We will additionally “flip” the masks utilizing the ~(masks) operation:


To get a “contiguous” zone of 1s, we will subtract 1 from the corresponding energy of twos:


Within the well-known e-book known as Cracking The Coding Interview there’s one train the place the reader is requested to swap the even bits with the odd bits inside a quantity:


When you ignore the ask to use as few directions as potential our programmer’s reflex can be to:

  • Preserve all of the bits of the quantity in an array;
  • Carry out swaps contained in the array;
  • Recreate the numbers primarily based on the brand new array configuration.

In fact, an easier resolution makes use of bitwise operations and the masking method. Spoiler alert, we are going to begin with the precise resolution, adopted by some in-depth explanations:

uint16_t pairwise_swap(uint16_t n)  ((n&0x5555u)<<1);

Cryptic, however easy:

uint16_t n = 0xBCDD;
uint16_t n_ps = pairwise_swap(n);
print_bits(stdout, n); printf("n");
print_bits(stdout, n_ps); printf("n");

// Output
// 1011110011011101
// 0111110011101110

The important thing to understanding the answer lies within the patterns described by the binary numbers 0xAAAA and 0x5555. 0xAAAA selects all of the even bits of n, whereas 0x5555 selects all of the odd bits of n. If we put the numbers facet by facet, we should always see that:


At this level, the data initially contained within the enter quantity (n=0xBCDD) is contained within the two numbers:

  • 0xBCDD & 0x5555 will comprise the odd bits of 0xBCDD;
  • 0xBCDD & 0xAAAA will comprise the even bits of 0xBCDD;

Now we have to swap them. We are going to shift the even bits one place to the left, and the odd bits one place to the proper, so we don’t lose any. To recombine the 2 interlacing patterns again, we use the | operation.


Getting the nth little bit of a quantity

To get the nth little bit of a quantity n, we will use the & and >> bitwise operations:

  • We shift the quantity >> with nth positions;
  • We apply a easy masks to &0x1 for acquiring the final bit;

Most on-line sources (ChatGPT included) will suggest you the next two options for retrieving the nth bit:

A macro:

#outline GET_BIT(n,pos) (((n)>>(pos))&1)

Or a way:

int get_bit(int num, int n) {
    return (num >> n) & 0x1u;

Visually, each options work like this:


I desire utilizing a way as a substitute of a macro, relying on the context. It’s finest to validate the enter and guarantee n shouldn’t be detrimental or larger than the dimensions (in bits) of num. In any other case, issues can result in UB quick:

inline uint8_t get_nth_bit(uint32_t num, uint32_t nth) {
    if (nth>=32) {
        // Catch error
        // Log & Handle the error
    return (num>>nth)&0x1u;

Let’s attempt it in observe now:

int primary(void) {
    uint32_t n = 0xFFu;
    int i = 0;   
    printf("Printing final 8 bits:n");
    for(; i < 8; i++)
        printf("%hhu", get_nth_bit(n,i));
    printf("nPriting the primary 24 bits:n");
    for(; i < 32; i++) 
        printf("%hhu", get_nth_bit(n,i));

// Output
// Printing final 8 bits:
// 11111111
// Printing the primary 24 bits:
// 000000000000000000000000

Establishing the nth little bit of a quantity

The little bit of a quantity n could be set to 0 or 1, and relying on the context, we will find yourself having two capabilities or macros:

#outline set_nth_bit1(num, pos) ((num) |= (1 << (pos)))
#outline set_nth_bit0(num, pos) ((num) &= ~(1 << (pos)))

// Or capabilities

inline void set_nth_bit0(uint32_t *n, uint8_t nth) {
    *n &= ~(1 << nth);
inline void set_nth_bit1(uint32_t *n, uint8_t nth) = (1 << nth);

As a result of each of the capabilities (and macros) can result in UB, it’s advisable to validate nth to verify it’s not larger than the size (in bits) of the kind of n (in our case it’s uint32_t, so it ought to be smaller < than 32).

Utilizing the capabilities in code:

uint32_t n = 0x00FFu;
print_bits(stdout, n); printf("n");

set_nth_bit0(&n, 5);
printf("bit 5 of n is: %hhun", get_nth_bit(n, 5));
print_bits(stdout, n); printf("n");

set_nth_bit1(&n, 5);
printf("bit 5 of n is: %hhun", get_nth_bit(n, 5));
print_bits(stdout, n); printf("n");

// Output
// 00000000000000000000000011111111
// bit 5 of n is: 0
// 00000000000000000000000011011111
// bit 5 of n is: 1
// 00000000000000000000000011111111

Visually, set_nth_bit0 seems to be like this:


Making use of & between 0 and 1 will at all times return 0. So we create a masks for the fifth bit (1<<5), we flip it (~(1<<5)) so we get a 0 on the fifth place, after which we apply & (bitwise AND). The 1 doesn’t stand an opportunity.

Visually, set_nth_bit1 seems to be like this:


Making use of | between 0 and 1 returns 1. So we create a masks for the fifth bit (1<<5), then apply | between the masks and the quantity to repair the hole.

Toggling the nth little bit of a quantity

Toggling the little bit of the quantity means altering the worth of a selected bit from 0 to 1 or from 1 to 0 whereas leaving all the opposite bits unchanged.

The primary reflex can be to re-use the beforehand outlined capabilities set_nth_bit1(...) and set_nth_bit0(...) to improvise one thing like:

void toggle_nth_bit(uint32_t *n, uint8_t nth) {
    if (get_nth_bit(n,nth)==0) {
        set_nth_bit1(n, nth);
    } else {
        set_nth_bit0(n, nth);

However there’s a greater and easier manner that avoids branching altogether and makes use of XOR:

void toggle_nth_bit(uint32_t *n, uint8_t nth) {
    *n ^= (1<<nth);

The thought is kind of easy; we create a masks with 1 on the nth place (1<<nth), after which we ^ (XOR) the quantity n with the masks. This can protect all of the bits of n, minus the nth bit will change values relying on its state (it would toggle).

Let’s visualise this, by imagining calling: toggle_nth_bit(0xF0u, 3):


The results of toggle_nth_bit(0xF0u, 3) ought to be 0xF8:

uint32_t n = 0xF0u;
toggle_nth_bit(&n, 3);
if (n==0xF8u) {
    printf("It really works!");

// Output
// It really works!

Or we carry out the inverse operation on the identical bit:

uint32_t n = 0xF8u;
toggle_nth_bit(&n, 3);
if (n==0xF0u) {
    printf("It really works!");

// Output
// It really works!

Clearing the final bits of a quantity

So let’s say now we have a quantity n. Our job is to put in writing a generic technique that clears the final nbits of that quantity.

The answer is straightforward:

  • We have to create a masks the place all of the bits are 1, besides the final nbits, that are 0.
  • We apply an & operation between n and the newly created masks;

To create the masks, we begin from a price the place all of the bits are set to 1. This worth could be simply obtained by flipping all of the bits of 0: ~0x0u. Subsequent, we left shift with nbits and, voila, the masks is prepared.

The code is:

void clear_last_bits(uint32_t *n, uint8_t nbits) {
    *n &= (~(0x0u) << nbits);

To check it, let’s attempt to clear the final 4 bits of 0xFF. The consequence ought to be: 0xF0:

uint32_t n = 0xFFu;
clear_last_bits(&n, 4);
if (n==0xF0u) {
    printf("It really works!n");

// Output
// It really works!

Visually, the operation seems to be like this:


Changing a number of bits

On this case, the ask is straightforward; given an uint16_t and two bit indices, i and j, we have to write a way that replaces all of the bits between i and j (together with j) from N with the worth of M. In different phrases, M turns into a substring of N that begins at i and ends at j.

The signature of the strategy ought to be the next:

void replace_bits(uint32_t *n, uint32_t m, uint8_t i, uint8_t j);

A easy resolution that doesn’t impose any validation on i, j or m could be:

void replace_bits(uint16_t *n, uint16_t m, uint8_t i, uint8_t j) = m;

Executing the code:

See Also

uint16_t n = 0xDCBE;
print_bits(stdout, n); printf("n");
replace_bits(&n, 0x1u, 3, 6);
print_bits(stdout, n); printf("n");

// Output
// 1101110010111110
// 1101110010001110

As you may see, the bits from positions 3 to 6 (inclusive) had been changed with the worth of 0x1, which is 0b001 in binary.

To grasp what’s occurring behind the scenes, we should always undergo the algorithm step-by-step.

Firstly we have to construct a masks that selects the interval outlined by i and j. The masks can be created by stitching collectively the 2 sections (utilizing |). The road of code the place we create the masks is: uint16_t masks = (~0x0 << (j+1)) | ((1<<i)-1);. Visually it really works like this:


The second step is to make use of the ensuing masks to clear the bits from i to j (together with j) inside n: *n &= masks;:


The third step is to shift the bits of m with i positions to the left to align them with the empty portion created by the masks. After which use m as a brand new masks: *n |= m;:


Studying a number of bits

Studying a number of bits (as a substitute of changing them) is an analogous job to the one described above. We should write a way that works on an uint16_t and two bit indices i and j. We have to extract and return the worth of all of the bits between i and j (together with j).

A proposed C perform may appear to be this:

uint16_t get_bits(uint16_t enter, uint8_t i, uint8_t j) {
    uint16_t masks = (1 << (j - i + 1)) - 1;
    masks <<= i;
    return (enter & masks) >> i;

Or, if we get pleasure from complicated our colleagues, we will attempt one thing like this:

uint16_t get_bits2(uint16_t enter, uint8_t i, uint8_t j) {
    uint16_t masks = (1 << (j + 1)) - (1 << i);
    return (enter & masks) >> i;

After we attempt them in observe, magic unfolds:

uint16_t n = 0xDCBE;
print_bits(stdout, n); printf("n");
replace_bits(&n, 0x7u, 3, 6);
print_bits(stdout, n); printf("n");
print_bits(stdout, get_bits(n, 3, 6)); printf("n");
print_bits(stdout, get_bits2(n, 3, 6)); printf("n");

// Output
// 1101110010111110
// 1101110010111110
// 0000000000000111
// 0000000000000111

All of it boils right down to how we’ve determined to implement the masking mechanisms:

  • uint16_t masks = (1 << (j - i + 1)) - 1; masks <<= i; // OR
  • uint16_t masks = (1 << (j + 1)) - (1 << i);

As you may see, in each variations (get_bits and get_bits2), we’ve determined to create the masks in a single go with out stitching collectively two sections as we did in replace_bits.

Let’s take the primary model to exemplify additional. If we glance nearer, there’s no magic concerned.

(1 << (j - i + 1))      -1
   energy of two         -1

That’s an influence of two from which we subtract 1. We all know the bit sample related to that type of quantity ((2^n-1)):


So, visually talking, the masks types like this:


  • j-i+1 offers the size of the masks (the contiguous zone of 1 bits);
  • The second shift masks <<= i put 1 bits to the proper place.

There’s a powerful relationship between bitwise operations and mathematical operations involving powers of two. This occurring shouldn’t be any thriller or a shock; in spite of everything, we use the powers of two to symbolize the quantity within the binary system.

Multiplying a quantity with an influence of two

Multiplying a quantity (a) with an influence of two, (a * 2^{n}), is equal to writing a<<n, shifting the bits of a to the proper with n positions.

There’s a transparent mathematical demonstration for this. If we return to the start of the article and re-use the components acknowledged there, we all know a quantity within the binary system could be written as a sum of the facility of twos: (A_{2} = sum_{i=0}^{n} a_i * 2^i), the place (a_{i} in {0, 1}). If we multiply either side of the connection with (2^m), the connection turns into:

[2^{m} * A_{2} = sum_{i=0}^{n} a_i * 2^{i+m}]

We will intuitively perceive that the primary m bits of knowledge had been misplaced, now once we sum; we don’t begin with (2^0) anymore, however somewhat with (2^{m}), in order that:

[2^{m} * A_{2} = a_{0} * 2^{m} + a_{1} * 2^{m+1} + a_2*2^{m+2} + … + a_{n} * 2^{n+m}]

So, if we had been to hyperlink the mathematical components with what’s occurring on the bit stage, let’s check out the next image:


Now let’s see if the compiler is aware of how one can optimise the multiplication with out explicitly telling it so. Given the next code:

int primary(void) {
    int i = rand();
    for(; i < (1<<12); i*=4) {
        printf("%dn", 1);
    return 0;

You’ll be able to see that as a substitute of writing i<<=2 within the loop, we’ve most well-liked to make use of the extra readable i*=4. If we compile the code (gcc -O3 for x86-64) and take a look at the ensuing meeting:

        .string "%dn"
        push    rbx
        xor     edi, edi
        name    srand
        name    rand
        cmp     eax, 4095
        jg      .L2
        mov     ebx, eax
        mov     esi, 1
        mov     edi, OFFSET FLAT:.LC0
        xor     eax, eax
        ; Shifts the worth in ebx to the left by 2 bits (multiplication by 4)
        sal     ebx, 2
        name    printf
        cmp     ebx, 4095
        jle     .L3
        xor     eax, eax
        pop     rbx

You will notice the compiler is sensible sufficient to detect that one of many operands of i*=4 is an influence of two, so it makes use of the equal >> instruction, which is sal ebx, 2, the place:

  • sal is an instruction that stands for shift arithmetic left;
  • ebx is the register the place our i worth is stored;
  • 2 is the variety of positions we shift to.

Compilers can carry out this optimisation for you, so that you shouldn’t hassle.

Dividing a quantity with an influence of two

Dividing a quantity (a) with an influence of two, (a div 2^{n}), is equal to writing a>>n. The mathematical demonstration is an identical to the multiplication one so we received’t write it right here.

However we will carry out the next smoke take a look at:

uint16_t a = 100;
if (a/2 == a>>1) {
    printf("Sure, we're propern");

// Output
// Sure, we're proper

Now let’s take a look at the next code:

int primary(void) {
    uint32_t n = rand(); // generates a random quantity
    whereas(n!=0) {        // whereas the quantity is totally different than 0
        n /=2;           // we divide it with 2 
    return 0;

If we compile the code with gcc -O1 (for x86-64), the ensuing meeting code is:

        sub     rsp, 8
        mov     edi, 0
        name    srand
        ; Generate a random quantity and retailer the lead to eax
        name    rand
        ; Take a look at if the random quantity is 0 . 
        ; Whether it is bounce to .L2 in any other case proceed
        take a look at    eax, eax
        je      .L2
        ; Copy the worth of eax to edx
        mov     edx, eax
        ; Shift the worth of eax to the proper with 1 place
        shr     eax
        ; Evaluate the unique in edx to 1 and bounce again to .L3
        cmp     edx, 1
        ja      .L3
        mov     eax, 0
        add     rsp, 8

The vital line right here is shr eax, the place the compiler shifts the eax one place to the proper. Why did it do this? Our C code explicitly known as division n /=2;. Nicely, the compiler realised that the operand is 2, and there’s no motive to make use of division as a substitute of easy >>.

Enjoyable reality, if we rewrite the C code with the bitwise optimisation by changing the road n/=2 with the road n>>=1, the ensuing meeting code can be an identical. Compilers can carry out this optimisation for you, so you need to not often hassle with mundane optimisations like this.

Checking if a quantity is even or odd

Suppose we ponder the next components, the place a quantity could be written as: (A_{2} = sum_{i=0}^{n} a_i * 2^i), the place (a_{i} in {0, 1}), we are going to quickly realise that: if we sum up powers of two basically (besides (2^{0})), (A_{2}) will at all times be even. A sum of even numbers is at all times even (we will use (2) as a standard issue).

So the one indicator that provides the parity of the number is (a_{0}*2^{0}). (a_{0}) is the least important bit, however in one other manner, it’s fairly a vital fellow as a result of it supplies us with the reply to 1 essential query: is the quantity even, or is it odd?

The rule is the next:

  • If (a_{0}=1), thus activating (2^{0}), then the quantity is odd;
  • If (a_{0}=0), thus deactivating (2^{0}), then the quantity is even;

So to examine the parity of a quantity is sufficient to masks it with 0x1, and get the final bit:

uint16_t a = 15;
uint16_t b = 16;
printf("a=%d is %sn", a, a&0x1u ? "odd" : "even");
printf("a=%d is %sn", b, b&0x1u ? "odd" : "even");

// Output
// a=15 is odd
// a=16 is even

Getting the rest once we divide with an influence of two

The modulus operation % is sluggish irrespective of the {hardware} structure we’re utilizing. So at any time when we will substitute it with one thing extra environment friendly, it’s advisable, even when compilers can theoretically optimise issues like this for you.

As a rule (a % (1<<n)) is equal to (a & ((1<<n)-1)), the place 1<<n is the bitwise of claiming (2^n).

If we return to the components, (A_{2} = sum_{i=0}^{n} a_i * 2^i), the place (a_{i} in {0, 1}) and we divide into either side with an influence of two, (2^m), we are going to acquire:

[frac{A}{2^{m}} = a_{0} * frac{1}{2^m} + a_{1} * frac{1}{2^{m-1}} + a_2*frac{1}{2^{m-2}} + … + a_{n-1}*2^{n-m-1} + a_{n} * 2^{n-m}]

However in some unspecified time in the future, the denominator of the fraction (frac{1}{2^{m-j}}) will turn out to be detrimental once more in order that issues will flip the wrong way up but once more. This can occur when (j ge m). So, for instance, if m = 3, we will write issues like:

[frac{A}{2^3} = underbrace{a_{0} * frac{1}{2^3} + a_{1} * frac{1}{2^2} + a_{2} * frac{1}{2^1}}_text{the bits composing the remainder} + underbrace{a_{3} * 2^0 + a_4 * 2^1 + … + a_{n} * 2^{n-3}}_{text{The new bits composing }frac{A}{2^3}}]

So to get the rest, we have to choose the final 3 bits (with the masks ((1<<3)-1)) of the quantity:

uint16_t pow2 = 1 << 3;
for(int i = 1; i < 100; i++) {
    printf("%2nd mod %d=%d  %c", 
        i, pow2, i & (pow2-1), i&0x7 ? ' ' : 'n');

// Output
//  1 mod 8=1    2 mod 8=2    3 mod 8=3    4 mod 8=4    5 mod 8=5    6 mod 8=6    7 mod 8=7    8 mod 8=0  
//  9 mod 8=1   10 mod 8=2   11 mod 8=3   12 mod 8=4   13 mod 8=5   14 mod 8=6   15 mod 8=7   16 mod 8=0  
// 17 mod 8=1   18 mod 8=2   19 mod 8=3   20 mod 8=4   21 mod 8=5   22 mod 8=6   23 mod 8=7   24 mod 8=0  
// 25 mod 8=1   26 mod 8=2   27 mod 8=3   28 mod 8=4   29 mod 8=5   30 mod 8=6   31 mod 8=7   32 mod 8=0  
// 33 mod 8=1   34 mod 8=2   35 mod 8=3   36 mod 8=4   37 mod 8=5   38 mod 8=6   39 mod 8=7   40 mod 8=0  
// 41 mod 8=1   42 mod 8=2   43 mod 8=3   44 mod 8=4   45 mod 8=5   46 mod 8=6   47 mod 8=7   48 mod 8=0  
// 49 mod 8=1   50 mod 8=2   51 mod 8=3   52 mod 8=4   53 mod 8=5   54 mod 8=6   55 mod 8=7   56 mod 8=0  
// 57 mod 8=1   58 mod 8=2   59 mod 8=3   60 mod 8=4   61 mod 8=5   62 mod 8=6   63 mod 8=7   64 mod 8=0  
// 65 mod 8=1   66 mod 8=2   67 mod 8=3   68 mod 8=4   69 mod 8=5   70 mod 8=6   71 mod 8=7   72 mod 8=0  
// 73 mod 8=1   74 mod 8=2   75 mod 8=3   76 mod 8=4   77 mod 8=5   78 mod 8=6   79 mod 8=7   80 mod 8=0  
// 81 mod 8=1   82 mod 8=2   83 mod 8=3   84 mod 8=4   85 mod 8=5   86 mod 8=6   87 mod 8=7   88 mod 8=0  
// 89 mod 8=1   90 mod 8=2   91 mod 8=3   92 mod 8=4   93 mod 8=5   94 mod 8=6   95 mod 8=7   96 mod 8=0  
// 97 mod 8=1   98 mod 8=2   99 mod 8=3

Figuring out if an integer is an influence of two

With out taking bitwise operations into consideration, our first reflex to examine if a quantity is an influence of two is to make use of logarithms. It’s not the very best resolution, and you’ll shortly see why:

#embrace <math.h>

int is_power_of_two(int num) {
    // Adverse numbers will not be energy of two
    // 0 shouldn't be an influence of two
    if (num <= 0) {
        return 0; 
    // We compute the logarithm 
    double log2num = log2(num);
    // We examine if the logarithm is an integer
    return (log2num == ground(log2num));

Code seems to be positive, nevertheless it incorporates a harmful comparability between log2num==ground(log2num). The explanation it’s harmful is that double numbers can’t be represented with precise precision, errors by approximation can construct up, and refined variations can seem rendering the comparability ineffective.

When you don’t imagine me, let’s attempt the next code:

double x = 10 + 0.1 + 0.2 + 0.2; // ought to be 10.5
double y = 11 - 0.2 - 0.2 - 0.1; // ought to be 10.5
printf("x and y arepercentsequaln", x == y ? " " : " not ");
printf("the distinction between the numbers is: %1.16fn", x-y);

// Output
// x and y will not be equal
// the distinction between the numbers is: -0.0000000000000036

A disputed technique of fixing that is to introduce an epsilon (a really small worth representing tolerance) and examine doubles by approximating equality. So as a substitute of creating the comparability (x==y) straight, we will examine their distinction with epsilon.

double epsilon = 0.000001;
if (fabs(x-y) <= epsilon) {
    // the numbers are equal or nearly equal

This doesn’t resolve the issue by itself, however it could actually vastly cut back the variety of errors we get. So why don’t we implement this the skilled manner. A easy bitwise trick that determines if a quantity is an influence of two is to put in writing a perform like this:

bool is_pow2(uint16_t n) {
    return (n & (n-1)) == 0;

And once we take a look at it we noticed that every little thing seems to be positive:

uint16_t a = 1<<2, 
         b = 1<<3, 
         c = (1<<3) + 1;

printf("%hu is an influence of two: %s.n", a, is_pow2(a) ? "sure" : "no");
printf("%hu is an influence of two: %s.n", b, is_pow2(b) ? "sure" : "no");
printf("%hu is an influence of two: %s.n", c, is_pow2(c) ? "sure" : "no");       

// Output
// 4 is an influence of two: sure.
// 8 is an influence of two: sure.
// 9 is an influence of two: no.

Spoiler Alert the perform has one refined bug: it doesn’t behave appropriately when n is 0. Let’s attempt it:

uint16_t a = 0x0u;
printf("%hu is an influence of two: %s.n", a, is_pow2(a) ? "sure" : "no");

// Output
// 0 is an influence of two: sure.

Mathematicians will say: Elevating any non-zero quantity to a pure energy won’t ever lead to 0. So our code ought to be re-written as such to think about this nook case:

bool is_pow2(uint16_t n) {
    return n && !(n & (n-1));

Now that issues are sorted let’s have a look and see why the perform works. Firstly, everyone knows {that a} quantity which is an influence of two, in its binary illustration has precisely one little bit of 1 on the facility’s column:


After we subtract 1 from an influence of two, the bit sample seems to be like this:


So if we put these two footage facet by facet, we should always see how issues are going:


We will see that every one the bits nullify themselves once we apply &. If just one bit can be totally different (when the quantity shouldn’t be an influence of two), this trick received’t work.

Getting the subsequent energy of two

There are instances in code when, given a quantity n, you need to decide the primary energy of two that’s larger than n. For instance, if n=7, the subsequent energy of two larger than n is 8. Or, if n=13, the subsequent energy of two larger than 13 is 16.

The programmer’s reflex can be to put in writing a perform like:

uint32_t next_power_of_two_naive(uint32_t n) {
    uint32_t r = 1;
        r*=2; // or r<<=1
    return r;

Code works, nevertheless it’s liable to errors:

uint32_t n1=0, n2=128, n3=7, n4=UINT32_MAX; 
printf("subsequent energy of two for %u is %un", n1, next_power_of_two_naive(n1));
printf("subsequent energy of two for %u is %un", n2, next_power_of_two_naive(n2));
printf("subsequent energy of two for %u is %un", n3, next_power_of_two_naive(n3));
printf("subsequent energy of two for %u is %un", n4, next_power_of_two_naive(n4));

// Output
// subsequent energy of two for 0 is 1
// subsequent energy of two for 128 is 128
// subsequent energy of two for 7 is 8

Let’s abandon this resolution and attempt to make use of bitwise operations. The brand new code ought to be like this:

uint32_t next_power_of_two(uint32_t n) = n >> 2;

Does it work higher ?

uint32_t n1=0, n2=128, n3=7, n4=UINT32_MAX; 
printf("subsequent energy of two for %u is %un", n1, next_power_of_two(n1));
printf("subsequent energy of two for %u is %un", n2, next_power_of_two(n2));
printf("subsequent energy of two for %u is %un", n3, next_power_of_two(n3));
printf("subsequent energy of two for %u is %un", n4, next_power_of_two(n4));

// Output
// subsequent energy of two for 0 is 0
// subsequent energy of two for 128 is 128
// subsequent energy of two for 7 is 8
// subsequent energy of two for 4294967295 is 0

Nicely, at the least the code doesn’t enter an infinite loop when n=UINT32_MAX, however returns faulty outcomes for 0. So we will positively change one thing to it:

uint32_t next_power_of_two(uint32_t n) = n >> 1; 

Now, we also needs to do one thing when the numbers are getting nearer to UINT32_MAX. As you most likely know, UINT32_MAX shouldn’t be an influence of two (it’s truly (1<<32)-1), so trying to find the subsequent energy of two, after 1<<31, doesn’t make any sense. If we let the perform within the present type:

uint32_t n1=(1<<31)+1, 

printf("subsequent energy of two for %u is %un", n1, next_power_of_two(n1));
printf("subsequent energy of two for %u is %un", n2, next_power_of_two(n2));
printf("subsequent energy of two for %u is %un", n3, next_power_of_two(n3));

// Output
// subsequent energy of two for 2147483649 is 0
// subsequent energy of two for 2147483650 is 0
// subsequent energy of two for 2147483651 is 0

All the outcomes can be 0. So we should always department the perform once more and determine on what we’re going to do when n>(1<<31).

However now let’s get again to this magic, and see what’s occurring:

n |= n >> 1; 
n |= n >> 2;
n |= n >> 4;
n |= n >> 8;
n |= n >> 16;

Let’s assume n=0x4000A8CC (or n=1073785036). Calling next_power_of_two(0x4000A8CC) will return 0x80000000:

n        = 01000000000000001010100011001100 (0x4000A8CC)
n--      = 01000000000000001010100011001011 (0x4000A8CB)

n>>1     = 00100000000000000101010001100101
n        = 01000000000000001010100011001011
n|(n>>1) = 01100000000000001111110011101111
           -->1s                      1s<--

n>>2     = 00011000000000000011111100111011
n        = 01100000000000001111110011101111
n|(n>>2) = 01111000000000001111111111111111
           --->1s                    1s<---

n>>4     = 00000111100000000000111111111111
n        = 01111000000000001111111111111111
n|(n>>4) = 01111111100000001111111111111111
           ----->1s               1s<------

n>>8     = 00000000011111111000000011111111
n        = 01111111100000001111111111111111
n|(n>>8) = 01111111111111111111111111111111
           ------->1s           1s<--------

n>>16    = 00000000000000000111111111111111
n        = 01111111111111111111111111111111
n|(n>>8) = 01111111111111111111111111111111
           --------->1s        1s<---------

n++      = 10000000000000000000000000000000 (0x80000000)

As you may see, at every iteration, we’re slowly making a masks (within the type (1<<n)-1). By the top, when including 1, we get the subsequent energy of two: 1<<n.

BitSet or BitVector are used interchangeably to refer to a knowledge construction representing a set of bits, every of which could be 0 or 1. A BitSet is sort of a large panel with ON/OFF switches. You’ll be able to alter the state of these ON/OFF switches if you already know their place (index within the set).

Nevertheless, there could be some variations within the implementation and utilization of the 2 phrases primarily based on the context they’re getting used. Generally, A BitSet might confer with a fixed-sized assortment of bits, whereas BitVector might confer with a dynamically resizable assortment of bits.

For simplicity, we are going to implement a BitSet utilizing, you’ve guessed it, bitwise operations. The minimal set of operations a BitSet ought to help are:

  • Setting a bit to 0 (already lined here);
  • Setting a bit to 1 (already lined here);
  • Retrieving the worth of the bit (already lined here);
  • Resetting the BitSet (setting all of the bits to 0).

Now that we all know how one can manipulate the person bits of an integer, we will say that:

  • a uint16_t could be thought-about a BitSet with a dimension of 16;
  • a uint32_t could be thought-about a fixed-sized BitSet with a dimension of 32;
  • a uint64_t could be thought-about a fixed-sized BitSet with a dimension of 64;

However what if we would like a BitSet with a dimension larger than 64? We don’t have uint128_t (but!). So we are going to most likely have to make use of 4 uint32_t or 2 uint64_t. So a BitSet is an array of fixed-sized numbers (uintN_t), the place we index bits by their relative place within the BitSet.

The next diagram describes an array of 4 uint32_t integers with a complete of 4*32 ON/OFF switches (bits 0 or 1). Every bit ought to be accessible relative to their place within the array, to not the relative place of their integer (phrases):


To implement the BitSet we are going to use C macros:

#outline SET_NW(n) (((n) + 31) >> 5)
#outline SET_W(index) ((index) >> 5)
#outline SET_MASK(index) (1U << ((index) & 31))

#outline SET_DECLARE(title, dimension) uint32_t title[SET_NW(size)] = {0}
#outline SET_1(title, index) (title[SET_W(index)] |= SET_MASK(index))
#outline SET_0(title, index) (title[SET_W(index)] &= ~SET_MASK(index))
#outline SET_GET(title, index) (title[SET_W(index)] & SET_MASK(index))

Issues can look daunting at first, so let’s take every line and clarify what it does.


#outline SET_NW(n) (((n) + 31) >> 5)

This macro can decide the variety of uint32_t phrases we have to symbolize a BitSet of a given dimension.

If for instance, we’d like 47 positions, then SET_NW(47) will return (47+31)>>5, which is equal to saying (47+31)/32=2. Our array wants at the least two uint32_t integers to carry 47 values.


#outline SET_W(index) ((index) >> 5)

This macro returns the index of the uint32_t phrase that incorporates the bit we’re in search of on the given index.

For instance, if our BitSet has 64 indices (2 uint32_t phrases), calling SET_W(35) will return 35>>5, which is equal to saying 35/32=1. So we should search for the bit within the second uint32_t.


#outline SET_MASK(index) (1U << ((index) & 31))

Primarily based on a given index, this returns the masks to pick that particular person bit from the uint32_t phrase. index & 31 is equal to saying index % 32.

So, if, for instance, we name SET_MASK(16) it would create a masks that selects the bit 16 from the corresponding uint32_t phrase. If we name SET_MASK(35), it would create a masks that selects the bit 3 from the corresponding uint32_t phrase.

SET_MASK works on the phrase stage, whereas SET_W works on the array stage.


#outline SET_DECLARE(title, dimension) uint32_t title[SET_NW(size)] = {0};

This macro declares a bitset array (uint32_t[]) with the given title and dimension, and initializes it to all zeros. After declaration, the BitSet is a clear state, no ON/OFF swap is activated.

SET_1 and SET_0

#outline SET_1(title, index) (title[SET_W(index)] |= SET_MASK(index))
#outline SET_0(title, index) (title[SET_W(index)] &= ~SET_MASK(index))

These macros can be utilized to SET to 0 or 1 particular bits contained in the BIT_VECT. The strategies for doing this had been already described here.


#outline SET_GET(title, index) (title[SET_W(index)] & SET_MASK(index))

This macro is used to examine whether or not a bit is a set. If the bit is about to 1, the macro returns a non-zero worth. If the bit is about to 0, the macro returns 0.

Utilizing the BitSet

To check the newly outlined “macro” BitSet we will use this code:

// Declares uint32_t bitset[3] = {0};
SET_DECLARE(bitset, 84);

// Units the bits 1 and 80 to 1
SET_1(bitset, 1);
SET_1(bitset, 80);

printf("Is bit %d set? Reply: %s.n", 1, SET_GET(bitset, 1) ? "YES" : "NO");
printf("Is bit %d set? Reply: %s.n", 2, SET_GET(bitset, 2) ? "YES" : "NO");
printf("Is bit %d set? Reply: %s.n", 80, SET_GET(bitset, 80) ? "YES" : "NO");

// Is bit 1 set? Reply: YES.
// Is bit 2 set? Reply: NO.
// Is bit 80 set? Reply: YES.

This bitwise trick is usually uncalled for, nevertheless it’s good to make use of once you need to deceive your naive colleagues.

Swapping the worth of two variables is often achieved utilizing an middleman variable. This is among the first “algorithms” we study once we begin programming:

void swap(int *a, int *b) {
    int tmp = *a;
    *a = *b;
    *b = tmp;

int primary(void) {
    int a = 5, b = 7;
    printf("Earlier than swap: a=%d b=%dn", a,b);
    swap(&a, &b);
    printf("After swap: a=%d b=%dn", a,b);
    return 0;

However there are two different methods of attaining the identical consequence with out the necessity to introduce a brand new variable, tmp:

void swap_xor(uint8_t *a, uint8_t *b) {
    *a ^= *b;
    *b ^= *a;
    *a ^= *b;

int primary(void) {
    uint8_t a = 7;
    uint8_t b = 13;
    printf("Earlier than swap: a=%hhu b=%hhun", a, b);
    swap_xor(&a, &b);
    printf("After swap: a=%hhu b=%hhun", a, b);
    return 0;

// Output
// Earlier than swap: a=7 b=13
// After swap: a=13 b=7

What sort of magic is that this? Nicely, after these two traces of code: *a ^= *b; *b ^= *a; we will truly say that *b=(*b)^((*a)^(*b)), however as a result of ^ (XOR) is associative and commutative, the connection additionally interprets to *b=(*b)^(*b)^(*a), which is equal to *b=0^(*a), which is equal *b=*a, wow, did simply b turn out to be a?

Once more, we will additionally write *a=((*a)^(*b))^((*b)^((*a)^(*b))), which is equal to *a=(*a)^(*a)^(*b), wow, did a simply turn out to be b ? It seems to be difficult, nevertheless it’s not. Put this on paper, and the thriller will unfold.

Characters in C (char) described by this wonderful mapping, extra particulars about ASCII codes here:


All, with out getting deeper into the difficult realm of character encoding, we will undoubtedly say that your common char in C is a quantity. All of the printable char symbols are discovered within the following interval: [32..126].

The uppercase letters are discovered contained in the interval: [65..90], whereas the lowercase letters are to be discovered contained in the interval: [61..79]. As a result of chars are numbers, we will use bitwise operations for them.


Uppercase and lowercase letters have an identical bit patterns, besides the column akin to 1<<5. So with the proper masks put in place, we will transition backwards and forwards from lowercase to uppercase format. However what’s the proper masks? Nicely, it’s precisely the one akin to 0x20, which is the ' ' (the area) character.

So if we take an uppercase letter and | ' ', we are going to acquire a lowercase letter as a result of we are going to activate the bit akin to 1<<5.

char *p = "ABCDEFGH";
whereas(*p)  ' ');

// Output
// abcdefgh

If quite the opposite, we take a lowercase letter and & '_' (which corresponds to 0b01011111) we’re going to “eradicate” the 1<<5 bit and rework the preliminary letter to its uppercase type:

char *p = "abcdefgh";
    printf("%c", *p & '_');

// Ouput

If we need to toggle the case, we use ^ ' ' (XOR <area>):

char *p = "aBcDeFgH";
whereas(*p) {
    printf("%c", *p ^ ' ');
// Output
// AbCdEfG

Different bitwise tips involving char that you just may discover fascinating are:

// Getting the lowercase letter place within the alphabet
for(char i = 'a'; i <= 'z'; i++) {
    printf("%c --> %dn", i, (i ^ '`'));
// Output
// a --> 1
// b --> 2
// c --> 3
// d --> 4
// e --> 5
// f --> 6
// g --> 7
// ... and so forth
// Getting the uppercase letter place within the alphabet
for(char i = 'A'; i <= 'Z'; i++) {
    printf("%c --> %dn", i, (i & '?'));
// Output
// A --> 1
// B --> 2
// C --> 3
// D --> 4
// E --> 5
// F --> 6
// G --> 7
// ... and so forth

Gray Code, often known as Mirrored Binary is a binary numeral system the place two consecutive numbers differ in solely one-bit place. This new manner of representing binary numbers is helpful in functions reminiscent of electronics, the place errors attributable to spurious output transitions could be eradicated utilizing Grey Code as a substitute of the normal binary code (the one we’ve used till now).

The desk of correspondence seems to be like this:

Decimal Binary Grey Code Decimal Grey
0 0000 0000 0
1 0001 0001 1
2 0010 0011 3
3 0011 0010 2
4 0100 0110 6
5 0101 0111 7
6 0110 0101 5
7 0111 0100 4
8 1000 1100 12
9 1001 1101 13
10 1010 1111 15
11 1011 1110 14
12 1100 1010 10
13 1101 1011 11
14 1110 1001 9
15 1111 1000 8

The algorithm for transitioning from the binary system to the Grey Binary System is as follows:

uint8_t gray_code(uint8_t bv) {
    uint8_t gv = 0;    // 1. We initialize the consequence with 0
    uint8_t masks = bv; // 2. We use the enter binary quantity as a masks
    whereas (masks) {     // 3. Till the masks is totally different than 0
        gv ^= masks;    //       4. We XOR the consequence with the masks 
        masks >>= 1;    //       5. We shift the masks one bit to the proper
    return gv;         // 6. We return the corresponding Grey Code

If we run the code, it would return the beforehand described desk of correspondence:

for(uint8_t i = 0; i < 16; i++) {
    print_bits(stdout, i);
    printf(" - ");
    print_bits(stdout, gray_code(i));

// Output
// 00000000 - 00000000
// 00000001 - 00000001
// 00000010 - 00000011
// 00000011 - 00000010
// 00000100 - 00000111
// 00000101 - 00000110
// 00000110 - 00000100
// ... and so forth

A much less apparent utilisation of Grey Codes is that we will use them to generate permutations of a given set of parts (such because the characters of string, or the weather of an array). The fundamental concept is straightforward, every permutation is a sequence of Grey Codes, the place every code represents a swap between adjoining parts. By iterating from all of the Grey Codes, we do swaps, and on the identical time, generate every permutation.

The world of bitwise tips is way larger than what was lined on this article. Thanks for studying up till this level. Please examine the References part under to see extra on the subject.

In case you are curious to see a few of my code the place I did use bitwise operations intensively, please examine up the next two articles:

Source Link

What's Your Reaction?
In Love
Not Sure
View Comments (0)

Leave a Reply

Your email address will not be published.

2022 Blinking Robots.
WordPress by Doejo

Scroll To Top