Why does division and multiplication by 2 use the shift operator rather than division operator

binarymathprogramming-languages

While looking at the code in C for division/multiplication by 2, it is found that shift operator is used rather than division operator. What is the advantage of using shift over division operator?

Best Answer

Multiplication is complex typically... unless one of the multiplicands is the base the numbers are in themselves.

When working with base 10 math, multiplying by 10 is trivial: "append the same number of zeros as the 10 has". 2 * 10 = 20 and 3 * 100 = 300

This is very easy for us. The exact same rule exists in binary.

In binary, 2 * 3 = 6 is 10 * 11 = 110, and 4 * 3 = 12 is 100 * 11 = 1100.

For a system already working with bits (ANDs and ORs), operations such as shift and roll already exist as part of the standard tool set. It just happens that translating N * 2^M into binary becomes shift N by M places

If we are doing something that isn't a power of 2 in binary, we've got to go back to the old fashioned multiply and add. Granted, binary is a bit 'easier', but a bit more tedious at the same time.

11 * 14 becomes (from Wikipedia on binary multiplier - a good read as it links to other multiplication algorithms for binary... shifting powers of two is still much easier):

       1011   (this is 11 in decimal)
     x 1110   (this is 14 in decimal)
     ======
       0000   (this is 1011 x 0)
      1011    (this is 1011 x 1, shifted one position to the left)
     1011     (this is 1011 x 1, shifted two positions to the left)
  + 1011      (this is 1011 x 1, shifted three positions to the left)
  =========
   10011010   (this is 154 in decimal)

You can see, we're still doing shifts, and adds. But lets change that to 11 * 8 to see how easy it becomes and why we can just skip to the answer:

       1011   (this is 11 in decimal)
     x 1000   (this is  8 in decimal)
     ======
       0000   (this is 1011 x 0)
      0000    (this is 1011 x 0, shifted one position to the left)
     0000     (this is 1011 x 0, shifted two positions to the left)
  + 1011      (this is 1011 x 1, shifted three positions to the left)
  =========
   1011000   (this is 88 in decimal)

By just skipping to that last step, we have drastically simplified the entire problem without adding lots of 0s that are still 0s.

Dividing is the same thing as multiplying, just the reverse. Just as 400 / 100 can be summarized as 'cancel the zeros', so too can this be done in binary.

Using the example of 88 / 8 from the above example

         1011 r0
     ________
1000 )1011000
      1000
      ----
       0110
       0000
       ----
        1100
        1000
        ----
         1000
         1000
         ----
         0000

You can see the steps in the long way of doing long division for binary is again quite tedious, and for a power of two, you can just skip to the answer by in effect, canceling the zeros.

(as a side note, if this is an interesting area for you, you may find browsing the binary tag on Math.SE, well... interesting.)

Related Topic