[r6rs-discuss] Confusion over |p

From: William D Clinger <will>
Date: Fri, 29 Jun 2007 19:50:22 -0400

Sorry, I was thinking that (number->string 1.1 10 1)
was supposed to produce a string that represents the
best 1-bit approximation to 1.1. That's not true at
all; it's supposed to produce the string that uses
the fewest digits and the smallest p >= 1 that still
reads back in 1.1.

As Alan Watson pointed out, that means the first while
loop of my algorithm would normally crank p all the
way up near the precision of the representation, which
I will assume is 53. That means it would be better to
run the loop in the other direction. More importantly,
it means that first loop should terminate when x (the
1.1 of our example) rounded to p bits would no longer
be equal to x. That makes the algorithm a lot simpler
than I thought:

    s := (number->string x);
    p := 53;
    y := x;
    #| this loop terminates with p <= 53 |#
    while (and (< precision p)
               (eqv? y x)) {
        p := p - 1;
        #| compute the nearest p-bit approximation to x |#
        y := roundToNearest (x, p);
    }
    if (< precision p)
      then p := p + 1;
    return (string-append s "|" (number->string p));

Here is a table showing p and roundToNearest (x, p).
As before, I assume big-endian double precision.

    p roundToNearest (1.1, p)
    = =======================
   53 #x3ff199999999999a
   52 #x3ff199999999999a
   51 #x3ff1999999999998

So the loop terminates with p = 51, and p is immediately
incremented to 52. The result is "1.1|52".

I apologize again for the foolishness of my previous
message.

Will
Received on Fri Jun 29 2007 - 19:50:22 UTC