On Jul 28, 2005, at 12:34 AM, William D Clinger wrote:

> ... the R5RS semantics of arithmetic
> was designed to allow systems to implement the computable reals...

This is a very interesting comment that expands my understanding of
numerics in Scheme.  I had realized earlier that Scheme's exact numbers
could be extended, e.g., to quadratic fields (with certain fixed m,
numbers are of the form a + b*sqrt(m), with a and b rational), but it
hadn't crossed my mind that the inexacts could be the computable reals.

I'm a "numerical" guy in the traditional sense, so most of my computing
is with floating-point (or fixed-point) arithmetic in Gambit.  Late in
the beta series for 4.0, the Gambit compiler was improved to generate
much faster "safe" code, so for some applications I've just used
standard Scheme code, perhaps with a few top-level declarations, so
some of that code should be easily run on any R5RS system.  (Maybe I'm
just getting older and prefer flexibility, safety, and "debugability"
over maximum speed for some applications.)  It had never occurred to me
before that calling exact->inexact on some Scheme systems would invoke
arithmetic in the computable reals.

There was a somewhat related discussion in comp.lang.lisp this spring
prompted by a newbie's complaint that

(- 0.9 0.5)

did not evaluate to 0.4 in the Common Lisp REPL.  Let me quote from

http://groups-beta.google.com/group/comp.lang.lisp/msg/
d452669476b6b4ea?hl=en

After pointing out that in Maxima, an application (now) written in
Common Lisp, 0.9-0.5 really *does*  evaluate to 0.4, Fred Gilham
writes:

> Seems like the issue is to distinguish between applications, which
> have user-related specs, and language-level representations, which
> have programmer-related specs.  The point is that there are floating
> point numbers which behave a certain way.  These numbers are intended
> for programmer use.  They behave the way they do because people have
> sat down and figured out that it's a good idea for them to behave that
> way.
>
> The fact that some person might type at the lisp REPL and expect it to
> act like a pocket calculator is not a good reason to change the way
> these numbers are represented.  It might be a good reason to write a
> "pocket calculator emulator" in common lisp, or to point someone at
> Maxima.

So I think the question is, "Do we want to separate user-related specs
from program-related specs?"  Do we want Scheme to be a language where
a conforming implementation could specify the computable reals as the
default inexact representation for all applications, or do we want
Scheme to be a language where inexact arithmetic is implemented by
floating-point arithmetic by default and the use of the computable
reals for inexact arithmetic can be specified (by loading a module, for
example) for certain applications?

 From my limited knowledge of Common Lisp, it seems that that community
has chosen the second path (going so far as to forbid the re-definition
of functions in the standard "Common Lisp" package, so you would have
to work in a new package before the arithmetic functions could be
shadowed by versions that use the computable reals).

Perhaps in Scheme we want to take a slightly different path---specify
floating-point as the default implementation but continue to allow
redefinition of standard functions.

Brad