Re: Motion P1788/M003.01_Set_of_reals
I'm sorry but I noticed that I should clarify some of my remaks
Jueregn
Jürgen Wolff v Gudenberg schrieb:
Ian,
although the discussion period is over I think I should give some
comments on your reason to vote against metion 3.
Ian McIntosh schrieb:
I vote NO on Motion 3.
Infinity is needed, not just as a lower or upper bound, but as a
value. Lots of reasons:
I consider this as a special case of "Thou shalt not lie." Treating
an answer that should be +/-Infinity as not having an answer (empty)
is a form of lieing.
As interval arithmetic is defined as arithmetic for real numbers, there
is only one case among the 4 basic operation that is not defined.: The
division by 0. That will be specially treated by setting a flag. The
same happens with functions evaluated on a point which does not belong
to its domain. log([0,0]) may produce [-oo,-maxreal] and set the flag
This may seem to give more information But actually the value of log(0)
is not defined. Hence the result is the empty set
In case of division by zero which seems to be your main concern, you
have an odd singularity, so if you permit infinity as a number you may
return th set {-oo,+oo} which has to be enclosed by the interval
(-oo,+oo), the whole line, that does not give valuable information
For I3 = op (I1, I2), it should be true that if x is in I1 and y is in
I2, that x op y is in I3.
for every defined real basic arithmetic operation I3 is empty only if I1
or I2 is empty. dividion by zero is not allowed in a field
Saying I3 is Empty means you aren't answering
the question. Doing that when it's not necessary to is undesirable.
Empty has its own meaning and uses, and we shouldn't mash empty and
infinity together.
we don't do that
It's important for a standard to be inclusive, and not exclude valid
applications unnecessarily. There will be many applications of IA
beyond what is being done now.
I agree there may be and certainly will be extensions, John Pryce's
comments
One obvious example of a useful application would be to transform a
non-IA program into an IA one, to do error analysis. A very simple
example might be feeding millions of values into a math library sqrt
implementation (perhaps one that does multiple square roots in
parallel). The specification includes that sqrt (+Infinity) is
+Infinity, and sqrt (any quiet NaN) = the same quiet NaN. If IA
doesn't allow working with those values what do you do? Do those ones
by hand? Use some non-1788 IA system? And if you produce [Empty],
how do you distinguish values that should be infinity from those that
should be NaNs?
Infinities and NaN are not real numbers. You may have to convert them,
if you switch from floating-point to intervals.
Any standard will be more successful if it allows more uses. Some of
the IA uses will naturally produce or need to consume infinities.
No ! If you start with real numbers and apply the arithmetic which is
outlined in the Vienna proposal you do produce neither infinities nor NaNs
We
shouldn't rule all those out now, before we can even imagine them. A
couple of less obvious places IA could be useful:
- Project planning: Using IA ranges, calculate for example
task_time = 1 to 2.5 pw + 4.2 to 6 pw = 5.2 to 8.5 pw, then
that calendar_time = task_time / workers.
What if workers = 0? An infinite calendar time is more meaningful
and useful than an empty time.
An infinite calendar is noit meaningful for me.
I would suggest to improvve the software to check for exceptions.
Which bar on a graph shows management
where to add people - a tall bar with "oo" at the top, or an empty bar?
- Financial analysis: Using IA ranges for many possible investment
situations, calculate return_on_investment = profit / cost, then
sort them by value.
What if cost = 0? An infinite ROI is a lot better than an empty
one. Which one tells you more - "Take this freebie!" or "Sorry, I
couldn't calculate your results on this one."?
The point isn't that these applications should necessarily be
implemented using 1788 IA (but why shouldn't they?). It's that once
something is available, people will use it in ways we can't
anticipate, and for IA some (many?) of those uses will need
infinities. Even checking "Is the bridge safe?" can involve infinity
if the net support at some point is zero. The engineers need to know
that, not that after all that work they don't have an answer. Having
the 1788 standard force appllications to use some non-1788 system to
get useful results isn't beneficial to anybody.
The argument against including Infinities seems circular to me. If
you decide that IA is based on R, then you have to produce [Empty] for
expressions where the natural result is +/-Infinity.
Again there is no natural result infinity.
If a floating-point calculation overflows
I can produce the unbounded interval [maxreal,oo]
Juergen
--
=======
o Prof. Dr. J. Wolff v. Gudenberg, Informatik 2
/ \ Univ. Wuerzburg, Am Hubland, D-97074 Wuerzburg
info2 o Tel.: +49 931 / 31-86602 Fax: +49 931 / 888-6603
/ \ Uni e-mail: wolff@xxxxxxxxxxxxxxxxxxxxxxxxxxx
o o Wuerzburg http://www2.informatik.uni-wuerzburg.de/