In this article we are going to learn about converting a decimal number into a binary number with:

- method 1: Descending Powers of Two and Subtraction
- method 2: Short Division by Two with Remainder
- Scilab: using
`while`

loop - Scilab: using the build-in function
`dec2bin`

- C: using
`while`

loop

Before going through this article, it is recommended to have a basic understanding about:

When dealing with embedded systems, microcontrollers, digital electronics or engineering in general we might need to covert a decimal number (base 10) into a binary number (base 2).

We are going to convert the decimal number 57 into a binary number. The methods below can be applied to any positive integer decimal number.

#### Method 1: Descending Powers of Two and Subtraction

Before doing any calculation we are going to write down the powers of 2. In order to make the example easier to follow we are going to use. We only need to write the powers of 2 until we exceed out decimal number to be converted. Nevertheless in our example we’ll write up to 256.

\[ \begin{equation*} \begin{split} 2^0 =& 1\\ 2^1 =& 2\\ 2^2 =& 4\\ 2^3 =& 8\\ 2^4 =& 16\\ 2^5 =& 32\\ 2^6 =& 64\\ 2^7 =& 128\\ 2^8 =& 256 \end{split} \end{equation*} \]First we write the decimal number as a sum of powers of 2.

By looking into the power of 2 table above we can extract the highest power of 2 which is less than our decimal number (57). In our case is 32. So we write 57 as a sum of 32 and 25. The same we proceed with 25, we write it as a sum of powers of 2. Finally we get:

\[ \begin{equation*} \begin{split} 57 =& 32 + 25\\=& 32 + 16 + 9\\

=& 32 + 16 + 8 + 1 \end{split} \end{equation*} \]

Next, we multiply with 1 each power of 2. The sum remains the same but written closer to binary extraction:

\[ \begin{equation*} \begin{split} 57 =& 1 \cdot 32 + 1 \cdot 16 + 1 \cdot 8 + 1 \cdot 1 \end{split} \end{equation*} \]We write the same expression but with powers of 2:

\[ \begin{equation*} \begin{split} 57 =& 1 \cdot 2^5 + 1 \cdot 2^4 + 1 \cdot 2^3 + 1 \cdot 2^0 \end{split} \end{equation*} \]Now we add into the sum the missing powers of 2 but multiplied with 0 (zero) to keep the same result:

\[ \begin{equation*} \begin{split} 57 =& 1 \cdot 2^5 + 1 \cdot 2^4 + 1 \cdot 2^3 + 0 \cdot 2^2 + 0 \cdot 2^1 + 1 \cdot 2^0 \end{split} \end{equation*} \]From the expression above we extract the coefficients of the powers of 2 which is the binary number:

\[ \begin{equation*} \begin{split} 111001 \end{split} \end{equation*} \]Finally, the representation of 57 in binary format is:

\[ \begin{equation*} \begin{split} 57_{10} = 111001_{2} \end{split} \end{equation*} \]#### Method 2: Short Division by Two with Remainder

The second method is faster and probably easier to remember than the first method.

We start by dividing our decimal number 57 by 2. The result of the division is 28 with the remainder 1. We keep in mind the remainder and continue to divide 28 by 2. The result is 14 with the remainder 0. We proceed with the division until the result of the division is equal to 1:

\[ \begin{equation*} \begin{split} 57 \div& 2 (1)\\28 \div& 2 (0)\\

14 \div& 2 (0)\\

7 \div& 2 (1)\\

3 \div& 2 (1)\\

1 \div& 2 (1) \end{split} \end{equation*} \]

By extracting all the remainders of the divisions we get the binary representation of the decimal number. The remainder of the first division represents the first bit (from right).

By putting all the remainders on next to another we get the binary representation of the decimal number:

\[ \begin{equation*} \begin{split} 111001 \end{split} \end{equation*} \]Finally, the representation of 57 in binary format is:

\[ \begin{equation*} \begin{split} 57_{10} = 111001_{2} \end{split} \end{equation*} \]Obviously we got the same result as with Method 1.

If we need to represent the decimal number on **8 bits** we only need to fill up the left side of the binary representation with 0 until we have a total of 8 bits:

#### Scilab: using `while`

loop

The Scilab script below coverts a given decimal number `decNo`

into a binary number `binNo`

using the division by 2 method into a `while`

loop:

// Decimal number to be converted decNo = 57; // Display decimal number mprintf("Decimal: %d",decNo) // Binary string initialization binNo = []; // While loop while (decNo >= 1) remNo = modulo(decNo,2); // calculate remainder decNo = floor(decNo/2); // divide by 2 and keep integer if remNo binNo = ['1' binNo]; // if remainder is 1 add 1 to string else binNo = ['0' binNo]; // if remainder is 0 add 0 to string end end // Transform vector of strings into one string binNo = strcat(binNo); // Display binary number mprintf("\nBinary: %s",binNo)

#### Scilab: using the build-in function `dec2bin`

More easily we can use directly the Scilab build-in function `dec2bin`

for decimal to binary conversion:

-->dec2bin(57) ans = 111001 -->

You can use the `dec2bin`

function to verify if the script above with `while`

loop works correctly.

C: using while loop

The same algorithm, division by 2, programmed in C language:

#include <stdio.h> int main(void) { int decNo = 57; int binNo[8]; int i = 0; printf("Decimal number is: %d", decNo); printf("\nBinary number is: "); /* Calculate the binary number */ while(decNo>=1){ binNo[i]= decNo % 2; decNo = decNo / 2; if (decNo>=1){ i = i + 1; } else { break; } } /* Display the binary number */ while (i>=0){ printf("%d",binNo[i]); i--; } return 0; }

As reference save the image below which contains a summary of both methods for decimal to binary conversion.

For any questions, observations and queries regarding this article, use the comment form below.

Don’t forget to Like, Share and Subscribe!