I'm forwarding my follow-up message about abs[x] to the intervals
list, which discusses the results of my surveys of other programming
languages that implement interval arithmetic. In short, they all seem
to use a definition of abs[x] that returns a more sensible interval, and
I'm strongly leaning toward changing Frink's implementation accordingly.
If I don't see anything to change my mind, pending some more research
within the next few days, it will be changed.

Thanks to Alan Stebbens for the discussion!

-------- Original Message --------
Subject: Re: [Reliable Computing] abs[x] for intervals?
Date: Tue, 14 Apr 2009 17:48:52 -0600
From: Alan Eliasen <eliasen@...>
To: reliable_computing@..., stds-1788@...
References: <49E45FCE.8050901@...>
<49E478B0.2060101@...>

Ralph Baker Kearfott wrote:
> In some applications, such as non-smooth optimization, you want
> "abs" to be the range of the absolute value, whereas, in other
> implementations, you want it to be the "magnitude," that is, the
> largest absolute value, rounded up, of any point in the argument
> interval. (Additionally, the "mignitude," or the smallest absolute
> value of any point in the interval, rounded down, is usually
> included, for a triad of extensions to the absolute value. The
> mignitude is useful, for example, in proving diagonal dominance
> of a matrix with uncertain entries.)
>
> In my Fortran 90 module INTERVAL_ARITHMETIC, I have ABS and MAG
> (and MIG).

To clarify, does your ABS function return an interval or a scalar?

From those who answered my questions about existing implementations,
including Dan Zuras' cited Vienna proposal, I see that they all have a
version of a version of abs[x] that returns an interval, (in the Vienna
proposal it's called AbsoluteHull) and then most have separate magnitude
and mignitude functions, of which the magnitude function returns a
scalar value which is defined the same way as the absolute value
function from Moore's book, which is, as noted before:

max[ abs[infimum[x]], abs[supremum[x]] ]

While the definition of abs[x] that returns an interval is as I cited
before or as the Vienna proposal cited. Be sure to add a missing
closing brace to my first case; that case should read:

abs[x] = [0, max[infimum[x], supremum[x]]]

I also researched Sun's C++ interval library implementation, (see
http://dlc.sun.com/pdf/819-3696/819-3696.pdf ) and table 2-15 and code
example 1-9 indicate that the fabs[x] function returns an interval as
well, and they have separate magnitude and mignitude functions that
return scalars. I'd assume that their FORTRAN implementation follows
the same convention, but I haven't verified this.

Boost also returns the value of abs(x) as an interval, and also has a
norm(x) function that returns Prof. Moore's definition.

Mathematica also follows my proposed rule, returning Abs[x] as an
interval.

It seems that returning abs[x] as an interval, and having separate
magnitude and mignitude functions appears to be the prevailing
implementation, which seems very reasonable to me.

I don't want to digress into a discussion of converting real-valued
code into interval code, (which is why I noted in my original posting
that I have the usual warnings about doing just that, but I appreciate
getting those eloquent warnings again,) but rather to discuss which
implementation of the abs[] function will follow the "Principle of Least
Surprise" for the user, even if they're writing new code from scratch,
keeping intervals in mind at all times.

It's very clear that the notation |x| or the phrase "absolute value
of x" has taken on many different meanings when applied to anything
other than real numbers. When considering intervals of real numbers,
it's probably least surprising to the user to choose the definition
that's as close as possible to the spirit of the definition for real
numbers, and not to adopt one of the less-relevant definitions used for
vectors or complex numbers or quaternions. The fact that other behavior
has caused surprise to users (including myself) is a good data point.

In addition, any choice of definition that loses information about
the original interval (such as by arbitrarily choosing to preserve one
endpoint and discard the other) would seem to be a worse default choice
than a definition that preserves some information about both endpoints
(and the "main/middle" value if it exists.) (I don't feel that it has
been explained adequately why one endpoint of an interval would be more
important than another, unless you're explicitly requesting one or the
other endpoint as in magnitude/mignitude or the related infimum/supremum.)

To me (and apparently to the authors of these other interval
packages,) the most expected behavior is to return the value of abs[x]
as an interval, and to also provide new magnitude and mignitude
functions that might represent other behaviors, the latter functions
requiring the user to explicitly specify which endpoint is more
important to them. I find this behavior very reasonable, and believe
that it would tend to present the least surprise to the user, and I am
convincing myself further (pending more implementation surveys and
perusal of interval texts by various authors) that I should modify my
implementation accordingly.

More input and answers to my original questions are still very much
welcomed. Thanks very much to those who have already responded. I'd be
interested to hear about more implementations.

--
Alan Eliasen | "Furious activity is no substitute
eliasen@... | for understanding."
http://futureboy.us/ | --H.H. Williams