There are some minor differences between the 8087, 80287 floating point coprocessors and later versions. The major difference is probably the handling of infinity and NaN's. The 8087 and 80287 default to using projective infinity. The later fpu's default to using affine infinity, that is, plus and minus infinity are different. There are some other minor differences as well.

The exponent is stored as an integer, regarded as unsigned. This is achieved by adding an offset, a bias, to the actual (or logical) exponent.

The biased exponent with all bits 0 is reserved for zero and denormals.

The biased exponent with all bits 1 is reserved for the two infinities and for NaN's. NaN means Not a Number. NaN's propagate through a calculation and eventually may signal an exception. The details do not concern us here and are, in any case, not well enough known by me to discuss them. They may be found in the Intel literature.

A normalized number is a number in which the integer part (most significant bit) of the mantissa (significand) is 1. In the packed formats this bit is not explicitly stored. Thus the logical length of the mantissa is one bit more than the physical length. Of course, we have to unpack the number (that is, insert the missing bit) before doing any arithmetic. Internally the coprocessor uses 80 bit registers. It automatically unpacks fp numbers when loading the registers, and packs them when storing them to memory, at least for those formats which are less than 80 bits long. There is no packed 80 bit format, since the coprocessor's registers would not be long enough to unpack it.

A denormalized number (denormal) is a number in which the integer part (most significant bit) of the mantissa is 0 and the biased (physical) exponent is 0. An unnormalized number (unnormal) is a number in which the integer part of the mantissa is 0 and the exponent is arbitrary. Note that unnormals can occur only in the unpacked format (extended precision) since otherwise we have no way to recognize them!

While denormals and unnormals are necessary in the course of a calculation the denormals may also occur in the stored formats to represent (with a loss of significance) very small numbers. This scheme allows the coprocessor to underflow gracefully. The physical exponent 0 is reserved to indicate a denormal. Since the biased or physical exponent 0 signals a denormal we do not need to store the leading bit, which is 0, of the mantissa, except when we wish to do actual arithmetic. Thus in the packed formats we omit the leading bit also for denormals.

Note that we can store integers as floating point numbers, but for very large integers the gap between successive exactly storable integers becomes larger than one. Still this gives a much larger range of integers than would be available with ordinary integer storage (that is, fixed point). The c language provides some useful functions for handling floating point integers: floor(), ceil() and fmod(). Thus floor(x) returns the largest floating point integer less than or equal to x. If  x  is very large then floor(x) may be much smaller than the greatest integer in  x, gid(x), if gid(x) can not be stored exactly.

The largest floating point integer N such that N-1 is also a floating point integer (that is, exactly representable) is called the largest fp integer with a predecessor. It is of course much smaller than the largest fp integer.

The unit round is the smallest positive exactly representable floating point number u such that 1.0 + u > 1.0. It is very easy to write code to determine the unit round but one will obtain incorrect results unless one allows for the fact that the coprocessor uses the full 80 bit precision internally and also that some compilers are very clever about eliminating "useless" loops.

It is not difficult to see that for any real number y (within the range of normalized fp numbers) if fp(y) is its floating point representative then

y = fp(y) + e y

where |e| < u and where u is the unit round. This is if we chop the mantissa of y to obtain fp(y). If instead we round the mantissa of y to obtain fp(y) then we have |e| < u/2.

The largest fp integer with a predecessor and the unit round are convenient measures of the precision of the floating point representation.

Note if M is the largest logical exponent for normalized fp numbers and n is the number of logical bits in the mantissa then the largest normalized floating point magnitude (apart from infinity) is

N = 2^M (2 - 2^1-n).

Here we have used

(1 + 2^-1 + ... + 2^1-n)  =  2 - 2^1-n

and we have assumed 1<= mantissa < 2 is the normalization used for the mantissa. Since the binary point is not actually stored we have to have some agreement about where it falls. Another common convention is 1/2 <= mantisa < 1. Since M >= n in the formats below we see N is an integer, and so is the largest fp integer. If N₀ it the largest floating point integer with N₀ < N then

N - N₀ = 2^M-n+1,

a very large integer. Thus N₀ and N are very far from being consecutive.

The 32 bit fp format

The 64 bit fp format

The 80 bit fp format

Corrections are welcome!  petersen@math.orst.edu

References

Robert L. Hummel, PC Magazine: Programmer's Technical Reference: The Processor and Coprocessor, Ziff-Davis Press, Emeryville, California, 1992.

Stephen P. Morse, Eric J. Isaacson, Douglas J. Albert, The 80386/387 Architecture, John Wiley & Sons, Inc., New York, 1987.

Richard Startz, 8087 Applications and Programming for the IBM PC, XT, and AT, Revised and Expanded, Prentice Hall, New York, 1985.

John F. Palmer, Stephen P. Morse, The 8087 Primer, John Wiley & Sons, New York, 1984.

Intel Corporation, i486 Processor Programmer's Reference Manual, Intel, Osborne McGraw-Hill, 1990.

Mth 351 Index