Binary
Arithmetic
Binary Addition
Binary Subtraction
Binary Multiplication
Binary Division
Signed Numbers
Copyright ã 199395, Thomas P. Sturm
Binary Arithmetic
Arithmetic can be done on binary numbers just as it is done on decimal numbers. The only difference is that there are only two symbols in binary (instead of 10 in decimal), hence the tables to "memorize" are much shorter.
Addition:
Addend 
0 
1 

Augend 

0 
0 
1 

1 
1 
10 
Subtraction:
Subtrahend 
0 
1 

Minuend 

0 
0 
1 

1 
* 
0 
* we have no way of representing negative numbers yet
Multiplication:
Multiplicand 
0 
1 

Multiplier 

0 
0 
0 

1 
0 
1 
Binary Addition
To add two binary numbers, start at the right hand side as you would for decimal numbers.
For example, in an 8bit computer, add 16 to 6 (decimal)
00010000
+ 00000110
00010110
Need to worry about a "carry" whenever we add 1 + 1 (binary).
For example, in an 8bit computer, to add 29 to 77 (decimal)
00011101
+ 01001101
01101010
However, adding large numbers can present a problem, for example 176 + 230 (decimal):
10110000
+ 11100110
1 10010110
A carry off the left side of an unsigned number is overflow. (The result is greater than 255, the largest number that can be held in 8 bits)
Binary Subtraction
To subtract two binary numbers, again start at the right side of the number, as you would for decimal numbers.
For example, in an 8bit computer, subtract 9 from 15 (decimal)
00001111
 00001001
00000110
Need to worry about a borrow whenever we subtract 1 from 0.
For example, in an 8bit computer, subtract 9 from 17 (decimal)
00010001
 00001001
00001000
Borrows can span a long distance, for example 17  11 (decimal)
00010001
 00001011
00000110
However, subtracting a large number from a small one can create a problem, since we have no way of representing negative numbers. For example:
00010110
 00100100
(1) 11110010
Binary Multiplication
To multiply two numbers, we could use the methods learned for decimal numbers, for example 11 x 5
00001011
x 00000101
00001011
00000000
00001011
0000110111 = 00110111
However this is cumbersome for larger numbers, for example 11 x 13
00001011
00001101
00001011
00000000
00001011
00001011
00010001111 = 10001111
Instead, use the shiftandadd algorithm.
multiplicand:  multiplier:  product  
00001011  00001101  00000000  
00010110  00000110  00001011  
00101100  00000011  00001011  
01011000  00000001  00110111  
10110000  00000000  10001111 
Binary Division
To divide two numbers, we could use the methods learned for decimal numbers, for example 26 / 5
00000101 (quotient)
00000101  00011010
000101
110
101
1 (remainder)
Signed Numbers
Subtraction quickly leads to overflow because there are no negative numbers.
We need a way of coding negative numbers. We would prefer a way that would allow the four functions (addition, subtraction, multiplication, and division to "work" without special handling of the sign.
Generally, we use one bit to represent the sign of a number. Generally this is the leftmost bit. The means that about half of the numbers will be positive, and about half of the numbers will be negative.
There are four methods in use today for representing signed numbers. All are used by the VAX in various places.
 Sign/Magnitude
 One's Complement
 Two's Complement
 Biased
Sign/Magnitude
Sign bit is independent of magnitude bits. 0 is positive, 1 is negative.
For example +4 is 00000100 (same as unsigned), 4 is 10000100
(instead of representing 132 in unsigned).
Arithmetic:
Addition: 00000100 (4)
+ 10000100 +(4)
10001000 (8) doesn't work directly
(Nor does subtraction, multiplication, or division)
Need to provide special logic circuits to handle the sign.
This is used wherever you would need special logic circuits to handle the sign anyway, such as the sign on a floating point number.
One's Complement
Instead of just changing the sign bit for negative numbers, change all of the bits.
For example, 4 = 00000100 (same as unsigned and sign/magnitude), 4 = 11111011 (instead of 251 in unsigned or 123 in sign/magnitude)
Addition: 00000100 (4)
+ 11111100 +(3)
1 00000000
+ 1
00000001 (1)
Need to "conserve" the carry to get addition to work.
Subtraction: 00000100 (4)
 00000101 (5)
(1) 11111111
 1
11111110 (1)
Multiplication and division also need to conserve carries to work
Addition: 00000100 (4)
+ 11111011 +(4)
11111111 (0) or "dirty zero"
One's complement is used primarily for logical operations on the VAX.
Two's Complement
Two's complement is harder to form than one's complement, but doesn't require the adjustments for carry and borrow.
Two's complement doesn't have the "dirty zero" problem inherent in one's complement.
In two's complement, we count down 2 = 00000010, 1 = 00000001, 0 = 00000000, 1 = 11111111, 2 = 11111110
To form the negative of a number, start at the right, copy all of the 0 bits (if any) moving right to left until a 1 bit is encountered, copy the rightmost 1 bit, then toggle (change) all of the remaining bits.
For example, 4 = 00000100 (same as unsigned, sign/magnitude, and one's complement, 4 =
11111100 (252 in unsigned,
124 in sign/magnitude, 3 in one's complement)
Addition: 00000100 (4)
+ 11111100 +(4)
1 00000000 (0)
00000100 (4)
+ 11111101 +(3)
1 00000001 (1)
00000100 (4)
+ 11111011 +(5)
1 11111111 (1)
Two's Complement Subtraction
Subtraction:
00000100 (4)
 00000100 (4)
00000000 (0)
00000100 (4)
 00000011 (3)
00000001 (1)
00000100 (4)
 00000101 (5)
(1) 11111111 (1)
11111100 (4)
 11111011 (5)
00000001 (1)
11111100 (4)
 11111101 (3)
(1) 11111111 (1)
Multiplication and division also work by ignoring borrows and carries.
Biased representation
Would like a way where there is no discontinuous break from the positive to the negative numbers  want to "count through" zero. Just "bias" the unsigned numbers by half the range.
Consider a 4bit computer for a change. Examine the 16 bit patterns and see what they represent using each of the "encoding/decoding" conventions.
Binary 
Unsigned 
Sign/ Magnitude 
One's Complement 
Two's Complement 
Biased 

0000 
0 
0 
0 
0 
8 

0001 
1 
1 
1 
1 
7 

0010 
2 
2 
2 
2 
6 

0011 
3 
3 
3 
3 
5 

0100 
4 
4 
4 
4 
4 

0101 
5 
5 
5 
5 
3 

0110 
6 
6 
6 
6 
2 

0111 
7 
7 
7 
7 
1 

1000 
8 
0 
7 
8 
0 

1001 
9 
1 
6 
7 
1 

1010 
10 
2 
5 
6 
2 

1011 
11 
3 
4 
5 
3 

1100 
12 
4 
3 
4 
4 

1101 
13 
5 
2 
3 
5 

1110 
14 
6 
1 
2 
6 

1111 
15 
7 
0 
1 
7 
Biased looks like "two's complement with the sign backwards"
Arithmetic doesn't work, but adding unsigned to biased to get biased does.
Used in floating point representations in the exponent portion.