# Binary numbers: introduction

This section forms a brief introduction to the binary number-system.

Binary numbers are closely linked to digital logic, because arithmetic on binary numbers can easily be implemented using an array of logic-gates.

This section doesn't go into binary arithmetic, since there's not much arithmetic going on in the Qibec CPU except "increment by one" to calculate the next program-address.

# Decimal digits and numbers

Most everyday arithmetic (e.g. when buying goods in a store) makes use of the decimal number-system.

A decimal number consists of decimal digits. A decimal digit is a symbol from "0" up to and including "9". The reason for there being exactly 10 digits, is probably that humans have 10 fingers.

The value of a decimal number can be much higher than 10 (e.g. 15382), but the value of a digit is 9, at most.

Decimal digits form decimal numbers according to "decimal positional notation". This means that in a number, the position of a digit determines its magnitude.

As an example, consider the decimal number "345" (three-hundred and forty-five). The meaning, or value, of this number is:

`345(dec)  =  3 x hundred  +  4 x ten  +  5 x one`

or rather:

`345(dec)  =  3 x 10^2  +  4 x 10^1  +  5 x 10^0`

(The caret stands for "to the power of". The "dec" suffix is added to make it clear this is a decimal number - or in other words, make it clear how to interpret this number.)

As can be seen, the magnitude (or numeric weight) of a digit depends on its position: the further a digit is positioned to the left, the more it weighs.

This is very convenient: big numbers can be formed using a small set of symbols (0..9).

# Bits and binary numbers

The decimal number-system is also called "base-10", because when going 1 digit to the left in a decimal number, its magnitude increases by a factor 10.

As stated before, this number "10" is arbitrary - if humans had had 12 fingers, we would probably be using a base-12 number-system.

The binary number-system narrows down the set of possible symbols from 10 to 2.

(The value of this binary symbol can only be "0" or "1". Such a binary symbol/digit is called a "bit" - literally "Binary digIT".)

Therefore, the binary number-system is a base-2 system. Like the decimal number-system, the position of a bit in a binary number determines its magnitude or weight:

`1011(bin)  =  1 x 2^3  +  0 x 2^2  +  1 x 2^1  +  1 x 2^0`

or, in words:

`1011(bin)  =  1 x eight  +  0 x four  +  1 x two  +  1 x one`

The value of this binary number is therefore eleven.

When mixing binary and decimal numbers, it becomes important to explicitly state the number-system that is to be used.

For example:

`110(bin)  =  1 x four  +  1 x two  +  0 x one  =  six`

but:

`110(dec)  =  1 x hundred  +  1 x ten  +  0 x one  =  hundred-ten`

Obviously, a big difference. Sometimes, a "b" suffix is used for binary numbers, e.g. "110b".

# Relevance of binary numbers to computing

For a few reasons, binary numbers and binary/digital arithmetic lend themselves better to electrical implementations than do decimal numbers.

For one, the water- and electrical circuits given earlier make use of only 2 pressure-/voltage-states: either high or low.

From a practical point, this is convenient, because it presents less ambiguity between values.

(Compare this to a model with e.g. 10 different pressure-levels. More advanced components would have to be used to distinguish levels, and there's a risk of pressure/voltage dropping too much when traveling in a long pipe/wire.)

Circuits to perform binary arithmetic can be implemented one bit at a time, by using sub-circuits. For example, adding 2 binary numbers of 10 bits each can be done by 10 cascaded subcircuits, each adding 2 bits at a certain position.

Without going into detail, this method of addition is very similar to how most people perform addition: write the numbers to be added under each other, then, for each digit-position from right to left, add the digts, "carrying" a digit to the left if a sum exceeds 9.

``` carried :     1               1111

number A :     44              0101100
number B :     28              0011100
---- +(dec)     --------- +(bin)
result :     72              1001000```

Using the same method, the only difference between adding decimal and binary numbers is that when using binary numbers, a digit has to be carried to the left if a result exceeds 1 instead of 9.

Thus, by using many simple subcircuits together, binary arithmetic can be implemented - addition just being an example.