ACRITH-XSC

[David Hough]

is a Fortran compiler embodying the notions expressed in several books
by Kulisch, Miranker,  and others.   The intent is to obtain narrow
intervals containing numerical results by exploiting exact dot products.
This implies (probably, but not necessarily) one accumulator per system
wide enough to contain such products.  One designed to support IEEE
double precision but be designed to accomodate the sum of (2**-1074)**2
and (2**+1024)**2, implying an accumulator at least 4200 bits wide,
with multicycle carry propagate to say the least.
Such devices are available microcoded in some IBM mainframes and some
other Nixdorf systems, I think, and in software implmentations on
a variety of machines.  Besides the Fortran language described here,
there is also a Pascal-SC language to do these calculations, and a
body of software for obtaining reliable interval bounds
for common computations of mathematical software.

This work emanates primarily from Kulisch's group in Karlsruhe and has
gained some acceptance in Europe but little in the USA.  GAMM,
a European applied math group, has formally endorsed the notion that
computing systems should supply correctly-rounded dot products.

The principal objection to this system involves efficiency:
what is needed and useful can be obtained with conventional interval
arithmetic far more economically.  Not all problems lend themselves
readily to solution via correctly-rounded dot products.  The point
is difficult to prove either way because comparisons are hypothetical:
there have been no high-performance
hardware implementations of the dot product accumulator, and no
high-performance software implementations of conventional
interval arithmetic in a higher level language on a system that could
support it well, such as any of the RISC architectures with IEEE 754 
floating-point hardware.

The test metric would be: for several classical numerical problems,
what's the slowdown ratio for obtaining realistic interval results
relative to algorithms of comparable stability and cleverness
that obtain point results only?
This is tricky because comparably stable and clever 
point and interval algorithms
for the same problem are usually completely different.