Re: 0^0 oh no!

Daniel Lichtblau wrote:

I'm not convinced this is a bad thing, so much as a bad usage of
SetPrecision (in Mathematica; I suspect there are similar functions in
other programs). What it can do is to expose guard bits, in the sense
of claiming "regard these bad bits as good bits". Returning to the

When writing some iterative numerical method, where you know that the
iteration converges, but significance arithmetics won't be able to
detect this fact (*), you'd use SetPrecision to tell the system to
regard those bits as good, or do I miss something again? That would lead
to a genuine usage of that function where it would cause things like o1
== o2, yet f(o1) != f(o2), as I mentioned.

(*) This is not a critique on significance arithmetics. It has been a
rather long time until interval numerical analysts found out why some of
the rather basic linear algebra algorithms actually return much more
precise results than could be expected from analyzing individual steps.
This is even true for non-iterative algorithms such as Gaussian
elimination. I would expect direct application of significance
arithmetics to yield equally pessimistic estimates for the result precision.

In[28]:= SetPrecision[sum2plus,5] == SetPrecision[sum2,5]
Out[28]= False

But these new objects really ARE different, because we promoted bad
bits to become good bits.

And, in my interpretation, that implies that the old objects are
different, too. After all, there is a way to tell them apart. But I
realize that different programming languages have different operators
for equality, equivalence, identity, etc.

--
if all this stuff was simple, we'd
probably be doing something else. -- Daniel Lichtblau, s.m.symbolic
.