The Representation of Numbers on the Computer (Brief Version- 01/23/2004)

Transcription

1 0. Introduction The Representation of Numbers on the Computer (Brief Version- 01/23/2004) Brian J. Shelburne Dept of Mathematics and Computer Science Wittenberg University The development of the computer was driven by the need to mechanize arithmetic; that is, to construct a machine that would perform arithmetic quickly and accurately and thereby speed the solution of calculation intensive problems. But if arithmetic was to be performed by "mechanical (or electronic) devices" like computers, efficient ways had to be found to represent numbers on these machines. What follows is a short introduction to the standard methods used to represent numbers on a computer. 1. Unsigned Binary Integers In our everyday decimal notation, we use the ten digits 0, 1, 2, 3, 4, 5, 6, 7, 8 and 9 to represent the first ten whole number quantities starting at zero. (Note : There is no digit for the quantity we call ten.) To represent whole numbers greater than nine, we use a "string" of digits where the position of a digit in the string determines the weight given to that digit. The weights used are powers of ten. Thus the number 12 represents one ten and two ones. The number 257 represents 2 hundreds (ten to the second power) plus 5 tens (ten to the first power) plus 7 ones (ten to the zero power) or 257 = 2x x x10 0 This is called "positional notation" and any whole number quantity can be represented this way. Now computers are built out of electronic components which are in one of two discrete states, OFF or ON. We assign the symbol 0 to the OFF state and the symbol 1 to the ON state. Using only two binary digits or bits (bit is a contraction of binary digit), integers can be represented using base 2 or binary notation. Like decimal notation, the position of a binary digit in binary notation determines the weight given it. However, the weights are powers of two, not ten. For example the binary number 1101 represents 1 "eight" (two to the third power) plus 1 "four" (two to the second power) plus 0 "twos" (two to the first power) plus 1 "one" (two to the zero power) or 1101 = 1x x x x2 0 = = 13 This rewriting of a binary number as a "sum of powers of two" is also a simple technique to convert it to its corresponding decimal representation. Note : It is useful to know the powers of two from 2 0 up to 2 10 (or even 2 16 ). The following "table" is easily generated by starting at 2 0 = 1 and doubling each value until 2 16 is obtained. 2 0 = = = = = = = = = = = = = = = = = Converting Binary to Decimal Representation As mentioned above, one method to convert binary representation to decimal representation is to write the binary representation as a "sum of powers of two". This requires knowing the powers of two : 1, 2, 4, 8, 16, 32, 64 etc. 1

2 Example: Convert binary to decimal by expanding it as a sum of powers of two = 1x x x x x x2 0 = = 53 Exercise: Convert the following binary representations to their decimal equivalents by expanding each as a sum of powers of two. a b A more "elegant" technique for converting binary to decimal is called Horner's Method or Synthetic Division. This technique does not require computing the decimal values for each power of two (thus minimizing the amount of multiplication). The set-up for Horner's method (see below) uses three lines: the binary representation is placed on the first line, a single 0 is placed in the first (left-most) column of the second line and the third line is left empty except for a "2 " (the 2 is the multiplier) off to the left. A bar separates the second and third lines. Horner's Method Set-Up <- line line line 3 Horner's method works from left to right. Starting with the left-most column, sum the two digits on lines 1 and 2 (1 + 0) and place the sum below the bar in line 3. Then multiply this sum by 2 transferring the product to the next column of line 2 (see below). Repeat this "sum, multiply by 2, transfer to next column" process for each digit in line 1. The final sum in the right-most column of line 3 is the corresponding decimal representation. Initial Set-Up After 1 Iteration Final Result ^ decimal result Exercise: Use Horner's Method to convert the binary representations in the above exercise to decimal. 3. Converting Decimal to Binary Representation An easily remembered method for converting decimal representation to binary is to repeatedly subtract out powers of two from the decimal representation. Begin by determining the largest power of two less than or equal to the decimal value. (For example 2 4 = 16 is the largest power of two less than or equal to 31 while 2 5 = 32 is the largest power of two less than or equal to 32.) Subtract the largest power of two from the decimal value and repeat by finding the largest power of two less than or equal to the remainder. Subtract again. Repeat until you reach zero. The powers of two subtracted out make up the binary representation. Example : Convert 13 (decimal) to binary 13-8 = 5 where 8 = = 1 where 4 = = 0 where 1 = 2 0 Therefore 13 = 1x x x x2 0 =

3 A useful trick to use with the "Subtraction of Powers of Two" method is to first list the powers of two from right to left leaving a blank line below each power Scanning from left to right, compare each power of two with the number to be converted. If the power of two is strictly larger, put a 0 in the blank below it; if it's less than or equal to the number, put a 1 in the blank below it, subtract the power of two from the number, and continue with the remainder.. Subtracting out powers of two to convert decimal to binary is the inverse of expanding by powers of two to convert binary to decimal. Example : Convert 104 (decimal) to binary Therefore 104 decimal equals binary This method often gives leading zeros which, as shall be seen below, is necessary when representing binary integers on the computer. A more elegant method, called the Integer Division Algorithm, involves repeated integer division of the decimal value by 2 while keeping track of the remainders. The remainders produce the binary representation in reverse order (i.e. the first remainder is the right-most or least significant bit). In the example worked out below, 13 is first divided by 2 to yield quotient 6 remainder 1. Continue by dividing the quotient 6 by 2 to obtain a new quotient 3 and a remainder 0. When the quotient eventually reaches 0, stop. The reminders (in reverse order) give you the binary representation. As noted below, "toppling" over the remainders will yield the correct binary representation. Example : Convert 13 (decimal) to binary r 1 Note L : If you "topple over" --- the "remainder tower" 2 3 r 0 you will have the --- binary representation. 2 1 r r 1 => Note the use of the "upside-down" division sign. 3

4 4. Representing Unsigned Integers on the Computer. Computers use a fixed number of bits to store a binary integer. The number of bits used is a function of the way the memory of the computer is configured. Generally the individual bits of memory are not individually accessible (i.e. "addressable"). Instead a fixed number of bits is grouped into "cells" (e.g. 8-bit bytes or 16-bit words) and only these larger "cells" can be accessed. The Intel 80x86 family can use either an 8-bit byte or a 16-bit word to store a binary integer. So decimal 13 is either or The Intel 80x86 is "byte" addressable. With the advent of the Intel 386, 486, and Pentium architectures four byte 32-bit "double word" length integers were added. So 13 decimal is Exercises 1. What are the largest unsigned binary integer representable by the following memory cell sizes and what are their corresponding decimal values? a. a 4 bit "nybble" (Yes, a 4 bit "half" byte is sometimes referred to as a "nybble") b. an 8 bit byte c. a 16 bit "word" (as in the Intel 80x86) 2. Suppose you added 1 to the largest integer represented by 16 bits. That is = The latter value is a 1 followed by 16 zeros. What is the value of this binary representation? (Careful - it's NOT 2 17.) If the largest binary integer representable by 16 bits is one less than the above answer, use this method to find the decimal value of the largest integer representable by a 32 bit double word. 5. Hexadecimal Notation A drawback to binary representation is length; many bits are needed to represent even relatively small integers. Shorter integers are possible using octal (base 8) and hexadecimal (base 16) representations which are easily obtained by "grouping" the bits of a binary representation.. To convert from binary to hexadecimal, start from the right, group the bits by fours and convert each grouping to its corresponding hexadecimal digit. Since hexadecimal (base 16) notation requires sixteen digits and since we lack symbols for the values ten (binary 1010), eleven (binary 1011), twelve (binary 1100), thirteen (binary 1101), fourteen (binary 1110), and fifteen (binary 1111) we use the symbols (digits) A, B, C, D, E, and F for these values. The correspondences are listed in the table below. Four Bit to Hexadecimal Digit Conversion Table 0000 = = = = C 0001 = = = = D 0010 = = = A 1110 = E 0011 = = = B 1111 = F Remember that A through F are the hexadecimal digits for the decimal values ten (binary 1010) through fifteen (binary 1111). 4

5 Binary to hexadecimal conversions are easy : group by fours and convert each grouping using the table (which is easily memorized). Example : Convert binary to hexadecimal = = D4 This technique "works" because we are factoring out powers of 16 (2 4 ) from the binary representation. Recall that, as a sum of powers of two can be written as 1x x x x x x x x2 0 Starting from the right, group the terms by four and factor out the common power of 16 from each grouping. (1x x x x2 0 )x (0x x x x2 0 ) x 16 0 Finally, rewrite the expression in front of each power of 16 as an octal digit. D x x 16 0 = D4 (hexadecimal) To convert from hexadecimal to binary, replace each hexadecimal digit with its 4-bit equivalent. Example : Convert B9E2 hexadecimal to binary B9E2 = = Notation : To signify whether a representation is binary, octal, decimal or hexadecimal, we shall adopt the convention of attaching the post-fixed letter, 'b' for binary, 'o' for octal, 'd' for decimal, 'h' for hexadecimal, to the integer. For example, 157o is 157 octal; 157h is 157 hexadecimal. We shall use this "postfix" notation whenever the radix (i.e base) of the integer is not clear from context. (Another convention for hexadecimal is to use the prefix '0x' as in 0x157) Exercise 1. Convert the following binary representations into hexadecimal a b Convert the following representations into binary a. ACE0h b. 8B3h 6. Hexadecimal to Decimal Conversions Conversions from hexadecimal to decimal can be done indirectly by first converting hexadecimal to binary then converting binary to decimal. Conversions from decimal to hexadecimal can be done indirectly by reversing the above process. It is also possible to alter the conversion methods from Sections 2 and 3 in an obvious manner to directly convert between hexadecimal and decimal. Exercise: Think about how you would alter the conversion methods from Section 2 (expansion by powers of two, Horner's method) and the conversion methods from Section 3 (subtracting powers of two, integer division) to obtain methods that directly convert between hexadecimal and decimal. Apply your methods to do the following. a. Convert 7Eh to decimal using either expansion by powers of 16 or Horner's method. Check your work by using either subtracting powers of 16 or integer division to convert your answer back to octal. 5

6 b. Convert BADh to decimal using either expansion by powers of 16 or Horner's method. Check your work by using either subtracting powers of 16 or integer division to convert your answer back to hexadecimal. Hint! When working with hexadecimal integers using decimal arithmetic, it is sometimes useful to replace each hexadecimal digit with its decimal equivalent. For example, rewrite BADh as (11)(10)(13)h 7. Binary Addition and Subtraction Binary Addition of two digits is trivial; there are only four "rules" Note that the last sum has a "carry out"; that is 1 plus 1 is 0 "carry" 1. More interesting and useful is binary addition with a "carry in" which is the "carry out" from the previous column <- carry in Using the above eight "rules", any two binary integers can be added. Example: Binary Subtraction is more complicated because of the need to "borrow" from the next column. This is indicated by placing a -1 above the column to the left to indicate that 1 must be borrowed from the next column over borrow -> The only time a borrow is needed is when subtracting 1 from 0 (in the second subtraction above). Essentially, you borrow 10b from the next column over so you subtract 1 from 10b leaving a difference of 1. The effect of a borrow from a previous column on the right can get a bit complicated. If the current minuend (upper digit) is a 1, it will be used by the borrow from the previous column and so it effectively becomes a zero (see subtractions 3 and 4 below). If the minuend is a 0 a borrow "in" from the right must be propagated to the next column on the left which has the ultimate effect of making the 0 minuend into a 1. (When you borrow 10b from the column on the left, since 10b = 1 + 1, one of the 1's is used by the borrow "in" from the right while the remaining 1 becomes the new minuend). See subtractions 1 and 2 below. 6

7 It helps to distinguish between a "borrow in" (a borrow made by the column on the right) or a lend and a "borrow out" (a borrow from the next column on the left). borrow borrow borrow borrow out in out in in out in If you think about it, subtraction with binary integers is just like subtraction with decimal integers. However, as we will see below, there is easier way to do binary subtraction. Example : Exercises: Evaluate the following a b c d e Signed Binary Integers : Two's Complement Representation So far we have only discussed representations for unsigned binary integers. One way to represent signed binary integers uses the left-most bit to store the sign of the integer (0 for +, 1 for -) and uses the remaining bits to store the magnitude of the integer. This is called sign-magnitude representation. If a signed integer were stored in an 8-bit byte, the left most bit (bit 7) would store the sign and the other seven bits (bits 0-6) would store the magnitude. sign magnitude _ _ For example, the 8-bit sign-magnitude representation of +67 would be while -67 would be Sign-magnitude representation for binary integers has been superseded by other representations, in particular two's complement representation. However, sign-magnitude is still used in floating point representation. To introduce two's complement representation for signed binary integers we begin by looking at odometers, those mileage gauges found on cars.. Assume we have a 3 bit binary odometer. If it was initialized to 000 and we drove forward one mile, it would read 001. If we drove forward two miles it would read 010. If we drove forward three miles it would read 011. On the other hand, if we started at 000 and drove backwards one mile it would read 111. Thus we can set up the following correspondence between the signed integers from -4 to +3 and the eight 3-bit binary odometer readings. 3-Bit Binary Odometer Readings and Signed Integers odometer signed value Note that all negative values are assigned to "odometer representations" which begin with 1. 7

8 This technique can be scaled up. Assume we have an 8 bit binary odometer. If it was initialized to and we drove -1 mile (i.e. 1 mile backwards), it would read Minus 2 miles would be etc. So there is an obvious one to one correspondence between the range of signed integers and the binary integers starting at and increasing to followed by and increasing to (Actually "follows" since if you add 1 to and throw away the "carry out", you would get ) 8-Bit Two's Complement Integers and their Signed Decimal Values This method for representing signed binary integers is called Two's Complement Representation. The 8-bit binary representations between and are the integers between 0 and +127 (you should check that is 127); the 8-bit binary representations between and are the integers from -128 to -1. Representations for negative integers have a 1 as their left-most bit; positive integers have 0. One advantage of two's complement representation is the ease of detecting positive or negative integers (the left most bit is referred to as the "sign bit"). Aside from the "binary odometer" model, there is another way to understand two complement representation. This involves assigning a negative weight (value) to the left most sign bit. For example, above we said that represents -2. If we express this as a sum of powers of two with the left-most bit having the negative weight -(2 7 ) instead of 2 7, we have 1 -(2 7 ) = = -2 Expressing a two's complement representation as a sum of powers of two with the weight of the sign bit negated makes it easy to convert any two's complement representation to its corresponding signed integer value. It obviously "works" for negative integers; it also works for positive integers since the left most bit being 0 contributes nothing to the sum; only the remaining positive weights contribute. Another advantage to two's complement representation is the ease that one can convert any positive binary representation to its negative counterpart. The trick is "complement and add one". This allows us to use the binary to decimal conversion methods of Section 2 to convert any two's complement representation to a signed decimal integer and the decimal to binary methods of Section 3 to convert any signed decimal integer to two's complement representation. Two's Complement Representation is fixed length. It is important to point out that two's complement representation is a fixed length representation where all integers have the same number of bits. That is, you can have 3-bit two's complement representation or 8-bit two's complement representation or 16-bit two's complement representation etc. It is fixed length because the negative weight given to the sign bit is determined by the position of the sign bit. As a result all positive two's complement representations have leading zeros and all negative two's complementation representations have leading ones. So +1 in 8-bit two's complement representation is and never just 1. Expanding by powers of two or Horner's method will convert any positive two's complement representation (sign bit is 0) to decimal. No extra work is needed. However, if the two's complement representation is negative (sign bit is 1), use "complement and add one" to get the corresponding positive two's complement representation then apply expanding by powers of two or Horner's method. Negate the decimal result. 8

9 Example : Convert two's complement to signed decimal complement and add 1 to <- complement 1 <- add Now convert binary to decimal (sums of powers of two) 1110 = 1 x x x x 2 0 = = 14 negate 14 to obtain -14 Therefore b = -14 Subtracting out powers of two or integer division will convert any positive signed decimal to an n-bit two's complement representation. No extra work is needed except remembering to include the leading zeros! To convert a negative decimal integer, apply subtracting out powers of two or integer division to the corresponding positive decimal value, expand the binary integer to n-bits then use complement and add one to obtain the n-bit two's complement representation. Example : Convert -57 to 8-bit two's complement representation negate -57 to get 57 convert 57 to an 8-bit binary integer (subtract out powers of two) <- powers of Finally complement and add <- complement 1 <- add = -57 You can always expand by powers of two to check your work. Example: Using the expand by powers of two with the left-most bit negated verify that equals = -57 Finally, the "complement and add one" method also converts any negative two's complement representation to its positive counterpart < <- complemented + 1 <- add <

10 Exercise: Express the following integers using 8-bit two's complement representation a. 119 b. -76 c. -63 d. -23 e Representing Signed Binary Integers on the Computer As noted above two's complement representation is a fixed length notation. When representing signed integers using two's complement representation on a computer, the number of bits used will be a function of that computer's memory "cell" size (recall Section 4). For example, using an 8 bit (byte) representation for integers, the positive integers run from to and the negative integers run from to Exercise: What is the range (in decimal) of signed integers using an 8-bit byte? Give both the positive range and the negative range. The Intel 80x86 family is a 8-bit byte addressable architecture so it uses either an 8-bit byte or a 16 bit word (or a 32 bit double word for 386 and above) two's complement representation. It also uses hexadecimal notation. With an 8-bit byte, the Intel 80x86 has a range of 00h to 7Fh (+127) for positive integers and a range of FFh (-1) to 80h (-128) for negative integers. In hexadecimal, negative two's complement integers begin with the digits 8 through F. Exercise: In hexadecimal, what is the range of signed integers using 16-bit two's complement representation? Remember that since two's complement representation is fixed length, the binary representations have the SAME NUMBER OF BITS. Finally, if a 32-bit double word two's complement representation is used, positive integers range from h to 7FFFFFFFh; negative from FFFFFFFFh to h. 10. Addition and Subtraction with Two's Complement Representation Binary addition with two's complement representation is the same as binary addition with unsigned binary integers provided that any "carry out" from the left-most sign bit is thrown away. This works for both positive and negative two's complement representations. Example : Add -23 to 17. We first find the 8-bit twos complement representations of -23 and < < <- complement + 1 <- add < Then add both representations < < <- -6? 10

11 Since the sign bit of the sum is 1, the sum is negative. To determine the magnitude of the sum, "complement and add one" <- complement + 1 <- add <- equals 6 So -6 is the answer which agrees with Subtraction is done by addition of a negative value. That is, to subtract B from A (A - B), complement and add one to B which yields -B and add this to A. (A - B = A + (-B)). Thus no separate rules for subtraction are needed! Exercise: Evaluate the following by converting all integers to 8-bit two's complement representation and add. Remember that subtraction is done by adding the negative value. Convert your answer back to decimal to make sure it's correct. a. 98 b. -43 c. -37 d e. 98 f. -43 g. -37 h Arithmetic Overflow Using 8-bit twos complement representation, suppose we try to add 78 to is and 67 is which is a negative integer (note the leading 1) On reflection we might realize that equals 145 which is outside the range ( ) of integers representable using 8-bit two's complement representations. Examining the calculation we observe that there was a carry from the 64's bit (2nd column on the left) into the sign bit (left-most column) which changed the sign of the result. Suppose we try to add -78 and is and -67 is which is a positive integer (note the leading 0) Again this is not surprising since adding -78 and -67 yields a result outside of the range Examining the calculation we note that the two sign bits when added together yielded a 0 for the sign bit in the result (we threw away the carry out from the sign bit). 11

12 To further examine all possibilities, let us add -78 to +67 and +78 to -67. Both will result in correct answers < < < < < <- +11 In the first case there was no carry into the sign bit (left-most bit) or carry out of the sign bit. In the second case there was both a carry in and a carry out of the sign bit. If we contrast the two correct cases to the two incorrect cases, the first incorrect case had a carry in to the sign bit but NO carry out of the sign bit and the second had a carry out but NO carry in to the sign bit. This is gives us a simple way to detect an "overflow" condition, i.e the generation of a result that is outside the range of representable integers: If "Carry In" (to sign bit) does NOT equal "Carry Out" (from sign bit) then OVERFLOW! 12. Fractional Binary Numbers - Positional Notation Just like decimal numbers, binary numbers can have digits below the "binary" point (called the decimal point with decimal notation). In positional notation, bits below the binary point have weights which are negative powers of two. For decimal notation, digits below the decimal point represent tenths (10-1 ), hundredths (10-2 ), thousandths (10-3 ) etc. In binary notation bits below the binary point represent halves (2-1 ), fourths (2-2 ), eighths (2-3 ) etc. Example : Convert binary to decimal by expanding by powers of two b = 1x x x x x x2-3 = = The "expanding by powers of two" method can be used to convert any binary number with or without a fractional part, into its corresponding decimal equivalent. Exercises: Convert the following binary reals to their decimal equivalents. a b c A binary real has two parts : an integer part consisting of the digits above the binary point and a fractional part consisting of digits below the binary point. We will refer to this fractional part as a fraction, not to be confused with the idea of a rational binary number, one which is in the form a/b where a and b are binary integers (i.e. 1/100 is binary for 1/4) 13. Conversion of Binary Fractions to Decimal While "expanding by powers of two" is a quick and easy technique to convert any binary number to its decimal equivalent, there is an extension of Horner's method which will convert any binary number to its decimal equivalent. The integer part of a binary number can be converted using Horner's method as presented in Section 2. The fractional part can be converted using a variant of this algorithm. The initial set up of the variant of Horner's method, like the original, uses three lines. The fraction digits appear on the first line beginning with a 0 before the decimal point. A single 0 appears in the last column of the second line and the third line is empty except for a " 0.5" off to the right.. 12

13 <- 0 point binary fraction For this variant of Horner's method, work right to left. Sum the numbers in the first and second lines, place the result on the third line, multiply this sum by 0.5 and transfer the product to the second line one moving column to the left. Repeat this add, multiply by 0.5, transfer process.. The final sum on the third line left most column is the decimal value. Example : Convert b to decimal Initial Set Up Final Result (right to left) result Exercises Using Horner's method (above) convert the following binary fractions to their decimal equivalents. a b c Conversion of Decimal Fractions to Binary Converting a decimal fraction to its binary equivalent can be done by subtracting out negative powers of two in the manner similar to converting a decimal integer to binary. First, list out the values of the first few negative powers of 2 left to right, leaving blanks below to be filled in with either 0 or 1. Initial Setup : Scan the values of the negative powers of two left to right and if a value is too large, place a 0 in the blank below it; otherwise subtract that value from the decimal fraction and place a 1 in the corresponding blank. Repeat with the reduced value terminating when you reach zero or enough bits have been generated. 13

14 Example : Convert to binary <- final result <- 0.5 is < is so = 0.101b This technique is awkward because of the difficulty of generating the decimal values needed and subtracting them out. Fortunately there is a better way which uses repeated multiplication If N is the decimal number you are trying to convert, multiply it by two. The product will have an integer part (digits above the decimal point) and a fractional part (digits below the decimal point). The integer part (either a 0 or 1) will be the first bit in the binary fraction. Continue by multiplying the fractional part by two. The integer part (0 or 1) of this multiplication will be the second bit in the binary fraction. Repeat this process on the fractional part until either zero results or a sufficient number of bits in the binary fraction have been generated Example : Convert to binary * 2 -> 0.75 multiply by 2 int(0.75) -> 0 extract the integer part 0.75 <- frac(0.75) extract the fractional part 0.75 * 2 -> 1.5 multiply by 2... int(1.5) -> <- frac(1.5) 0.5 * 2 -> 1.0 int(1.0) -> <- frac(1.0) 0.011b <= result 14

15 Example : Convert 0.3 to binary * 2 -> 0.6 int(0.6) -> <- frac(0.6) 0.6 * 2 -> 1.2 int(1.2) -> <- frac(1.2) 0.2 * 2 -> 0.4 int(0.4) -> <- frac(0.4) 0.4 * 2 -> 0.8 int(0.8) -> <- frac(0.8) 0.8 * 2 -> 1.6 int(1.6) -> <- frac(1.6) 0.6 * 2 -> 1.2 int(1.2) -> <- frac(1.2) 0.2 * 2 -> 0.4 int(0.4) -> <- frac(0.4) At this point, observe that the algorithm repeats, so 0.3 decimal is the repeating binary fraction Exercise: Using the repeated multiplication algorithm, convert the following decimal fractions into binary fractions. If the binary fraction repeats, indicate the repeating pattern of bits a b c. 0.1 d Fixed Point Representation One obvious way to store a binary real on a computer is to store both integer and fractional parts while keeping track of where the binary point is. For example, using a single 8-bit byte, we could store a four bit integer part in the upper four bits and a four bit fractional part in the lower four bits with the assumed binary point being between bits 3 and 4. Example : Store = in an 8-bit fixed point representation integer fraction <- contents of byte <- bit number ^ binary point Another way would be to use adjacent cells (bytes) of memory with the assumed binary point between the two bytes. 15

16 Example : Represent = b in fixed point representation using adjacent 8-bit bytes integer fraction ^ binary point In fixed point representation, a binary real number has an integer part and a fractional part with an assumed binary point separating the two. Example : Store = b using adjacent 8-bit bytes integer fraction binary point In fixed point representation all the standard methods for addition and subtraction work. Even more interesting is that two's complement representation goes over in a natural way with fixed point representation. To obtain the negative representation, complement and add one to the right most position. Example : Find the two's complement fixed point representation of < <- complement + 1 <- add < Check: = Additional Note : Fixed point representation is no longer used having been superseded by floating point notation, discussed below. Exercises: a. Using a one-byte fixed point two's complement representation with the binary point between bits 3 and 4, what is the magnitude of the smallest number? The largest number? b. In representing integers, the difference between consecutive integers is 1. What is the difference between consecutive fixed point representations assuming the one-byte representation above is used? c. Using a two-byte fixed point two's complement representation with the binary point between the bytes, answer the questions from parts a and b above. 16

17 16. Scientific Notation in Binary Recall that scientific notation is used to represent very large or very small numbers. Example : 1,000,000,000,000 (one trillion) = 1.0 x ,000,000,001 (one trillionth) = 1.0 X The same can be done in binary. The binary real can be written as x where we shift the binary point 4 (decimal) or 100 (binary) places to the left. In scientific notation, the decimal or binary point can be placed anywhere with an appropriate adjustment to the exponent (power). There is a standard convention whereby the binary (or decimal) point is shifted (with an appropriate adjustment to the exponent) so that it appears immediately to the left of the leading non-zero digit. So all digits above (to the left of) the binary (or decimal) point are 0 and the first digit below (to the right of) the binary (or decimal) point is nonzero. Such a representation is said to be normalized. Example : normalized is written as x The sequence of bits is called the mantissa or fraction; the power to which 10 is raised, in this case 101, is the exponent. 17. Floating Point Notation - A Byte-Size Example In floating point representation, the sign of the number, the fraction (mantissa), and the exponent from the normalized binary scientific notation form are stored in separate fields within one or more contiguous cells (bytes) of memory. As an example, we will store all three values within one 8-bit byte. Bit 7, the left-most bit will hold the sign (0 for positive, 1 for negative), bits 4 through 6 will hold the exponent, and bits 0 through 3 will hold the fraction. sign exponent fraction We will use the sign magnitude convention to represent signed quantities. Given any positive normalized floating point binary representation (e.g = = x 10 1 ), it should be obvious how the values in the sign bit and the fraction field are obtained. What is not clear (or might not be just yet) is what is entered into the exponent field since we need to account for both positive and negative exponents. For our 8-bit floating point representation, we will use "excess 011" notation for the exponent field where the value for the exponent field is obtained by adding 011 to the exponent. For example, if 001 is the exponent, the exponent field will contain = 100. Thus x is stored as This "excess 011" (or "excess 3") notation maps the signed exponents from -3 to + 4 to the binary range 000 to 111 where -3, -2, and -1 map to 000, 001, and 010 (except the exponent 000 is not used - see below), 0 maps to 011, and +1 through +4 maps to 100, 101, 110, and 111. Note that order is maintained! There is one final feature to our 8-bit floating point representation. We always normalize our numbers first. But since the first digit to the left of the binary point is always 1, to save bits (and get an extra bit of precision), we never store this 1-bit. Thus 2.25 would be stored not as but as (note that the fraction is shifted left). 17

18 Example : Express 0.35 in 8-bit binary floating point notation 0.35 º = (binary). This is stored as (not ) where the value in the exponent field, 001, is obtained by adding 011 to -10. To store the negative value -0.35, do the same but set the sign bit to 1. Example: Express in 8-bit binary floating point notation 2.25 = 10.01b = (binary) This is stored as where the value in the exponent field, 100, is obtained by adding 011 to 1 and the sign bit is set to 1. Thus to convert any binary real to the above 8-bit floating point representation a. rewrite the (positive) binary real in scientific binary notation b. normalize (shift binary point so the leading 1 is to the immediate left and adjust exponent accordingly) c. add 011 to the exponent and insert into the exponent field d. drop the leading 1 of the fraction and insert the following 4 bits into the fraction field e. set the sign bit (0 for positive; 1 for negative). The representation for 0 in floating point is a special case. We use for zero. By convention the exponent field is never 0 except for the representation (or for negative 0!). Thus any represent with a zero exponent field and a non-zero fraction (e.g ) is illegal The largest (magnitude) real that is representable is = x = b = 31 decimal (-31 is represented as ). The smallest (magnitude) normalized non-zero real that is representable is = = 0.01b = However the next larger number is = which differs by So relative precision is above 15/1000 Floating point representation values are not "evenly distributed". Unlike the integers where the difference between any two consecutive integers is always 1 or fixed point notation where the difference between any value and the "next" is fixed (for example, using the two byte fixed point format from Section 19, the difference is 2-8 ), the difference between consecutively representable floating point representation varies depending on the exponent and the number of digits represented in the fraction. Example : The difference between the smallest normalized floating point representation, , and the next smallest, is 2-6 = However, the difference between the largest floating point representation, = 31 and the next to largest, = 30 is 1! The difference depends on the exponent and the number of bits in the fraction. There is the question of why the exponent field comes before the fraction field and why excess 011 notation is used for the exponent. Presumably one reason is that it permits positive floating point representations to have the same ordering when considered as integer quantities. Consider the following example. 18

19 Example : Express +4.0, , and 0.0 as 8-bit floating point representations +4.0 = 100.0b = 1.0 x (binary) = = = 10.0b = 1.0 x (binary) = = = 0.10b = 1.0 x 10-1 (binary) = = = 0.01b = 1.0 x (binary) = = = = 0 If you treat the above positive floating point representations for +4.0, +2.0, +0.5, and 0.0 as unsigned integers, they are ordered by their values as the 8-bit unsigned integers 80, 64, 32, 16 and 0. Positioning the exponent field first and adding 011 to it gives positive exponents greater weigh when the representation is considered as an unsigned integer. This means that any comparison "circuit" that compares unsigned integers for less than, less than or equal to, greater than, greater than or equal to, etc will also work for positive floating point representations. 18. Floating Point Notation - A Four Byte Example In floating point notation, the sign of the number, the fraction and the exponent of the normalized binary scientific notation form are stored in separate fields within one or more continuous cells of memory. In 8-bit byte addressable architectures usually four contiguous bytes are used to hold all three fields. If we number the 32 bits of four consecutive 8-bit bytes right to left 0 to 31, the right most bit (bit 31) would be the sign bit, the next 8 bits (bits bits 23-30) would store the exponent, and the remaining 23 bits would hold the normalized fraction (where the binary point is shifted to be to the immediate right of the leading 1 bit and the exponent adjusted accordingly). To get an extra bit of precision the leading 1 to the left of binary point in the normalized fraction is implied. sign exponent field fraction field _ _ The sign bit is used for the sign of the mantissa where 0 indicates plus and 1 indicates minus (sign - magnitude convention). The value actually stored in the exponent field is not the exponent itself but the exponent offset by (offset by 7Fh or excess 7Fh ). That is, if the exponent is 101, the value = would be stored in the exponent field. An exponent of -101 would be ( ). The effect is to "encode" all positive and negative exponents as unsigned binary integers. Positive exponents have a 1 in the left-most bit position; zero and negative exponents have a 0. As observed in the previous section, you can treat two positive floating point representations as unsigned integer quantities and correctly compare them. Alternately you can separately treat the 8 bits of the exponent and the 23 bits of the mantissa as two unsigned integers. Comparing the two exponents determines which exponent and which floating point representation is larger; if the exponents are the same, go on to compare mantissas. The fraction is always left justified in the mantissa field. Since the fraction is first normalized so that the leading 1 would normally appear to the left of the binary point, this bit is not stored giving the 23-bit fraction field 24 bits of precision. The exponent field is never zero exception to represent a floating point 0 where all 32 bits are 0. Example : in floating point representation would appear as

20 Example : in floating point representation would appear as Converting a decimal number to floating point representation takes a bit of doing. Basically this requires: 1. Converting a decimal number to binary fixed point notation which usually requires handling the integer and fraction parts separately 2. Converting binary fixed point to normalized binary scientific notation 3. Offsetting the exponent value by and insert into the exponent field 4. Drop the leading 1 bit of the fraction and insert the remaining 23 bits into the fraction field 5. Set/clear the sign bit. Example : Convert to floating point representation decimal = (binary) 2. = x offset plus exponent : = => (drop first 1) Note that has a repeating binary representation, so we truncated after 24 bits. Exercise: Convert the following decimal real numbers to floating point representation. a b c Convert the following floating point representations to decimal real numbers. d e Advantages and Disadvantage of Floating Point Representation The obvious disadvantage of floating point representation is the difficulty in converting between decimal numbers and floating point representation. In addition, any "hardware" used to perform arithmetic operations on floating point representations will be very complex (hence expensive) since exponent and fraction have to be treated separately. In fact, many early computers did not support hardware floating point operations; operations had to be done in software which is slower. However, the advantages more than make up for the disadvantages. The range of expressible numbers is greatly increased using floating point representation. 20

21 Example : The smallest value (magnitude) greater than 0 is which is 1.0 x = 1.0 x º x Example : The largest value (magnitude) is which is x º 2 x º 3.40 x Note: An exponent field with all 1's is reserved to denote plus or minis infinity. A second issue deals with precision, that is the number of digits in a decimal real number that can be represented. We've observed that many decimal numbers have repeated binary expansions which are truncated after the 24th bit. How much error does this introduce? With out going into the details, the relative error introduced by floating point representation is on the order of 2-24 = x This means that floating point representations are accurate to about 7-8 decimal digits. In summary, floating point representation permits a much larger range of real numbers to be represented than is possible with fixed point representation. The 32-bit floating point representation given above corresponds to the IEEE (754) Standard for Binary Floating Point Arithmetic. While the general ideas are the same, floating point representations for different computer architectures can differ in the details like how many bits are used to store the normalized mantissa, how many bits are used to store the exponent etc. For example, the Intel 80x86 family has 32-bit 64-bit and 80-bit floating point representations. BriefNum.doc 01/23/04 21