The largest has a 0 in the sign position and 0's in all other positions:

Transcription

1 10.2 Sign Magnitude Representation Sign Magnitude is straight-forward method for representing both positive and negative integers. It uses the most significant digit of the digit string to indicate the sign of the number and the rest of the digits to represent its magnitude. This means, of course, that every number represented in this fashion has one more digit--the sign digit--than the conventional number. Let us agree that a 0 in the sign position means that the number is positive. We indicate a negative by the digit resulting from the subtraction of 1 from the base of the original number. We will see later that this decision has consequences for other representation schemes. But for now, (+907) 10 = (0907) 10 (-907) 10 = (9907) 10 (+605) 8 = (0605) 8 (-605) 8 = (7605) 8 (+101) 2 = (0101) 2 (-101) 2 = (1101) 2 Suppose we are using a 16 bit word to store positive and negative numbers in sign magnitude representation. What is the largest and smallest integer that we can accomodate? The smallest has a 1 in the sign position and 1's in all other positions: ( ) 2 = ( ) 2 = (-32767) 10 The largest has a 0 in the sign position and 0's in all other positions: ( ) 2 = ( ) 2 = (+32767) 10 Although sign magnitude representation of numbers is straight forward it has two significant drawbacks. First, there are two ways to represent the number zero. There can be a positive zero and a negative zero. Second, the computer hardware necessary to do sign magnitude arithmetic is more complicated and,

2 consequently, more expensive than that necessary to perform arithmetic on numbers stored in other representations Complement Representation The additive inverse of a number is the number which, when added to the original number will result in the value zero. For example, the additive inverse of 23 is -23 because 23 + (-23) = 0. So the negation of a number is its additive inverse. The fact that the size of numbers that a computer can represent is limited by the number of bits allocated to its representation has interesting consequences for additive inverses. Consider what would happen if we were to add (433) 10 and (567) 10 on a calculator which only handled numbers up to three digits long (1) 000 no digit in which to store the carry The result is zero, so if we limit ourselves to three digits, 567 is the additive inverse of 433. That is, when 567 is added to 433 it produces a zero. The opposite, of course, is also true. In this three digit system the additive inverse of 1 is 999. So, as long as we restrict ourselves to three digits: = = 999 Recall that when we developed sign magnitude representation we said that any positive number has a 0 in the most significant digit position and that any negative number has (base - 1) in that position. So that we are consistent with how we defined positive and negative numbers in sign magnitude representation, let us put the sign digit back in. By necessity, we have to modify our calculator has to handle four digits. Now we are looking for the additive inverse of (0433) 10 in four digits. That is, what number when added to 0433 will produce 0's in all four positions as well as a carry into the fifth position (that will then be lost)?

3 (1)0000 So, 9567 is the additive inverse of 0433 when using four digits. Notice that 9567, a negative number, has a 9 in the most significant digit position. This is consistent with how we have defined the sign of a negative number: base - 1. In this case, the base is 10. The additive inverse in base 10 when restricted to a fixed number of digits is called the 10's complement. It can be generalized to numbers in any base, B. To find the B's complement of a number, subtract the number whose complement you want to find from the base raised to the number of digits you have to work with. Formally, we define the B's complement like this: (N') B = B D - (N) B where: (N) B is the number whose complement you want to find (N') B is the complement B is the base D is the number of digits you are working with, including the sign digit Using this technique, the complement of 150 base 10 in four digits is given by: N' = = 's Complement Representation Though we can do complement arithmetic in any base, it is binary arithmetic using 2's complement representation that is most of interest to us. To keep things simple, imagine that we are working with a four bit computer. These are the positive integers we can represent using three magnitude bits and a sign bit: Decimal Binary

4 Now, let's take the complement of these: At this point a pattern should be emerging that could save us a lot of work. Notice that in every case the complement and the original number are identical from left to right until you pass the first 1 of the original number. At that point, all the digits are opposite. The complement of 0010, for example, is This of course, is a consequence of binary arithmetic. Beginning from the left, subtracting a 0 from a 0 produces a 0. Thus all 0's in the original number remain 0's in the complement until you encounter the first 1. When this happens, subtracting a 1 from a 0 results in a borrow from the next column. So, 1 from 10 in binary is 1. The column after the first borrow occured is where the changes begin. We borrowed from this column, but this column originally had a 0 in it. So this column was forced to borrow from the column to its left and so on. Once this column borrowed

5 successfully, it became 10. But, of course, the column to its right borrowed from it and so changed it to 1. Now, if the number in the original column is 1, subtracting it from 1 produces a 0. If the number in the original column is 0, subtracting it produces 1. Here is the algorithm to find the 2's complement of a number: 1. Leave the 0's before the least significant 1 untouched. 2. Leave the least significant 1 untouched. 3. After the least significant 1, change 0's to 1's and 1's to 0's. Students often confuse 2's Complement as a representation scheme with taking the 2's complement of a number. As a representation scheme, 2's Complement is a set of numbers. The number of members in this set depends on how many digits we have to work with. Taking the 2's complement of a number is act of applying the algorithm just described. Thus there are positive 2's Complement numbers as well as negative 2's Complement numbers and we can find the 2's complement of each of them. Clearly, finding the 2's complement of a positive 2's Complement number produces its additive inverse, a negative 2's complement number. This scheme would not be consistent with the laws of arithmetic if the opposite were not true: finding the 2's complement of a negative 2's complement number produces the positive 2's complement number. For example, 0111, is a positive 2's complement number. Its complement is Now using the algorithm above, the complement of 1001 is 0111 as predicted. Here is the table of binary numbers and their complements using four bits. Decimal Binary 2's Complement

6 Using 2's Complement representation and four bits, we can represent numbers from -8 to +7 in base 10. Can you see why there is no 2's Complement representation for +8 base 10 in four bits. This is an improvement over sign magnitude representation for two reasons. First, there is a single representation for 0. Second, 2's Complement is a positional number scheme not a code. To convince yourself of this. Try adding -5 and +2 in 2's Complement representation: is -3 in 2's Complement, just as we would expect Storing Characters Although we can store signed and unsigned numbers to varying degrees of precision on a computer, this is not the end of the story. A computer manipulates textual data as well. This text, for instance, is being written using a word processor on a microcomputer. Somehow, the letters and punctuation symbols, as typed are transformed into strings of 1's and 0's and stored in the computer. Clearly, these letters and punctuation symbols--let's call them "characters"--are encoded and then decoded when the time comes to print the document out. The only real requirement for an encoding scheme is that it be unambiguous. If we assign a string of bits

7 to a letter, we cannot assign that same string of bits to another letter. One encoding scheme that fulfills this requirement is ASCII, and acronym for American Standard Code for Information Interchange. ASCII is a seven bit code. It represents character data as strings of seven 1's and 0's. This means that we can use ASCII to encode 2 7 different characters. These 128 characters are shown in the ASCII table handed out in class. The table has four groups of three columns. The leftmost column shows hexadecimal code for a given character. IF we translate this to binary and ignore the most significant bit, we will have the actual string of 1's and 0's stored in memory. The middle column shows the decimal equivalent of the hexadecimal code. The rightmost column shows the character that the hexadecimal code represents. For example, find decimal code 84 in the third group of columns. The hexadecimal code here is 54. Since (54) 16 = (84) 10, we can see that the decimal code is listed for convenience only. The binary eqivalent of hexadecimal 54 is The least significant seven bits of this binary number is the ASCII code for upper case "T". The characters encoded through ASCII are: 26 upper case alphabetic characters 26 lower case alphabetic characters 32 punctuation and miscellaneous symbols 10 numeric characters 34 control characters Notice that the binary code for each of the alphabetic characters is one greater than that of the preceding character. For example, the upper case characters range from hex 41 for "A" through hex 5A for "Z". The actual ASCII codes are through This means that sorting operations on alphbetic data can be done using arithmetic operations: "A" comes before "B" and comes before Notice also the relationship between the codes for upper and lower case alphabetic characters: Character Hex Code Character Hex Code A 41 a 61 B 42 b 62

8 Y 59 y 79 Z 5A z 7A Since ASCII encodings are just strings of 1's and 0's, they can be treated as binary numbers. We can, therefore, translate from upper case to lower case by adding (20) 16 to the upper case character. But let's look more closely. The following table shows not just the hexadecimal code, but its binary equivalent. Character Hex Binary Character Hex Binary A a B b Y y Z 5A z 7A Notice that the upper case letter differs from the lower case equivalent in the fifth bit where the least significant bit is designated the zeroth. So, we can convert from upper case to lower case by changing the fifth bit from 0 to 1. We can convert from lower to upper case by changing the fifth bit from 1 to 0. It is important not to be misled by the ASCII representations of the numeric characters. These are codes, not numbers. They are used for encoding numbers on which computations will not be performed. Finally, the control characters are used to send messages to hardware devices. Hex 0D, for example, is the encoding for a carriage return character. When an output device encounters this character, it begins to display text on the next line. Because ASCII is a seven bit code, we can store one ASCII encoded character in a byte. We will discuss a possible use to which the most significant bit might be put in the next section. For now, assume it is a zero. Here is the ASCII encoding for the "computer" starting at hexadecmial address : Address Character Hex Code As Stored

9 "c" "o" 6F "m" 6D "p" "u" "t" "e" "r"

10