**Binary Addition Rules**

- Arithmetic rules for binary numbers are quite straightforward, and similar to those used in decimal arithmetic.
- The rules for addition of binary numbers are:

**Figure 1.Rules for Binary Addition**

Notice that in Fig.1, requires a ‘carry’ of 1 to the next column. Remember that binary 10_{2} = 2_{10} decimal.

- Binary addition is carried out just like decimal, by adding up the columns, starting at the right and working column by column towards the left.
- Just as in decimal addition, it is sometimes necessary to use a ‘carry’, and the carry is added to the next column.
- For example, in Fig. 3 when two ones in the right-most column are added, the result is 2
_{10}or 10_{2}. - The least significant bit of the answer is therefore 0 and the 1 becomes the carry bit to be added to the 1 in the next column.

**Binary subtraction rules**

**Figure 2.Simple Binary Addition**

- The rules for binary subtraction are quite straightforward except that when 1 is subtracted from 0, a borrow must be created from the next most significant column.
- This borrow is then worth 2
_{10}or 10_{2}as a 1 bit in the next column to the left is always worth twice the value of the column on its right.

**Binary Subtraction**

- The rules for subtraction of binary numbers are again similar to decimal.
- When a large digit is to be subtracted from a smaller one, a ‘borrow’ is taken from the next column to the left.
- In decimal subtractions the digit ‘borrowed in’ is worth ten, but in binary subtractions the ‘borrowed in’ digit must be worth 2
_{10}or binary 10_{2}. - After borrowing from the next column to the left, a ‘pay back’ must occur.
- The subtraction rules for binary are quite simple even if the borrow and pay back system create some difficulty.
- Depending where and when you learned subtraction at school, you may have learned a different subtraction method, other than ‘borrow and payback’, this is caused by changing fashions in education.

However any method of basic subtraction will work with binary subtraction but if you do not want to use ‘borrow and payback’ you will need to apply your own subtraction method to the problem.

**Figure 3.Binary Addition with Carry**

Fig. 4 shows how binary subtraction works by subtracting 5_{10 }from 11_{10} in both decimal and binary. Notice that in the third column from the right (2^{2}) a borrow from the (2^{3}) column is made and then paid back in the MSB (2^{3}) column.

**Figure 4.Binary Subtraction**

**Note:** In Fig 4 a borrow is shown as 10, and a payback is shown as 01. Borrowing 1 from the next highest value column to the left converts the 0 in the 2^{2} column into 10_{2} and paying back 1 from the 2^{2} column to the 2^{3} adds 1 to that column, converting the 0 to 01_{2}.

Once these basic ideas are understood, binary subtraction is not difficult, but does require some care. As the main concern in this module is with electronic methods of performing arithmetic however, it will not be necessary to carry out manual subtraction of binary numbers using this method very often.

This is because electronic methods of subtraction do not use borrow and pay back, as it leads to over complex circuits and slower operation. Computers therefore, use methods that do not involve borrow.

**Limitations of Binary Arithmetic**

**Figure 5.Limits of Binary Arithmetic ** ** ****Figure 6.The Overflow Problem**

- In Fig. 5 notice how the carry goes right up to the most significant bit.
- This is not a problem with this example as the answer 1010
_{2}(10_{10}) still fits within 4 bits, but what would happen if the total was greater than 15_{10}?

As shown in Fig 6,

- There are cases where a carry bit is created that will not fit into the 4-bit binary word.
- When arithmetic is carried out by electronic circuits, storage locations called registers are used that can hold only a definite number of bits.
- If the register can only hold four bits, then this example would raise a problem.
- The final carry bit is lost because it cannot be accommodated in the 4-bit register; therefore the answer will be wrong.
- To handle larger numbers more bits must be used, but no matter how many bits are used, sooner or later there must be a limit.
- How numbers are held in a computer system depends largely on the size of the registers available and the method of storing data in them, however any electronic system will have a way of overcoming this ‘overflow’ problem, but will also have some limit to the accuracy of its arithmetic.