# Binary Subtraction

Subtract one number from another is the same thing that adding it to its symmetrical. Thus if we want to subtract 37 from 65 we get the same result if we add to **65** the symmetrical of (+37), i.e., **(-37)**.

** 65 – (+37) = 65 + (-37) = 28**

In base 2 everything goes the same way. When we want to subtract one number from another, we establish its symmetrical and add the result to it.

Let’s exemplify this operation in the graphic of * Figure 1* step by step as indicated in its captions. In a first step the numbers 65 and 37 are converted into their unsigned binary representation. The number

**65**, now

**1000001**is represented by 7 bits. Adding to it the sign 0 because it is positive, it will come to have 8 bits and thus being prepared for the operation, as

**65** = **0**1000001

With the number **37**, now **100101** we will have a lot more things to do. Adding the sign to it, **0** because it is * positive *it will come to have 7 bits, as

**0**100101. Then we deny its bits and add 1 to the result, getting

**1**011011. Finally we extend it to 8 bits thus being prepared for the operation as

**(-37)** = **1**1011011

Now we can do the binary addition of **65** and **(-37)** as we can see in Figure 1-14 . The final * carry out* of the operation has the value

**1**but as it doesn’t fit in a 8 bits representation it is ignored. As we said we will deal with this question further on.

After all, we are dealing with addition and subtraction the same way, only with different assumptions.

*Is it by any chance possible to identify a common pattern in both operations behavior that would allow us** to use the same circuit for both purposes**, just introducing some additional logic into the adder circuit?*

Let’s see and follow the description with * Figure 2*, where the circuit is materialized. First we have to bring to the adder the information about the kind of operation it will be doing, if its an addition or a subtraction. That can be done with a sign which we will call by

**Sop**(sign

*of the*

**op**

*eration*). If it is a subtraction the bits of the second operand have to be denied, but only if it is a subtraction.

*How are we going to tell the circuit if it denies or not the second operand bits? We are dealing with a circuit which does two types of operations, but only one in each moment.*

Probably it won’t be very difficult to deny the bits. There’s a logical gate which does it for us. The XOR gate. Always **1** when * different* and

**0**when

*. We will put one*

**equal****XOR**gate per bit before the adder circuit, connecting the

*‘s bits to one of their inputs and the operation identifier sign*

**2nd operand***to the other input. Since*

**Sop****Sop**assumes the value

**1**for

*, the*

**subtraction****XOR**operator fulfills its function inverting (denying) the value of all the bits of the 2nd operand.

*And when the operation is an addition?*

In this case, **Sop** assumes the value **0** indicating addition, the **XOR** operator input with Sop will assume the value **0** and thus **XOR** will always return the value of the other input, the 2nd operand not denying its bits. If we connect these XOR gates output to the Adder circuit 2nd operand input, the denial of its bits for the subtraction, and only for the subtraction, is ensured.

*But what we want there it’s not the 2nd operand’s denial but its symmetrical. In order to get it we have yet to add the value 1 to the denial. And now what?*

We have to sum **1** to the first bit!

*But, as the circuit is already adding the two zero-order bits of the operands, how do we put a 3rd bit over there? *

If, instead of a partial adder for the first bit we use a full adder, we can introduce a further element to the sum in the form of a carry in. Yes, it’s possible.

*But how do we tell our friend that it only uses this value when it is doing a subtraction?*

Wait! We don’t need to say anything. The * carry-in* is always added . It’s its value which can be either

**1**or

**0**. So we just have to connect it to

**Sop**, the operation identifier, and thus the first carry in (

**Cin**) assumes the value

**1**if it’s doing a

*or*

**subtraction****0**if it’s doing an

*. Ok! Now its complete!*

**addition** **We can ensure that the 2nd operand will always be represented by its symmetrical in a subtraction, and only for this operation.**

Let’s put all this together and summarize:

- To each of the adder circuit 2nd operand input will be connected the
**XOR**gate output whose inputs are the operation identifier sign**Sop**and the respective**2nd operand**bit. - If
**Sop**is**0**(addition) the**XOR**gate will return the real value of the 2nd operand bit. If**Sop**is**1**(subtraction) the**XOR**gate will deny the 2nd operand bit. -
**Sop**being connected to**Cin**(the carry in of order 0 bit)**adds 1**to the sum of order 0 bits**when Sop is 1**(*subtraction*) and**adds 0**when**Sop is 0**(*addition*).

*This is just what we pretended. When the operation is a subtraction the 2nd operand bits are denied and 1 is added to it, thus being converted in its symmetrical. When the operation is an addition the 2nd operand is used as it is. *

We are going to add some graphics of this circuit, illustrating the various operations of addition and subtraction between the values **5** and **13**, trying to cover all the possible significant addition and subtraction operations with these operands, which can be seen in * Figure 4*.

For certain operations with **5** and **13** in two’s complement, such as the sum **13+5=18**, we need 6 bits (-32 to 31) to represent the result.

The numbers **5** and **13**, represented with 4 bits when unsigned, need one more bit, the sign, for its two’s complement representation, so 5 bits.

Thus, we will use 6 bit logical circuits and extend the binary representation of **5** and **13** to 6 bits, as shown in the table in * Figure 3*.

Some important observations about the * Frames of Figure 4* before we proceed:

**Sop**is the operation identifier.**Cin**is the circuit’s do carry in, equal to**Sop**.- The operands
**A**and**B**are represented by the bits:- A0 to A4 and SinA as A5.
- B0 to B4 and SinB as B5.

**SinA**and**SinB**represent**A and B signs**.**C0**to**C5**represent the adder circuit 0 to 5 orderbits**Cout**or the**Cin**of the above order bits.**S0**to**S4**bits and**S5****as Sign**represent the result.

So, let’s proceed with the frames of * Figure 4*:

In** Frame I** we subtract (+5) from (+13).

*This operation corresponds to the subtraction (Sop=1) of equal sign operands [(+13)-(+5)]*.

Actually what this circuit does is an addition. Being notified by the **Sop** sign (**1**) that the operation is a **subtraction**, it calculates the symmetrical of the 2nd operand and executes the operation

*[(+13)+(-5)].*

The result is **001000**, or **(+8**) in decimal.

In* Frame II* we add (+13) with (+5).

*This operation corresponds to the addition (Sop = 0) of equal sign operands [(+13)+(+5)]*.

The operation that the circuit executes is exactly the one which is identified. Being notified by the Sop sign (**0**) that the operation is an **addition**, it lets the second operand go through without any changes and executes the operation

*[(+13)+(+5)]*.

The result is **010010**, or **(+18)** in decimal.

In* Frame III* we add (+5) with (-13) .

*This operation corresponds to the addition (Sop=0) of different sign operands [(-13)+(+5)]*.

Again, the operation that the circuit executes is exactly the one which is identified. Being notified by **Sop** (**0**) that the operation is an **addition**, it lets the 2nd operand go through without any changes and executes the operation

*[(+13)+(+5)]*.

The result is **111000**, or **(-8)** in decimal.

In* Frame IV* we subtract (+13) to (-5).

*This operation corresponds to the subtraction (Sop = 1) off different sign operands [(-5)-(+13)]*.

Actually the operation that this circuit executes is an addition. Being notified by the **Sop** sign (**1**) that the operation is a **subtraction**, it calculates the symmetrical of the 2nd operand and executes the operation

*[(-5)+(-13)]*

The result is **001000**, or **(-18)** in decimal.

In* Frame V* we add (-13) to (-5).

*This operation corresponds to the addition (Sop = 0) of equal sign operands [(-5)-(+13)]*.

Actually the operation that this circuit executes is an addition. Being notified by the **Sop** sign (**0**) that the operation is an **addition**, it lets the 2nd operand go through without any changes and executes the operation

*[(-5)+(-13)]*,

what matches exactly what was done in the previous frame. we start from two different situations to end in the same solution for the circuit. The result is **001000**, or **(-18)** in decimal.

We verified in these 5 Frames the behavior of the adder/subtractor circuit in some different situations of addition and subtraction with different operand signs. The purpose was to illustrate how the operands are introduced in the circuit according to their sign and to the **Sop** value.

Let’s now address the frequently focused topic, the **excess**, which occurred in Frames II and IV. If we had not extended the circuit to 6 bits, the order 5 bit wouldn’t exist to absorb this excess. The generated situation, once not properly treated, would cause an error.

*Look at Frame II. The final Carry Out of the circuit is 1, correct? But we ignored this carry Out. Why? However we said that there was an excess absorbed by the order 5 bit and the carry out was 0. How is that? We ignore it when 1 and valorize it when 0?*

In this work we can do whatever we want. As we knew that the result of the operations we were going to execute could only fit into a 6 bit circuit, we created one.

Actually an 8 bits (e.g.) circuit is not extensible, it doesn’t know which operations it is going to perform and not even their result. But it has to be prepared to react correctly regarding all the possibilities it can face, always preventing the possibility of an error.

That’s just what we are going to see. How to detect, classify and manage **the excess** in binary operations. It’s an important matter, as if we don’t detect and correct the situation or stop the program issuing an error information, the error will propagate with unpredictable consequences.