Floating Point number format

Description

BBC BASIC stores real (non-integer) numbers in five bytes in a format known as "five-byte floating point". This splits the number into two components - a one-byte exponent and a four-byte mantissa.

All numbers, other than zero, can be expressed as m*10^e. You may be familiar with this form known as exponential format. For example:

   100 is 1*10^2
   5000 is 5*10^3
   0.5 is 5*10^-1.

Exactly the same can be done using base 2, expressing numbers as m*2^e, for example:

   4 is 1*2^2
   -8 is -1*2^3
   12 is 1.5*2^3
   -0.5 is -1*2^-1

In five-byte floating point format, the manitissa is normalised by being multiplied or divided by 2, and the exponent reduced or increased, until the mantissa m is in the range 0.5 to 1, excluding 1, for example:

   4 is 0.5*2^3
   -8 is -0.5*2^4
   12 is 0.75*2^4
   -0.5 is -0.5*2^0

This means that the first bit of the mantissa is always 1. That means it can be used to hold the sign bit.

To allow negative exponents an excess is added to it. Acorn BASICs use excess &80, where &80 represents an exponent of 0; Russell BASICs uses excess &7F, where &7F represents an exponent of 0.

So, for example on Acorn BASICs:

   4 is exponent &83, mantissa &00000000
   -8 is exponent &84, mantissa &80000000
   12 is exponent &84, mantissa &C0000000
   -0.5 is exponent &80, mantissa &00000000

Zero is a special case and is stored as five zero bytes. Some versions of BBC BASIC extend this and use a zero exponent to indicate that the real actually holds an integer value. For example:

   &00, &00000000 is 0
   &00, &00000080 is 128 (where implemented)
   &00, &FFFFFFFE is -2 (where implemented)

To convert a real to an integer the mantissa must be multiplied by two and the exponent consequently decreased until the exponent is zero (ie &80 on Acorn BASICs, &7F on Russell BASICs), a process known as denormalisation. For example, converting 0.5*2^3 back to 4*2^0.

Of course, if the real holds a noninteger, then when the mantissa is multiplied some bits will overflow before the exponent has reached zero. Depending on what you want to do with the denormalised number, a program would either ignore those overflowed bits, giving a truncated integer, or the overflow flags an error to indicate that the real could not be denormalised to an integer.

Implementations

Acorn BASICs

Acorn BASICs store reals in memory high-to-low as:

   mantissa.hi, mantissa.middle, mantissa.middle, mantissa.lo, exponent

The only 32-bit integer Acorn BASICs allow to be stored in a real is zero. Acorn BASICs use excess-&80 for the exponent, so &80 represents an exponent of zero.

Russell BASICs

Russell BASICs store reals in memory low-to-high as:

   mantissa.lo, mantissa.middle, mantissa.middle, mantissa.hi, exponent

Russell BASICs allow any 32-bit integer to be stored in a real by setting the exponent to zero. Russell BASICs use excess-&7F for the exponent, so &7F represents an exponent of zero.

PDP11 BASIC

J.G.Harston's PDP-11 BASIC stores reals in memory low-to-high, and allows 32-bit integers to be stored by setting the exponent to zero, as in Russell BASICs.

See Also

• Denormalising_a_number
• Normalising_a_number

Jgharston 23:26, 30 April 2008 (BST)