set the m-bit to n-bit [closed]

by

Suppose Bits are numbered from LSB to MSB:

BIT NUMBER    31                                     0
               ▼                                     ▼
number bits    0000 0000 0000 0000 0000 0000 0001 0101 
               ▲    ^           ^                    ▲ 
              MSB   |           |                   LSB
                    |           | 
                   n=27        m=17

LSB - Least Significant Bit (numbered 0)
MSB - Most  Significant Bit (numbered 31)

In the figure above, I have shown how bits are numbered from LSB to MSB.
Notice the relative positions of n and m where n > m.

To set (all one) bits from n to m

To set-1 all bits from position m to n (where n > m) in a 32-bit number.
You need a 32-bit mask in which all bits are 1 from n to m and remaining bits are 0.

For example, to set all bits from m=17 to n=27 we need mask like:

BIT NUMBER    31   n=27        m=17                  0
               ▼    ▼           ▼                    ▼
mask =         0000 1111 1111 1110 0000 0000 0000 0000

And if we have any 32-bit number, by bitwise OR (|) with this number we can set-1 all bits from m to n. All other bits will be unchanged.

Remember OR works like:

x | 1 = 1   , and 
x | 0 = x

where x value can be either 1 or 0.

So by doing:

 num32bit = num32bit | mask;

we can set n to m bit 1 and remaining bits will be unchanged. For example, suppose, num32bit = 0011 1001 1000 0000 0111 1001 0010 1101,

then:

0011 1001 1000 0000 0111 1001 0010 1101   <--- num32bit
0000 1111 1111 1110 0000 0000 0000 0000   <--- mask     
----------------------------------------  ---------------Bitwise OR operation  
0011 1111 1111 1110 0111 1001 0010 1101   <--- new number  
---- ▲           ▲  -------------------
     |-----------|   this bits are from `num32bit`
      all bits are   
      1 here

This is what I mean by:

     num32bit = num32bit | mask;

##How to make the mask?

To make a mask in which all bits are 1 from n to m and others are 0, we need three steps:

  1. Create mask_n: All bits on Right side from n=27 are one

     BIT NUMBER     31  n=27                              0
                ▼    ▼                                ▼
 mask_27=       0000 1111 1111 1111 1111 1111 1111 1111

    In programming this can be created by right-shift (>>) 4 times.

    And, why 4?

     4 = 32 - n - 1  ==> 31 - 27 ==> 4

    Also note: the complement (~) of 0 has all bits one,
    and we need unsigned right shift in C.
    Understand the difference between signed and unsigned right shift

  2. Create mask_m: All bits on left side from m=17 are one.

     BIT NUMBER    31              m=17                  0
               ▼                ▼                    ▼
 mask_17       1111 1111 1111 1110 0000 0000 0000 0000

  3. Create mask: Bitwise AND of above to: mask = mask_n & mask_m:

     mask =         0000 1111 1111 1110 0000 0000 0000 0000
                     ▲           ▲
 BIT NUMBER          27          17

And, below is my getMask(n, m) function that returns a unsigned number that looks like mask in step-3.

#define BYTE 8
typedef char byte; // Bit_sizeof(char) == BYTE
unsigned getMask(unsigned n,
              unsigned m){
    byte noOfBits = sizeof(unsigned) * BYTE;
    unsigned mask_n = ((unsigned)~0u) >> (noOfBits - n - 1),
             mask_m = (~0u) << (noOfBits - m),
             mask = mask_n & mask_m; // bitwise & of 2 sub masks
    return mask;
}

To test my getMask() I have also written a main() function and a binary() function, which prints a given number in binary format.

void binary(unsigned);
int main(){
    unsigned num32bit = 964720941u;
    unsigned mask = 0u;
    unsigned rsult32bit;
    int i = 51;     
    mask = getMask(27, 17);
    rsult32bit  = num32bit | mask;  //set n to m bits 1
    printf("\nSize of int is = %ld bits, and " 
           "Size of unsigned = %ld e.g.\n", sizeof(int) * BYTE,
                                            sizeof(unsigned) * BYTE);
    printf("dec= %-4u, bin= ", 21);
    binary(21);
    printf("\n\n%s %d\n\t   ", "num32bit =", num32bit); 
    binary(num32bit);
    printf("mask\t   "); 
    binary(mask);
    while(i--) printf("-");
    printf("\n\t   "); 
    binary(rsult32bit);
    printf("\n");
    return EXIT_SUCCESS;
}
void binary(unsigned dec){
  int i = 0,
      left = sizeof(unsigned) * BYTE - 1;
  for(i = 0; left >= 0; left--, i++){
    printf("%d", !!(dec & ( 1 << left )));
    if(!((i + 1) % 4)) printf(" ");
  }
  printf("\n");
}

This test code runs like (the output is quite same as I explained in above example):

Output of code: 
-----------------
$ gcc b.c 
:~$ ./a.out 

Size of int is = 32 bits, and Size of unsigned = 32 e.g.
dec= 21  , bin= 0000 0000 0000 0000 0000 0000 0001 0101 

num32bit = 964720941
           0011 1001 1000 0000 0111 1001 0010 1101 
mask       0000 1111 1111 1110 0000 0000 0000 0000 
---------------------------------------------------
           0011 1111 1111 1110 0111 1001 0010 1101 
:~$

Additionally, you can write getMask() function in shorter form in two statements, as follows:

unsigned getMask(unsigned n,
                 unsigned m){
    byte noOfBits = sizeof(unsigned) * BYTE;
    return ((unsigned)~0u >> (noOfBits - n - 1)) &
           (~0u << (noOfBits -m));
}

Note: I removed redundant parentheses, to clean up the code. Although you never need to remember precedence of operators, as you can override precedence using (), a good programmer always refers to precedence table to write neat code.

A better approach may be to write a macro as below:

#define _NO_OF_BITS sizeof(unsigned) * CHAR_BIT
#define MASK(n, m)  (((unsigned)~0u >> (_NO_OF_BITS - n - 1)) & \
                    (~0u << (_NO_OF_BITS - m)))

And call like:

result32bit  = num32bit | MASK(27, 17);

To reset (all zero) bits from n to m

To reset all bits from n to m = 0, and leave the rest unchanged, you just need complement (~) of mask.

mask      0000 1111 1111 1111 1000 0000 0000 0000 
~mask     1111 0000 0000 0000 0111 1111 1111 1111   <-- complement

Also instead of | operator to set zero & is required.

remember AND works like:

x & 0 = 0   , and 
x & 0 = 0

where x value can be 1 or 0.

Because we already have a bitwise complement ~ operator and and & operator, we just need to do:

rsult32bit  = num32bit & ~MASK(27, 17);

And it will work like:

num32bit = 964720941
       0011 1001 1000 0000 0111 1001 0010 1101 
mask   1111 0000 0000 0000 0111 1111 1111 1111 
---------------------------------------------------
       0011 0000 0000 0000 0111 1001 0010 1101

More Related Contents:

  1. What is the fastest/most efficient way to find the highest set bit (msb) in an integer in C?
  2. Are the shift operators () arithmetic or logical in C?
  3. How can I multiply and divide using only bit shifting and adding?
  4. What is CHAR_BIT?
  5. Rounding up to next power of 2
  6. Catch and compute overflow during multiplication of two large integers
  7. SIMD signed with unsigned multiplication for 64-bit * 64-bit to 128-bit
  8. Bitwise operators and “endianness”
  9. Explain this snippet which finds the maximum of two integers without using if-else or any other comparison operator?
  10. Bitfield manipulation in C
  11. Fastest way to clamp a real (fixed/floating point) value?
  12. What’s bad about shifting a 32-bit variable 32 bits?
  13. Casting float to int (bitwise) in C
  14. What does the statement if (counter & (1
  15. Compute fast log base 2 ceiling
  16. Finding consecutive bit string of 1 or 0
  17. warning: left shift count >= width of type
  18. Bitshift and integer promotion?
  19. Unexpected C/C++ bitwise shift operators outcome
  20. Encoding int value as an IEEE-754 float (binary32)
  21. C reverse bits in unsigned integer
  22. How to define and work with an array of bits in C?
  23. Implementing Logical Right Shift in C
  24. Algorithm to generate bit mask
  25. Check if a number is non zero using bitwise operators in C
  26. How to replace bits in a bitfield without affecting other bits using C
  27. C Programming – XOR Bitwise Operation
  28. Bitwise shifting array of char’s
  29. How to implement Bitcount using only Bitwise operators?
  30. What is bit masking?

Leave a Comment