Let's just see how we would add together two floating point numbers if we've got 42 and so in floating point representation that would be 100 100 100 times 2 to the 1 2 3 4 5 so let's add on 6 so 1 1 o is 6 and that's times 2 to the 2 so we now need to add these two numbers together Now before we would just add them together by going that was that that was that that Plus that that's it. We can't do that with Floating point numbers because the bit patterns for these things being that these are going to look like very very different things What we have to do is first of all Line them up to the bits in the same place. So we need to shift this one down so that the bit here which represents 4 is in the same position as the bit that represents 4 here And so the number of spacing we need to shift This right is a difference between the big one and the little one in this case.
It's three places. So 1 2 3 Spaces so we shift it 3 spaces to the right And so the first that was rather than just adding them together. We have a Step.
Now what we've got to expand them out of the bit representations because remember that this would actually be 0 1 which is encoded 0 1 0 1 0 And this the 8 bit exponent this is going to be what 127 plus 5 which is 128 plus 4 so that's going to be 1 0 0 One zero zero so it's gonna be something like that So we've got that so that's what that's represented by and this one is going to be similar It's going to be represented by zero. We've got one two, three, four, five six seven eight bits The ones already encoded implicitly zero and zeros down there ignore them for now And we're gonna store. This is 1 0 0 0 0 0 1 so the numbers were actually got in memory in our computer are represented like this so the first thing we have to do is Get them to a point we can and we can't just add these two numbers together anymore And we can see that they're simply by looking over here if we had 1 + 1 We'd get 1 0 Z answer which mean with the answer to have a 1 here which means something go from positive numbers to any Negative number which is definitely wrong.
So we need to unpack this representation into a form that we can add together now one way we could do that is just work out how many bits we would need and Assign the bits into the right place and do that, but we can actually use some sort of tricks We know for example if we're adding two numbers together with a certain number of bits in this case 24 bits The biggest number that we could add two numbers together and get a result Would have a value of two it roughly around two to the 25 The other thing we know is one of these numbers going to have a greater Exponent than the other So what we can do is we could say, okay Let's keep that one where it is and shift this one or divide this one by two So that the exponent on it would be the same. So if we shift this one place to the left We'd end it was this a zero point one times two to the three another place to the left It would be zero point and so on times two to the four Until we end up with that one lined up there and that becomes times two to the five and then we have zero Zero point two zero zero 1 there so We did the first step. We need to unpack them from the representations into forms that we can add together and then we need to shift this one so that the Exponents are the same.
So we take the smaller one and shift it So the exponents Alanya now we can add those numbers together So we can now add these because locally we can produce a number one bit bigger than this if we add them together One plus one is two for example. So 0 plus 0 is 0 1 plus 1 is 0 carry 1 0 plus 1 plus 1 is 0 Carry 1 1 plus 1 is 0 carry 1 0 plus 0 plus 1 is 1 1 2 to the 5 and then we ended up here times 2 to the 5 as already 6 on to 42 And I've got 48 as a result. So he's done the maps and I could write that back now, but potentially we could have ended up with a 2 here if we added up 1 and 1 for example would get 2 and So we need to do a final step once we've done the addition which is to normalize this back potentially into the normal form which in this case would be 1 point 1 0 0 0 0 times 2 to the 5 so the reason that floating point numbers take much longer to process Is that as well as doing the addition which you can do in exactly the same way?
You also have to take the bits unpack them from the representation shift them along So they match up things then do the addition and then potentially shift them back to get it back into the normalized form the standard scientific Representation the other problem you get is even though we can pack all these numbers Into 32 bits the representation When we slide them along we may end up needing More than 32 bits as many as 48 To represent things because if we have to slide this one Along to the point here when we're doing the maps that we actually need 48 bits to do the calculation Of course That means you don't have to do on the 32 bit CP you've two additions for That half and then that half and carry the value over from one to the other which again would slow things down In hardware, you can build your representations to take care of this if you've got 64 bit doubles You know that you perhaps don't need more Than certain number of bits to represent you and you can build the hardware to take all this and it ends up being Much faster that must be quite fiddly to do with standard hardware So is that why we end up with this custom hardware this floating-point unit. It's not most much fiddly. I mean most computers Preserve the carry when they add two bradleys together so if you had two 32-bit numbers that produces value greater than 32 bits they preserve that bit and let you add it on so you can use multiple registers to do it But you just have to then do Two operations to add operations one after the other if you know the operations are going to do this You can build your hardware to do that in one go so we could build hardware that would add these together There are lots of things you can spot where you could early out So for example, if the exponent was such that these end up so far apart That you know adding this onto this where there's all zero bits along here assumed Isn't going to make any difference to this you can say, well actually I don't need to do that I'm just ignore it.
