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

Re: inexactness vs. exactness

This page is part of the web mail archives of SRFI 70 from before July 7th, 2015. The new archives for SRFI 70 contain all messages, not just those from before July 7th, 2015.

Limiting the precision to that of the most-precise inexact argument,
as suggested by Will Clinger and myself at different times, seems
like a relatively practical thing to do (explanations below).
However, it would be forbidden by the current suggested wording,
because it runs against the principle of using a particular inexact
value (expressible in, say, four words because one of the arguments
was an inexact with four words of precision) when there are inexact
values (which are expressible in 1024 words) that are actually
closer to the mathematically expected result.

On Sun, 31 Jul 2005, Paul Schlie wrote:

>> From: bear <bear@xxxxxxxxx>
>> I know that it's not the right thing in all cases and all times,
>> but I think it's a good thing in most of the cases I use, for
>> an operation on exact arguments whose mathematically correct
>> result is too large to be represented as an exact number, to
>> (silently) return an inexact number of the highest available
>> precision.

>- As personally I think it's poor idea to place the responsibility
>  to limit the precision of exact data such that calculations will
>  not exceed the practical physical limitations of an exact
>  implementation's representational capabilities on the programmer,
>  but rather believe that it's the responsibility of the implementation
>  to endeavor to limit the precision of an exact value's representation
>  to some practical physical limit in an effort to prevent such
>  scenarios; I'd rather see it become acceptable that an exact
>  implementation may return an imprecise exact value limited to some
>  implementation defined precision limit, where the precision limit
>  of an exact value's representation is presumed to be greater than
>  the precision supported by an inexact value's representation.

Uh, this is faint and fuzzy thinking; no matter what the precision
limit, if you have a situation where you're not getting the
exact mathematically correct result, you must mark the result as
being an inexact number.  There is no limit on the size of the
representation for inexact numbers; the "highest available precision"
for inexacts may be several kilobytes long depending on what the
implementation's author did.

I agree with you, I think, about the desirable behavior: use exact
results until they get too big, and then switch to inexact results
_of_about_the_same_representational_precision to prevent further
out-of-control growth.

Unfortunately, most implementors limit inexacts to 64 bit (or even
32 bit) real values, and therefore have drastically different precision
ranges and limits available for exact and inexact numbers.

>  As this would imply that such an exact implementation may have some
>  practical precision limit, it correspondingly must either be defined
>  to have the same representational magnitude bounds as an inexact
>  implementation, or by implication have distinct infinite and reciprocal
>  bounds defined. (where the former seems simplest, although apparently
>  only suggested in jest earlier).

Ehhh.  Only half in jest.  Most of these problems do go away if you
provide inexact numbers as big and precise as your exact numbers;
But general-purpose schemata can't really be expected to do so, since
most of them want blazing speed out of inexact numbers and are perfectly
happy with inexact precision limited to 64 bits.  I think I'd be happy
in a scheme that represented numbers in up to 1024 words of memory,
whether exact or inexact, marked them "inexact" if that wasn't enough
to hold the correct answer but was enough to hold an approximation
within reasonable roundoff errors, and returned an error object if
the result was actually out of range (beyond the highest/lowest
representable number).

But for certain kinds of calculations, you'd still want a way to
specify a much lower "precision limit" in order to get wrong answers
really really fast.  An example is most iterative adaptive algorithms;
you get closer to the correct answer by making more iterations, much
faster rather than by carrying each iteration out to 1024 words of
precision.  And since those answers were doomed to be wrong anyway
(since they usually home in on irrationals) and the correctness is
not usually very critical within a small roundoff error, why *not*
limit them to 4 words of precision?

So, I think it's desirable to have a numeric system where inexacts
have a range of different precisions, depending on the precision
of the arguments to the procedures that produced them as results.
But this is where we violate the principle of always using "the"
closest representable inexact value to the mathematically correct