# Re: Exactness

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

```bear <bear@xxxxxxxxx> writes:

> The problem with exactness and inexactness, it appears, is that
> many implementors don't feel that it's worth implementing fully.

I disagree. The problem is that R5RS tries to describe it as one of
two fields of a number, the other being its value - while in reality
it's a predicate about the representation of the value, not
independently settable.

> And they have a point, I guess, in that a full implementation of
> and every fundamental mathematical function.

Suppose we have two flonums tagged as exact. You divide them, and the
result is not a finite binary fraction, so the implementation can't
use the same representation for the result. What should it do?

a) Represent it in a flonum tagged as inexact.
b) Represent it as an exact ratio of two integers.

In case a) exactness of flonums would be almost useless, because most
fp data except initial inputs would be inexact - most fp operations
must round data. Not only division; mere multiplication quickly runs
out of space for representing all digits. Since exactness doesn't
influence how computation proceeds, you could use it only to check the
confidence of the implementation that the answer is correct, which is
not strictly true anyway because of predicates returning exact
booleans.

In case b) using flonums to represent exact numbers would be almost
useless, because most exact data except initial inputs would be
converted to ratios - most fp operations must use some other type for
the result to represent it fully accurately. The implementation could
as well use ratios for all exact rational numbers and results will be
the same, so exact doubles are redundant.

R5RS doesn't specify what happens. For the first sight it seems to
suggest a), but actually it encourages to implement b). It mandates it
even for operations that integers are closed under, as long as the
given exact integer is representable at all.

I claim that the practical utility of numbers represented as fixnums,
bignums or ratios but tagged as inexact is close to zero, and similarly
for flonums tagged as exact.

> So they usually make the dodges and hacks that the standard fails to
> forbid, specifically making exactness correspond to representation
> type information rather than being orthogonal to type.

And that's good, it's not orthogonal. If it was, using different
representations for numbers of the same value and the same precision
would be redundant. R5RS even specifies that such numbers would be
indistinguishable (even more: the precision is not compared but the
exactness only, which is wrong if there are several possible amounts
of inexact precision, and SRFI-77 fixes that).

> Furthermore, treating exactness as type information actively
> messes up people who are trying to use it as exactness; having
> different numeric ranges and precisions for example, for exact
> and inexact numbers leads to all kinds of inconsistencies and
> problems.

I presume then that since (factorial 100) preserves all 158 digits,
you want (factorial 100.0) to produce a result with 158 digits but
tagged as inexact, right? But this would make impossible to reason
about complexity of numerical algorithms. Fixed-size flonums have a
constant cost of primitive operations; this would no longer be true.

it in the painful way), which is a necessary evil. But taking away
the remaining tool for approximate computation with constant cost of
primitive operations would be impractical.

> And the question comes down to this; in view of the widespread
> rebellion against fully implementing exactness among scheme system
> authors, and the harm caused by conflating exactness with type,
> should exactness remain part of the standard?

It should be described as a property which can be inferred from the
representation, not as an independently settable field.

> Or maybe we should make the whole concept optional, and explictly
> forbid any exact/inexact distinctions at all except in implementations
> where it really *is* information orthogonal to representation type.

Are there any implementations where it is?

> I'd like to see more full implementations of exactness, but I'm not
> going to recommend that the standard actually require it; this
> appears to be a situation where making a demand that very few would
> bother to implement would just undermine the authority of the
> standard.

Indeed. If everybody ignores something in the standard, it's should
raise suspections that the standard has made an unfortunate decision.

--
__("<         Marcin Kowalczyk
\__/       qrczak@xxxxxxxxxx
^^     http://qrnik.knm.org.pl/~qrczak/

```