1.1.3. Mathematical Operations with the Binary Base

Operations in the binary base are equal to those in the decimal base. The difference is when we need to store numbers with a finite amount of bits. Let’s do some operations with 8 bits, where the MSB is the sign bit and the other 7 bits hold the magnitude of the number. We should be careful to operate with MSB separately as we do with plus and minus signs in the decimal base.

1.1.3.1. Sum

104₁₀+ 2₁₀= 0110 1000₂+ 0000 0010₂= 0110 1010₂= 106₁₀

As both summands are positive (their MSBs are 0), the most significant bit of the result is also 0. The result also isn’t greater than the maximum possible number we can write with 7 numerical bits 0111 1111₂– so an overflow didn’t occur.

104₁₀+ 24₁₀= 0110 1000₂+ 0001 1000₂= 1000 0000₂= 0₁₀

In this example the second number is bigger than in the first example, but the result is unusually small – that is because an overflow occurred: we only have enough bits to store binary numbers with 7 digits, but our result has 8 digits (not counting the MSB, as it is used to store the sign) and due to that the highest, eight, digit gets cut off, as we do not have enough space to store it – this is called an overflow and the result we get is incorrect.

1.1.3.2. Subtraction

-104₁₀- 2₁₀= -(104₁₀+ 2₁₀)= -(0110 1000₂+ 0000 0010₂) = 1110 1010₂= - 106₁₀

Here we subtracted two negative numbers so the result is negative (MSB of the result is 1). The overflow can also occur with negative numbers as seen in the following example:

-104₁₀- 24₁₀= -(104₁₀+ 24₁₀) = -(0110 1000₂+ 0001 1000₂) = 1000 0000₂

The next example shows a subtraction of a positive and a negative number.

-104₁₀+ 24₁₀= -(104₁₀- 24₁₀) = -(0110 1000₂- 0001 1000₂) = 1101 0000₂

1.1.3.3. Multiplication

2₁₀* 60₁₀= 0000 0010₂* 0011 1100₂= 0111 1000₂= 120₁₀

-2₁₀* 60₁₀= -0000 0010₂* 0011 1100₂= -0111 1000₂= 1111 1000₂= - 120₁₀

In none of the cases shown above did an overflow occur.

1.1.3.4. Division

60₁₀/2₁₀= 0011 1100₂/ 0000 0010₂= 0001 1110₂= 30₁₀

If the division results in a decimal number, the decimal places are discarded.

1.1.3.5. Two Complement

The way we do arithmetic operations on paper, like carrying numbers over and deciding which number is greater to influence the sign of the result, when performing a subtraction, is difficult to implement in a digital system. To overcome that there is another way to represent finite binary numbers and it’s called two complement. It is easier to perform calculations of sum and subtraction using two complement representation.

The main advantage of two complement is that we do not have two numbers representing 0 when working with signed numbers (in signed magnitude notation the numbers 0000₂and 1000₂represent +0 and -0 (written with 4 bits), which makes computer calculations more complex). So the two complement always has one negative number more when written with finite bits (0 is defined as a positive number).

First we define how many bits we are working with. After that we perform an operation to find the two complement of a negative number. If you have to do the complement of a number x of n bits, the operation is this, y₂= ( \(2^n\) - x)₂. For example we are working with 3 bits and we want to know the two complement of -010₂, doing the operation,

y₂ = 1000₂ – 010₂ = 110₂, and the result is -010₂ represented in two complement.

Adding and subtracting numbers becomes easy.

3₁₀ – 2₁₀ = 011₂ – 010₂ = 011₂ + (1000₂ - 010₂) =011₂ + 110₂ = 1001₂ = 010₂, in this case we have to discard the MSB, the result is correct as the operands had different signs.

3₁₀ +2₁₀ = 011₂ + 010₂ = 101₂, the result is wrong as the sign of the operands are equal, but the sign of the result is different => an overflow occurred (maximum positive number is 011₂= 3₁₀).

-3₁₀ – 2₁₀ = 101₂ + 110₂ = 1011₂, the result is wrong as the sign of the operands are equal, but the of the result is different => an overflow occurred (the maximum negative number is 100₂= -4₁₀).

-3₁₀ – 1₁₀ = 101₂ + 111₂ = 1100₂ = 100₂, the result is correct as the sign of the operand are equal and the sign of the result is equal (we still need to discard the MSB).

There exists a way easier way of getting a 2’s complement of a number. For example, we want to get the equvalent of -24₁₀ in the binary base, written as a 2’s complement with 8 bits:

Firstly we write the negative number as a positive one in the binary base:

24₁₀ = 00011000₂

Then, going from LSB to MSB we just copy the digits until we get to the first 1, we also copy the fist 1, afterwards we just negate all the remaining bits and we get:

-24₁₀ = 11101000₂

If we calculate -24₁₀ with the previously mentioned formula (y₂= ( \(2^n\) - x)₂) we get:

-24₁₀ = 100000000₂ – 00011000₂ = 11101000₂

Decimal number	Binary number	3 bits complement two
3	011	011
2	010	010
1	001	001
0	000	000
-1	100	111
-2	101	110
-3	110	101
-4	111	100