[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Proposed removal of tail operations

Hi, Dan,

I'd like to move the following at the April meeting.


Motion:  Remove section 5.13 (Tail Operations) from the draft.

Rationale (applicable to both binary and decimal FP):
1. The specified tail operations would presumably be used in head/tail
distillations for FP addition, subtraction and multiplication, but they
supply only the low magnitude component of such distillations (even
though they must presumably calculate head components in order to derive
their results).  The user is thus required to calculate the head
component and must take care to do so using the same rounding mode
(to-nearest) that is used in the tail calculation.

2. Although the draft describes the tail operations as exact, it is
unclear whether exceptions raised by the head calculation within each
tail operation must be suppressed.  If they are not suppressed, the
"exact" tail operations will often raise the INEXACT flag and may
sometimes raise odd combinations of flags, such as
OVERFLOW/INEXACT/INVALID in the case of tailadd(x,y) where x+y
overflows.  If head calculation exceptions must be suppressed, the
performance of tail operations may be drastically impaired on certain

3. The specifications for tailadd() and tailsub() are incomplete in that
they fail to cover all corner cases.  For example, what does
tailadd(+INF,0) return and what exceptions does it raise?  Note that
this example has an exact head calculation.  In the case of
tailadd(-0,-0), what is the sign of the zero tail result?

4. Although the specification for tailmultiply(x,y) is more specific
regarding results and exception flags (ignoring for the moment whether
head calculation exceptions propagate or are suppressed), certain
results are nonintuitive.  For example, if x*y overflows to +INF,
tailmultiply(x,y) returns -INF and raises no exception flags.  On the
other hand, if x = +INF and y = 1, the head component is again +INF, but
tailmultiply(x,y) returns a NaN and signals INVALID. Tailmultiply(-1,+0)
returns +0, so that head+tail = +0 (exactly) in this case, while x*y =
-0 (exactly).  

5. A user who requires head/tail distillation of addition, subtraction,
or multiplication should presumably be knowledgeable enough to implement
the distillation with a sequence of more primitive floating-point
operations provided by the standard.  Such a user would benefit from the
freedom to tailor the distillation to produce results and exception
flags tailored to his specific requirements and to his target FP

Edit changes:
 5.13:  remove entire section from the draft.

754 | revision | FAQ | references | list archive