# How to count with Binary Numbers

In the next few blog posts I want to talk about some common stuff, which will be very important when we eventually design our CPU using transistors. In today’s blog post I want to cover counting with binary numbers. This might seems to be a very boring topic, but it is one of the most important things and you will need to know it without having to think about it. Before we get down to binary numbers, let’s review how we actually count with those well-known decimal numbers.

## Counting with decimal numbers – Reset-Carry Operations

Every day – maybe even every hour – you are count with those decimal numbers: you count how many coffees you have had so far today, you count how many hours you have worked, you count how much money you have spent over the course of the day. But how do we do that counting at the technical level?

With decimal numbers we have 10 different digits: 0 to 9. Imagine you want to count up to number 9, using 4 possible digit positions:

0000
0001
0002
0003
0004
0005
0006
0007
0008
0009

After you have reached number 9, you have a big problem: you are out of numbers, because adding 1 to the number 9 would introduce an overflow. Therefore you reset the right-most number to 0 and send a carry (the number 1) to the next left-based number, which gives you the number 10. This task is called a Reset-Carry Operation (as described in the amazing book Digital Computer Electronics from Albert Paul Malvino).

0009
0000 Reset
0010 Carry

And then you can continue counting up to number 19:

0010
0011
0012
0013
0014
0015
0016
0017
0018
0019

When you have reached the number 19, you are faced with the same problem again: the next number can’t be represented just with the right-most digit. Therefore you perform the reset-carry operation again:

0019
0010 Reset
0020 Carry

And then the counting continues:

0020
0021
0022
0023
...

Imagine that you have finally counted up to 99. What you do when you want to add one to 99? In the first step you reset the right-most number to 0:

0099
0090 Reset

Then you send the carry to the next left-based number and add. But when you add 9 + 1 you have another overflow.

0090 Reset
0000 Reset

Therefore you send the carry again to the next left-based number. In our case there is no left-based number anymore, and we introduce again a 1:

0100 Carry

And finally you have the correct value of 100.

## Base 10 System

Because we deal with the numbers 0 to 9 in the decimal system, it has a base of 10. When you want to "calculate" the sum of a number, you just have to sum up the individual places according to their position. Imagine you want to calculate the decimal sum of the following number:

789

Of course we know that the sum is 789, because it is already described in the decimal system. But how do you calculate it? Let’s start again at the right-hand side of the number. The first digit has a weighting of 1, the next digit has a weighting of 10, and the third digit has a weighting of 100. So we can calculate the sum by calculating the individual weighting of every digit and finally sum up everything:

(9 * 1) + (8 * 10) + (7 * 100) = 789
(9 * 10^0) + (8 * 10^1) + (7 * 10^2) = 789
9 + 80 + 700 = 789 Easy, isn’t it?

## Counting with binary numbers

Let’s discuss now how to count with binary numbers. With binary numbers we have only two possible digits: 0 and 1. In the context of electronics it could just indicate whether a current is flowing through an electrical circuit or not. Imagine now that we want to count with the digits 0 and 1 up to the decimal number 10. Counting up to 1 is very simple:

0000 Decimal 0000
0001 Decimal 0001

But when we want to continue to count up to decimal 2 we have a problem again, because we introduce an overflow within our Base 2 system. Therefore we perform another reset-carry operation here as well:

0001 Decimal 0001
0000 Reset
0010 Carry, Decimal 0002

And then we continue counting up to decimal 3.

0010 Decimal 0002
0011 Decimal 0003

Counting up to decimal 4 would again introduce an overflow, therefore we perform the reset-carry operation again:

0011 Decimal 0003
0010 Reset
0000 Reset
0100 Carry, Decimal 0004

When you count with binary numbers, you perform the reset-carry operation every 2 numbers, because you are dealing with a Base 2 system:

0100 Decimal 0004
0101 Decimal 0005
0100 Reset
0110 Carry, Decimal 0006
0111 Decimal 0007
0110 Reset
0100 Reset
0000 Reset
1000 Carry, Decimal 0008
1001 Decimal 0009
1000 Reset
1010 Carry, Decimal 0010

The reset-carry operation will happen over and over again until you run out of positions with your 4-bit long number – then you have triggered a final overflow.

## Base 2 System

Imagine now that we want to count the decimal sum of the binary number 1010. We apply the same algorithm that we applied with decimal numbers. The only difference is in the weighting of each individual bit. The 1st bit has a weighting of 1 (if set), the 2nd bit has a weighting of 2 (if set), the 3rd bit has a weighting of 4 (if set), and the 4th bit has a weighting of 8 (if set).

(0 * 1) + (1 * 2) + (0 * 4) + (1 * 8) = 10
(0 * 2^0) + (1 * 2^1) + (0 * 2^2) + (1 * 2^3) = 10
0 + 2 + 0 + 8 = 10 You have just performed your first binary to decimal conversion! In another blog posting I will also show you the reverse conversion – decimal to binary.

## Summary

In this blog post we reviewed how you can count with binary numbers. In the first step you saw how you perform the counting with decimal numbers, and finally we have transferred this process to binary numbers. The only thing that we have changed here was the base: instead of a Base 10 system we have just used a Base 2 system.

In my next blog posting we will have a more detailed look at the hexadecimal system - a Base 16 system. One of the nicest things of the hex system is that... – ooh no, let’s talk about that one the next time... 😉

Stay tuned,

-Klaus