Tue, 10 Sep 2013, 00:48

To my students in 306: Based on the number of students who stayed after class asking questions today, it is clear we were too rushed at the end. Ergo, this handout dealing with floating point numbers. Real machines (ISAs) generally have two sizes of floating point data types: 32 bits and 64 bits. The 32 bit variant we talked about in class today: 1 sign bit, 8 exponent bits, 23 fraction bits. The 64 bit data type in IEEE Floating Point Standard has: 1 sign bit, 11 exponent bits, 52 fraction bits. In class I used a 6 bit floating point data type to explain some of these concepts: 1 sign bit, 3 exponent bits, and 2 fraction bits. Tonight, I feel generous, and will use a 10 bit floating point data type: 1 sign bit, 4 exponent bits and 5 fraction bits. Suppose we want to represent the number -99. First the sign bit: ================== The sign bit is easy (0 means +, 1 means -). So the sign bit is 1. Second, the fraction bits: ========================= The fraction bits are also easy. They just represent the bits of the value. For example, 1100011 represents the magnitude of the number 99. That is, 1 x 2^6 + 1 x 2^5 + 0 x 2^4 + 0 x 2^3 + 0 x 2^2 + 1 x 2^1 + 1 x 2^0. I first need to put it in normalized form. The answer: 1.100011 x 2^6. Do you see why? If not you need to talk to your TA now! We said our floating point numbers will be 10 bits and only five of the bits are for the fraction. But here we have 7 bits. The 1 to the left of the binary point is not a problem. Normalized form means it must be a 1 so we do not waste any bits in its representation. That leaves six bits .100011, but our 10 bit representation only allows five, so we have to discard the lowest bit since we can not squeeze 6 bits into a 5 bit container. The fraction bits are therefore 10001. At this point, my representation is: 1 xxxx 10001. I put in xxxx where the exponent code is going to go. Third, and finally, the exponent bits: ===================================== The four bit exponent is from 0000 to 1111. 16 different codes, as you know. All computer designs that I know of, following in the footsteps of the IEEE Arithmetic, use 1111 and 0000 for special purposes. We use 1111 to represent infinity, a perfectly useful value. 0 1111 00000 is the representation for + infinity. 1 1111 00000 is the representation for - infinity. If the exponent bits are 1111 but the fraction bits are not 00000, then we are not representing infinity. What we are representing is beyond what we need to know in 306. Ask me when you are taking 460N in a couple of years. We use 0000 to represent numbers that are too small to normalize. We will get to that in a moment. But first, we want to know how to use 0001 to 1110 for the exponent when the number CAN be expressed in normalized form. Our example, -99 is a number that can be expressed in normalized form. With four bits of exponent, and removing 0000 and 1111, we have 14 codes left over. We use those 14 codes to represent 14 consecutive exponents. The convention is to use an *excess* code. That is, the exponent being represented is the value of the code MINUS the excess. That is, if we subtract the excess from the value of the code, we get the exponent. We usually refer to the excess as the BIAS, and in IEEE Arithmetic, it is the value 0111 (that is, 7) for our four bit exponents. It would be 01111111 (that is, 127) for our 8-bit exponent code. Or, 01111111111 (that is, 2047) for our 11-bit exponent. Back to our 4-bit exponent, we have code values of 0001 (1) to 1110 (14). The BIAS is 0111 (7). Thus the exponent for the code 0001 is 1-7, which is -6. The exponent for the code 1110 is 14-7, which is 7. AGAIN, we get the exponent by subtracting the BIAS from the code. We get the code by adding the BIAS to the exponent. The complete set of codes and their corresponding exponents are as follows: Code Exponent ==== ======== 1111 special case 1110 +7 1101 +6 1100 +5 1011 +4 1010 +3 1001 +2 1000 +1 0111 0 0110 -1 0101 -2 0100 -3 0011 -4 0010 -5 0001 -6 0000 special case Recall (way up above) the magnitude 99 in normalized form was 1.100011 x 2^6. The exponent is +6. If I add the BIAS (which we agreed was 7), we will get the code. Thus the code is 13, or in binary: 1101. And we are done! -99 is represented as 1 1101 10001. Now, going back the other way! ============================= Suppose we want to construct the floating point number from the 10-bit representation, how do we do it? Let's look at the ten bit representation: 1 1101 10001. The left most bit gives us the sign: negative. The low 5 bits give us the fraction following 1. : 1.10001 The remaining 4 bits give us the exponent. We take the code (13) and subtract the BIAS (7) and get the exponent 6. The answer 1.10001 x 2^6. If we work it out, we have -98. NOT -99. How come! Remember we could only pack 5 bits of fraction into our 5 bit field, so we lost the value represented by that last bit, which in this case was 1. Another example: +34. The magnitude is 100010. Normalized: 1.00010 x 2^5. The representation: 0 1100 00010 Another example: +13.5. The magnitude is 1101.1 Normalized: 1.1011 x 2^3. The representation: 0 1010 10110 Note we only had four bits in our number, but the fraction field had room for five bits so we filled it up with an extra 0. Finally, we are ready for the exponent code 0000. ================================================ (You may want to read the ps at the bottom of this email right now!) This is for numbers that are two small to represent in normalized form. So, we represent them, not as 1.fraction x 2^exponent, but rather as 0.fraction x 2^(-6), our smallest allowable exponent. An example, the value +3/256. This number in binary is 0.00000011. If we normalize it, we get 1.1 x 2^(-7). BUT, if we look at our exponent table above, we see we can not represent the exponent -7 in our 4-bit code. Therefore our number is too small to normalize. The BEST I can do is represent it with an exponent of -6, that is: 0.11 x 2^(-6). Note that this number is no longer normalized. It can not be! It is too small! In fact, we have a name for these numbers. They are called SUBNORMAL numbers. We represent this number: 0 0000 11000 Note we fill in the remaining three bits of our 5 bit fraction with 0. Now, we wish to reconstruct the value from the representation. The exponent 0000 tells us that we have 0.fraction x 2^(-6) The sign bit 0 and fraction 11000 gives us: + 0.11000 x 2^(-6), which is +3/256. And, now you have the whole story! Good luck with the first problem set. Yale Patt ps. I have a little surprise for you. Understanding the subnormal numbers is not something I will expect of you in EE 306. So, you can completely ignore this part of my email. I include it because there are 400 of you and some of the students in EE 306 just can't wait for E 460N to understand SUBNORMAL numbers. See you on Wednesday!