Transcript The Octal Number System

Compiled by :
S. Agarwal, Lecturer & Systems Incharge
St. Xavier’s Computer Centre,
St. Xavier’s College
Kolkata.
March-2003
Introduction
A number system defines a set of values used to represent
quantity. We talk about the number of people attending class, the
number of modules taken per student, and also use numbers to
represent grades achieved by students in tests.
Quantifying values and items in relation to each other is helpful
for us to make sense of our environment. We do this at an early
age; figuring out if we have more toys to play with, more presents,
more lollies and so on.
The study of number systems is not just limited to computers. We
apply numbers every day, and knowing how numbers work will
give us an insight into how a computer manipulates and stores
numbers.
The Romans devised a number system which could
represent all the numbers from 1 to 1,000,000 using only
seven symbols
•I = 1
•V = 5
•X = 10
•L = 50
•C = 100
•D = 500
•M = 1000
A small bar placed above a symbol indicates the number
is multiplied by 1000.
The Decimal Number System
The primary number system used is a base ten number
system. Base ten number systems are called decimal
number systems. In decimal we have ten numerals, 0, 1,
2, 3, 4, 5, 6, 7, 8, and 9.
Counting in decimal:
When we count, we start at 1 and count up to 9. The next
number is 10. That is, we create a place for the tens digit
and put zero in the ones position. We continue to count by
adding one to the ones place until we run out of digits
again at 19. Then we reset the ones place to zero and
increment the tens place to get 20. We continue in this
way until we reach 99. At that point we create a third
digit to hold hundreds and reset the tens and ones place to
zero to get 100. And so on. Each time we change a digit,
all the digits to its right are set to zero. So the number
after 299 is 300, with zeros to the right of the 3.
9000
9 * 1000
9 * 103
+ 700
7 * 100
7 * 102
9735 =
is equivalent to
is equivalent to
+ 30
3 * 10
3 * 101
+5
5*1
5 * 100
So 9735 = (9 * 103) + (7 * 102) + (3 * 101) + (5 * 100).
The Octal Number System
We can use a number system with only eight numerals,
0 through 7.
A system with only eight numerals is called octal.
Counting in Octal
In octal, instead of ten digits, we only have eight. So we
resort to changing the digits to the left more frequently.
Counting in base 8, we get:
0 1 2 3 4 5 6 7
10 11 12 13 14 15 16 17
20 21 22 23 24 25 26 27
Since the octal number 10 follows 7, 10 in octal is 8 in
decimal. 11 in octal is 9 in decimal. And so on.
octaldecimal
0-0
octaldecimal
10 - 8
octaldecimal
20 - 16
1-1
11 - 9
2-2
3-3
octaldecimal
octaldecimal
70 - 56
octaldecimal
100 - 64
21 - 17
71 - 57
101 - 65
12 - 10
22 - 18
72 - 58
102 - 66
13 - 11
23 - 19
73 - 59
103 - 67
...
octaldecimal
...
4-4
14 - 12
24 - 20
74 - 60
104 - 68
5-5
15 - 13
25 - 21
75 - 61
105 - 69
6-6
16 - 14
26 - 22
76 - 62
106 - 70
7-7
17 - 15
27 - 23
77 - 63
107 - 71
Octal Digit Positions and Values
In base 8, each digit occupies a position worth eight times the position
to its right, instead of ten times as in base 10. So if 5732 is an octal
number, it can be read as:
5732 = 5000 (octal) =
5 * 1000 (octal) =
5 * 83 =
5 * 512 (decimal) =
2560 (decimal)
+ 700 (octal) =
7 * 100 (octal) =
7 * 82 =
7 * 64 (decimal) =
448 (decimal)
+ 30 (octal) =
3 * 10 (octal) =
3 * 81 =
3 * 8 (decimal) =
24 (decimal)
+ 2 (octal) =
2 * 1 (octal) =
2 * 80 =
2 * 1 (decimal) =
2 (decimal)
Total = 3034 (decimal)
We total the decimal values of each octal digit to get the decimal
equivalent. So 5732 (octal) is 3034 (decimal).
To convert a decimal number to octal, we simply repeat
dividing by 8 and saving the remainder.
To convert 3034 in decimal to octal, start by dividing 3034 by 8 to
get 379 with a remainder of 2.
The first remainder will be the last digit in the octal number; the
second remainder will be the second digit from the right; and so
on. That is, all we need to do is write the remainders right-to-left
as we divide by 8:
Step Divide Equals
Remainder
Digits
(1)
3034 / 8 =
379
2
2
(3)
379 / 8 =
47
3
32
(5)
47 / 8 =
5
7
732
(6)
5/8=
0
5
5732
The Hexadecimal Number System
We can use a number system with sixteen
numerals. A base 16 number system is call
hexadecimal or just hex.
We can use our usual 0 through 9 for the first
ten digits, then use the letters A for 10, B for
11, C for 12, D for 13, E for 14 and F for 15.
Counting in Hexadecimal
In hexadecimal, we count the same same way we did in
decimal and octal. But instead of ten digits or eight digits, we
have sixteen, 0-9, A-F. So we resort to changing the digits to
the left less frequently than in decimal or octal.
Counting in base 16, we get:
0 1 2 3 4 5 6 7 8 9 A B C D E F
10 11 12 13 14 15 16 17 18 19 1A 1B 1C 1D 1E 1F
20 21 22 23 24 25 26 27 28 29 2A 2B 2C 2D 2E 2F
Since the hex number A follows 9, A in hex is 10 in decimal. B in hex is
11 in decimal. After F in hex (15 in decimal) we have 10 (16 in decimal).
And so on.
hex-dec hex-dec hex-dec hex-dec hex-dec
hex-dec hex-dec
0-0
10 - 16 20 - 32
F0 - 240 100 - 256
1-1
11 - 17 21 - 33
F1 - 241 101 - 257
2-2
12 - 18 22 - 34
F2 - 242 102 - 258
3-3
13 - 19 23 - 35
F3 - 243 103 - 259
4-4
14 - 20 24 - 36
F4 - 244 104 - 260
5-5
15 - 21 25 - 37
F5 - 245 105 - 261
6-6
16 - 22 26 - 38
F6 - 246 106 - 262
7-7
17 - 23 27 - 39
F7 - 247 107 - 263
...
...
8-8
18 - 24 28 - 40
F8 - 248 108 - 264
9-9
19 - 25 29 - 41
F9 - 249 109 - 265
A - 10 1A - 26 2A - 42
FA - 250 10A - 266
B - 11 1B - 27 2B - 43
FB - 251 10B - 267
C - 12 1C - 28 2C - 44
FC - 252 10C - 268
D - 13 1D - 29 2D - 45
FD - 253 10D - 269
E - 14 1E - 30 2E - 46
FD - 253 10D - 269
F - 15 1F - 31 2F - 48
FF - 255 10F - 271
Hex Digit Positions and Values
In base 16, each digit occupies a position worth sixteen times the
position to its right, instead of ten times as in base 10 or eight times
as in octal. So if 3F72 is an hex number, it can be read as:
3F72 = 3000 (hex) =
3 * 1000 (hex) =
3 * 163 =
3 * 4096 (decimal) =
12288 (decimal)
+ F00 (hex) =
F * 100 (hex) =
15 * 162 =
15 * 256 (decimal) =
3840 (decimal)
+ 70 (hex) =
7 * 10 (hex) =
7 * 161 =
7 * 16 (decimal) =
112 (decimal)
+ 2 (hex) =
2 * 1 (hex) =
2 * 160 =
2 * 1 (decimal) =
2 (decimal)
Total = 16242 (decimal)
We total the decimal values of each hex digit to get the decimal equivalent.
So 3F72 (hex) is 16242 (decimal).
Converting Decimal to Hex
We can convert a decimal to hex using the same procedure we
used to convert decimal to octal. The only difference is that we
divide by 16 each time since we are working in base 16.
In the following steps we convert 16242 from decimal to hex:
Step
Divide
Equals
Remainder
Digits
(1)
16242 / 16 =
1015
2 = 2 (hex)
2
(2)
1015 / 16 =
63
7 = 7 (hex)
72
(3)
63 / 16 =
3
15 = F (hex)
F72
(4)
3 / 16 =
0
3 = 3 (hex)
3F72
So 16242 in decimal is written as 3F72 in hex.
The Binary Number System
The base 2 number system, called binary is
based on powers of 2 and contains only two
digits, 0 and 1.
01001001010101110101010001010101101
10101010000000111101010101011111010
Counting in Binary
With only two numerals, 1 (one) and 0 (zero),
counting in binary is pretty simple. Just keep in
mind the following:
•0 + 0 = 0
•0 + 1 = 1
•1 + 0 = 1
•1 + 1 = 10
•1 + 1 + 1 = 11
We we would count in binary as follows:
bin-dec
bin-dec
bin-dec
bin-dec
0-0
1000 - 8
10000 - 16
11000 - 24
1-1
1001 - 9
10001 - 17
11001 - 25
10 - 2
1010 - 10
10010 - 18
11010 - 26
11 - 3
1011 - 11
10011 - 19
11011 - 27
100 - 4
1100 - 12
10100 - 20
11100 - 28
101 - 5
1101 - 13
10101 - 21
11101 - 29
110 - 6
1110 - 14
10110 - 22
11110 - 30
111 - 7
1111 - 15
10111 - 23
11111 - 31
Binary Digit Positions and Values
In base 2, each digit occupies a position worth two
times the position to its right, instead of ten times as in
base 10, eight times as in octal, or 16 as in hex. So if
1101001 is a binary number, it can be read as:
1101001 = 1000000 (bin) = 1 * 26 = 1 * 64 (decimal) = 64 (decimal)
+ 100000 (bin) =
+ 00000 (bin) =
1 * 25 = 1 * 32 (decimal) = 32 (decimal)
0 * 24 = 0 * 16 (decimal) =
0 (decimal)
+ 1000 (bin) = 1 * 23 =
1 * 8 (decimal) =
8 (decimal)
+ 000 (bin) =
0 * 22 =
0 * 4 (decimal) =
0 (decimal)
+ 00 (bin) =
0 * 21 =
0 * 2 (decimal) =
0 (decimal)
+ 1 (bin) =
1 * 20 =
1 * 1 (decimal) =
1 (decimal)
TOTAL = 105 (decimal)
We total the decimal values of each binary digit to get the decimal
equivalent. So 1101001 (binary) is 105 (decimal).
Converting Decimal to Binary
We can convert a decimal to binary by dividing by 2 each
time since we are working in base 2. In the following steps
we convert 105 from decimal to binary:
Step
(1)
(2)
(3)
(4)
(5)
(6)
(7)
Divide
105 / 2 =
52 / 2 =
26 / 2 =
13 / 2 =
6/2=
3/2=
1/2=
Equals
Remainder
52
26
13
6
3
1
0
1
0
0
1
0
1
1
Digits
1
01
001
1001
01001
101001
1101001
So 105 in decimal is written as 1101001 in binary.
Converting Between Hex, Octal and Binary
Converting between binary, octal and hex is simple.
Binary is base 2. Octal is base 8, and 8 is 23. That is, it takes
exactly three binary digits to make one octal digit. If we line up
the binary numbers and octal numbers, the connection is even more
obvious:
bin-octal-dec
bin-octal-dec
bin-octal-dec
bin-octal-dec
0-0-0
1000 - 10 - 8
10000 - 20 - 16
11000 - 30 - 24
1-1-1
1001 - 11 - 9
10001 - 21 - 17
11001 - 31 - 25
10 - 2 - 2
1010 - 12 - 10
10010 - 22 - 18
11010 - 32 - 26
11 - 3 - 3
1011 - 13 - 11
10011 - 23 - 19
11011 - 33 - 27
100 - 4 - 4
1100 - 14 - 12
10100 - 24 - 20
11100 - 34 - 28
101 - 5 - 5
1101 - 15 - 13
10101 - 25 - 21
11101 - 35 - 29
110 - 6 - 6
1110 - 16 - 14
10110 - 26 - 22
11110 - 36 - 30
111 - 7 - 7
1111 - 17 - 15
10111 - 27 - 23
11111 - 37 - 31
What this means is that we can convert from binary
to octal simply by taking the binary digits in groups
of three and converting. Consider the binary
number 10110100111100101101001011. If we take
the digits in groups of three from right to left and
convert, we get:
10 110 100 111 100 101 101 001 011
2 6
4 7 4 5 5 1 3
That is, 10110100111100101101001011 (binary) is
264745513 (octal).
Converting from octal to binary is just as easy. Since each
octal digit can be expressed in exactly three binary digits,
all we have to do is convert each octal digit to three binary
digits. Converting 7563021 in octal to binary goes as
follows:
7
5
6
3
0
2
111
101
110
011
000
010
1
001
So 7563021 (octal) is 111101110011000010001 (binary.)
Since (almost!) all computers have a
binary architecture, octal is very useful to
programmers. For humans, octal is more
concise, smaller, easier to work with, and
less prone to errors than binary. And since
it is so easy to convert between binary and
octal, octal is a favored number system for
programmers.
In the same way, hex is base 16 and 16 is 24. That is, it
takes exactly four binary digits to make a hex digit. By
taking binary digits in groups of four (right to left) we
can convert binary to hex. Consider once more the binary
number 10110100111100101101001011. By grouping in
fours and converting, we get:
10
2
1101
D
0011
3
1100
C
1011
B
0100 1011
8
B
So 10110100111100101101001011 (binary) is the
same number as 2D3CB8B (hex), and the same
number as 264745513 (octal).
Converting from hex to binary, simply write each hex digit
as four binary digits. In this way we can convert 6F037C2:
6
0110
F
1111
0
0000
3
0011
7
0111
C
1100
2
0010
Since we can drop the leading zero,
6F037C2 (hex) is 110111100000011011111000010 (binary).
These days, octal tends to be used by
programmers who come from a minicomputer background or who work with
unicode. Hex tends to be preferred by
programmers with a mainframe background
or who work with colors. Many
programmers are at home with either.
nibble
In computers and digital technology, a nibble is
four binary digits or half of an eight-bit byte.
Maximum number in a nibble :
1111 = 15
A nibble can be conveniently represented by one
hexadecimal digit.
BCD
Binary-coded decimal, or BCD, is a method of
using binary digits to represent the decimal digits
0 through 9. A decimal digit is represented by four
binary digits, as shown below:
The binary combinations
1010 to 1111 are invalid and
are not used.
UNPACKED & PACKED BCD
In unpacked BCD, a decimal digit is stored in one byte and in
packed BCD, four bits are used to keep one digit, so two digits
are stored in one byte, one in the lower half and one in the
upper half of the byte.
BCD and binary are not the same.
For example, 4910 in binary is 1100012,
but 4910 in BCD is 01001001BCD.
4
9
0100 1001 = 01001001BCD (PACKED BCD)
Each decimal digit is converted to its binary equivalent.
BCD Conversion
Conversion of decimal to BCD or BCD to decimal is similar to
the conversion of hexadecimal to binary and vice versa.
For example, let's go through the conversion of 26410 to BCD.
We'll use the block format that you used in earlier conversions.
First, write out the decimal number to be converted; then, below
each digit write the BCD equivalent of that digit:
The BCD equivalent of 26410 is 001001100100BCD
To convert from BCD to decimal, simply reverse
the process as shown:
The DECIMAL equivalent of 100110000011BCD
is 98310
ASCII Code
ASCII, pronounced "ask-key", is the common code for
microcomputer equipment. The standard ASCII
character set consists of 128 decimal numbers ranging
from zero through 127 assigned to letters, numbers,
punctuation marks, and the most common special
characters.
The Extended ASCII Character Set also consists of
128 decimal numbers and ranges from 128 through 255
representing additional special, mathematical, graphic,
and foreign characters.
The Standard ASCII character set is divided into four
groups of 32 characters.
The first 32 characters, form a special set of nonprinting characters called the control characters. We call
them control characters because they perform various
printer/display control operations rather than displaying
symbols.
Examples of common control characters include:
•carriage return which positions the cursor to
the left side of the current line of characters,
•line feed which moves the cursor down one
line on the output device
•back space which moves the cursor back one
position to the left
Unfortunately, different control characters perform different
operations on different output devices. There is very little
standardization among output devices. To find out exactly
how a control character affects a particular device, you will
need to consult its manual.
The second group of 32 ASCII character codes
comprise various punctuation symbols, special
characters, and the numeric digits. The most notable
characters in this group include the:
•space character
•numeric digits 0 through 9
Note that the numeric digits differ from their numeric
values only in the high order nibble. By subtracting
30h from the ASCII code for any particular digit you
can obtain the numeric equivalent of that digit.
The third group of 32 ASCII characters is
reserved for the upper case alphabetic characters.
The ASCII codes for the characters "A" through "Z"
lie in the range 41h through 5Ah. Since there are
only 26 different alphabetic characters, the
remaining six codes hold various special symbols.
The fourth, and final, group of 32 ASCII
character codes are reserved for the lower case
alphabetic symbols, five additional special symbols,
and another control character (delete).
ISCII
Indian Script Code for Information Interchange
The
ISCII code table is a super-set of
all the characters required in the ten Brahmi-based
Indian scripts.
An optimal keyboard overlay for these scripts
is made possible by the phonetic nature of the
alphabet. The differences between scripts primarily are
in their written forms, where different combination
rules get used.
The 8-bit ISCII code retains the standard ASCII
code, while the Indian script keyboard overlay is
designed for the standard English can co-exist with
Indian scripts.
This approach also makes it feasible to use Indian
scripts along with existing English computers and
software, so long as 8-bit character codes are allowed.
The common INSCRIPT keyboard overlay allows
typing of all the ten Indian scripts. This overlays
fits on any existing English keyboard. Alternating
between the English and Inscript overlay is achieved
through the CAPSLOCK key.
The
INSCRIPT
keyboard,
provides
a logical and intuitive arrangement of vowels and
consonants.
It is based both
on
the
phonetic
properties
and the relative usage
frequencies of the letters. Not only does this made the
keyboard much easier to learn, but also enables a person
to type subsequently in all the Indian scripts.
EBCDIC
Extended Binary Coded Decimal Interchange Code
It is an 8 bit character encoding used on IBM mainframes and
AS/400s. It is descended from punched cards and the corresponding
six bit Binary Coded Decimal Code that most of IBM's computer
peripherals of the late 1950s and early 1960s used. Outside of such
IBM systems, ASCII are normally used instead; EBCDIC is
generally considered an anachronism.
EBCDIC takes up eight bits, which are divided in two pieces. The
first four bits are called the zone and represent the category of the
character, whereas the last four bits are the called the digit and
identify the specific character. There are a number of different
versions of EBCDIC, customised for different countries.
The Binary Addition Algorithm
To add two 1-bit (representations of) integers: Count the number of
ones in a column and write the result in binary. The right bit of the
result is placed under the column of bits. The left bit is called the
"carry out of the column".
0 0 1 1
0 1 0 1
--- --- --- --0 01 01 10
1 1 1 1 0 0 0 0
1 0 1 0 1 0 1 0
1 1 0 0 1 1 0 0
--- --- --- --- --- --- --- --11 10 10 01 10 01 01 00
A
0
0
1
1
B
0
1
0
1
Carry
Digit
0
0
0
1
Unit
Digit
0
A
B
C
CARRY
UNIT
0
0
0
0
0
0
0
1
0
1
0
1
0
0
1
0
1
1
1
0
1
0
0
0
1
1
0
1
1
0
1
1
0
1
0
1
1
1
1
1
1
1
0
Signed Binary Integers
We will not be using a minus sign (-) to represent negative
numbers. We would like to represent our binary numbers with
only two symbols, 0 and 1. There are a few ways to represent
negative binary numbers. The simplest of these methods is called
ones complement, where the sign of a binary number is changed
by simply toggling each bit (0's become 1's and vice-versa). This
has some difficulties, among them the fact that zero can be
represented in two different ways (for an eight bit number these
would be 0000 0000 and 1111 1111)., we will use a method called
two's complement notation which avoids the pitfalls of one's
complement.
To represent an n bit signed binary number the leftmost bit, has a
special significance. The difference between a signed and an
unsigned number is given in the table below for an 8 bit number.
The value of bits in signed and unsigned binary numbers
Bit 7
Unsi 7
2 = 128
gned
Bit 6 Bit 5 Bit 4 Bit 3 Bit 2 Bit 1 Bit 0
26 = 64 25 = 32 24= 16 23= 8
22 = 4
21 = 2
20 = 1
Sign
-(27) = -128 26 = 64 25 = 32 24 = 16 23 = 8
ed
22 = 4
2 1= 2
20 = 1
Let's look at how this changes the value of some binary numbers
Binary
Unsigned
Signed
0010 0011
35
35
1010 0011
163
-93
1111 1111
255
-1
1000 0000
128
-128
If Bit 7 is not set (as in the
first
example)
the
representation of signed
and unsigned numbers is
the same. However, when
Bit 7 is set, the number is
always negative. For this
reason Bit 7 is sometimes
called the sign bit.
NEGATIVE BINARY NUMBER
Usually we represent a negative decimal number by placing a
minus sign directly to the left of the most significant digit, just as
in the example above, with -5. Since binary uses only 0 & 1, we
don't have a third symbol such as a "minus" sign, since these
circuits can only be on or off (two possible states). One solution is
to reserve a bit (circuit) that does nothing but represent the
mathematical sign:
. 1012 = 510 (positive)
.
. Extra bit, representing sign (0=positive, 1=negative)
.
|
.
01012 = 510 (positive)
.
. Extra bit, representing sign (0=positive, 1=negative)
.
|
.
11012 = -510 (negative)
There's another method for representing negative numbers
called complementation. With this strategy, we assign the
leftmost bit to serve a special purpose, just as we did with the
sign-magnitude approach, defining our number limits just as
before. However, this time, the leftmost bit is more than just a
sign bit; rather, it possesses a negative place-weight value.
For example, a value of negative five would be represented as
such:
Extra bit, place weight = negative eight
.
|
.
10112 = 510 (negative)
.
. (1 x -810) + (0 x 410) + (1 x 210) + (1 x 110) = -510
With the right three bits being able to represent a magnitude from
zero through seven, and the leftmost bit representing either zero or
negative eight, we can successfully represent any integer number
from negative seven (10012 = -810 + 710 = -110) to positive seven
(01112 = 010 + 710 = 710).
Examples ….
zero 0000
positive one 0001 negative one 1111
positive two 0010 negative two 1110
positive three 0011 negative three 1101
positive four 0100 negative four 1100
positive five 0101 negative five 1011
positive six 0110 negative six 1010
positive seven 0111 negative seven 1001 .
Note that the negative binary numbers in the right column,
being the sum of the right three bits' total plus the negative
eight of the leftmost bit, don't "count" in the same progression
as the positive binary numbers in the left column. Rather, the
right three bits have to be set at the proper value to equal the
desired (negative) total when summed with the negative eight
place value of the leftmost bit.
The two’s complement :
The two's complement for any positive binary number
will be whatever value is needed to add to the binary
number to make that positive value's negative
equivalent.
To get the two’s complement, simply invert all the bits
of that number, changing all 1's to 0's and visa-versa
(to arrive at what is called the one's complement)
and then add one!
For example, to obtain the two's complement of five
(1012), we would first invert all the bits to obtain
0102 (the "one's complement"), then add one to
obtain
0112,
or
-510
in
three-bit,
two's
complement form.
Interestingly enough, generating the two's
complement of a binary number works the same if
you manipulate all the bits, including the leftmost
(sign) bit at the same time as the magnitude bits.
Let's try this with the former example, converting
a positive five to a negative five, but performing
the complementation process on all four bits. We
must be sure to include the 0 (positive) sign bit on
the original number, five (01012). First, inverting
all bits to obtain the one's complement: 10102.
Then, adding one, we obtain the final answer:
10112, or -510 expressed in four-bit, two's
complement form.
It is critically important to remember that the place
of the negative-weight bit must be already
determined
before
any
two's
complement
conversions can be done. If our binary numeration
field were such that the eighth bit was designated as
the negative-weight bit (100000002), we'd have to
determine the two's complement based on all seven
of the other bits. Here, the two's complement of five
(00001012) would be 11110112. A positive five in
this system would be represented as 000001012,
and a negative five as 111110112.
Subtraction
We can subtract one binary number from another by
using the standard techniques adapted for decimal
numbers (subtraction of each bit pair, right to left,
"borrowing" as needed from bits to the left). However,
if we can leverage the already familiar (and easier)
technique of binary addition to subtract, that would be
better. As we just learned, we can represent negative
binary numbers by using the "two's complement"
method and a negative place-weight bit. Here, we'll
use those negative binary numbers to subtract
through addition.
Subtraction: 710 - 510
Addition equivalent: 710 + (-510)
Represent seven and negative five in binary (two's complemented)
form, all we need is three bits plus the negative-weight bit:
positive seven = 01112 negative five = 10112
Now, let's add them together:
.
1111 <--- Carry bits
.
0111
. + 1011
.
-----.
10010
.
|
.
Discard extra bit
.
. Answer = 00102
Since
we've
already
defined our number bit
field as three bits plus the
negative-weight bit, the
fifth bit in the answer (1)
will be discarded to give us
a result of 00102, or
positive two, which is the
correct answer.
Another example : add -2510 to 1810
If we want to add -2510 to 1810, we must first decide how large our binary bit
field must be. To represent the largest (absolute value) number in our problem,
which is twenty-five, we need at least five bits, plus a sixth bit for the negativeweight bit.
+2510 = 0110012 (showing all six bits)
One's complement of 110012 = 1001102
One's complement + 1 = two's complement = 1001112
-2510 = 1001112
Essentially, we're representing negative twenty-five by using the negative-weight (sixth)
bit with a value of negative thirty-two, plus positive seven (binary 1112).
Now, let's represent positive eighteen in binary form, showing all six bits:
. 1810 = 0100102
.
. Now, let's add them together
.
11 <--- Carry bits
.
100111
.
+ 010010
.
-------.
111001
Since there were no "extra" bits on the left, there
are no bits to discard. The leftmost bit on the
answer is a 1, which means that the answer is
negative, in two's complement form, as it should
be. Converting the answer to decimal form by
summing all the bits times their respective weight
values, we get:
(1 x -3210) + (1 x 1610) + (1 x 810) + (1 x 110)
= -710
Overflow
One problrm with signed binary numbers is that of overflow,
where the answer to an addition or subtraction problem exceeds
the magnitude which can be represented with the alloted
number of bits. Remember that the place of the sign bit is fixed
from the beginning of the problem. With the last example
problem, we used five binary bits to represent the magnitude of
the number, and the left-most (sixth) bit as the negativeweight, or sign, bit. With five bits to represent magnitude, we
have a representation range of 25, or thirty-two integer steps
from 0 to maximum. This means that we can represent a
number as high as +3110 (0111112), or as low as -3210
(1000002). If we set up an addition problem with two binary
numbers, the sixth bit used for sign, and the result either
exceeds +3110 or is less than -3210, our answer will be
incorrect.
Let's try adding 1710 and 1910 to see how this overflow condition
works for excessive positive numbers:
. 1710 = 100012 1910 = 100112
.
.
1 11 <--- Carry bits
. (Showing sign bits) 010001
.
+ 010011
.
-------.
100100
The answer (1001002), interpreted with the sixth bit as the -3210
place, is actually equal to -2810, not +3610 as we should get with
+1710 and +1910 added together!
The answer (1001002), interpreted with the sixth
bit as the -3210 place, is actually equal to -2810, not
+3610 as we should get with +1710 and +1910
added together! Obviously, this is not correct.
What went wrong? The answer lies in the
restrictions of the six-bit number field within which
we're working Since the magnitude of the true and
proper sum (3610) exceeds the allowable limit for
our designated bit field, we have an overflow error.
Simply put, six places doesn't give enough bits to
represent the correct sum, so whatever figure we
obtain using the strategy of discarding the leftmost "carry" bit will be incorrect.
A similar error will occur if we add two negative numbers together to
produce a sum that is too low for our six-bit binary field. Let's try adding
-1710 and -1910 together to see how this works (or doesn't work, as the
case may be!):
. -1710 = 1011112 -1910 = 1011012
.
.
1 1111 <--- Carry bits
. (Showing sign bits) 101111
.
+ 101101
.
-------.
1011100
.
|
.
Discard extra bit
FINAL ANSWER: 0111002 = +2810
The (incorrect) answer is a positive twenty-eight. The fact that the real
sum of negative seventeen and negative nineteen was too low to be
properly represented with a five bit magnitude field and a sixth sign bit
is the root cause of this difficulty.
Let's try these two problems again, except this time using the seventh bit
for a sign bit, and allowing the use of 6 bits for representing the
magnitude:
.
.
.
.
.
.
.
.
.
.
.
1710 + 1910
1 11
0010001
+ 0010011
--------0100100
ANSWERS: 01001002 = +3610
(-1710) + (-1910)
11 1111
1101111
+ 1101101
--------11011100
|
Discard extra bit
10111002 = -3610
By using bit fields sufficiently large to handle the magnitude of the sums,
we arrive at the correct answers.
In these sample problems we've been able to detect overflow errors by
performing the addition problems in decimal form and comparing the
results with the binary answers. For example, when adding +1710 and
+1910 together, we knew that the answer was supposed to be +3610, so
when the binary sum checked out to be -2810, we knew that something
had to be wrong. Although this is a valid way of detecting overflow, it is
not very efficient. After all, the whole idea of complementation is to be
able to reliably add binary numbers together and not have to doublecheck the result by adding the same numbers together in decimal form!
What we need is a simple error-detection method that doesn't require
any additional arithmetic. Perhaps the most elegant solution is to check
for the sign of the sum and compare it against the signs of the numbers
added. Obviously, two positive numbers added together should give a
positive result, and two negative numbers added together should give a
negative result. Notice that whenever we had a condition of overflow in
the example problems, the sign of the sum was always opposite of the
two added numbers: +1710 plus +1910 giving -2810, or -1710 plus -1910
giving +2810.
By checking the signs alone we are able to tell that something is wrong.