Path: utzoo!attcan!uunet!portal!cup.portal.com!mmm
From: mmm@cup.portal.com (Mark Robert Thorson)
Newsgroups: comp.arch
Subject: IEEE 754 vs. 854 (floating-point arithmetic)
Message-ID: <18721@cup.portal.com>
Date: 24 May 89 01:23:07 GMT
Organization: The Portal System (TM)
Lines: 29

As near as I can tell, the only difference between 754 and 854 is the
treatment of massive overflow and underflow.

Massive overflow and underflow are the conditions which result when the
result of an operation cannot be expressed as a denormalized number.
IEEE arithmetic uses a format in which the exponent is biased (e.g. an
exponent of 1 with a bias of 8192 is expressed as 8193).
When a result exceeds the range of the exponent, a larger bias is used,
and a special code is used to indicate that a "denormalized" result has
been generated.

If a result exceeds the number range which can be represented by denormalized
numbers, the condition known as "massive overflow" or "massive underflow"
occurs.

Under IEEE standard 754, this condition is indicated by a quiet NaN.
(A NaN is a representation for "not a number"; i.e. an error condition.)

Under its successor, IEEE standard 854, you have the option of returning a
quiet NaN, or +/- infinity or zero.

My question is:  Is there any program (other than Kahan's test suite) which
is sensitive to the treatment of massive underflow/overflow?

Related question:  How does your programming environment handle IEEE weirdness?
What happens when I scale a number, and the number range craps out?  Does a
trap get invoked?  If so, is the trap in the user program or the OS?  Does
anybody support a programming environment in which the application program
can make use of the fancy bits of the IEEE standard?