[racket] Style and Performance question

On May 10, 2011, at 3:40 PM, Matthew Flatt wrote:

> At Tue, 10 May 2011 10:05:35 -0400, Matthias Felleisen wrote:
>> 2. The addition in lieu of the multiplication is consistently the fastest 
>> version of the three I mentioned last night: 
>> 
>>  (: the-sqrt : Real -> Real)
>>  (define (the-sqrt y)
>>    (let loop [(x (/ y 2.0))]
>>      (let [(error (- y (* x x)))]
>>        (if (< (abs error) epsilon) 
>>            x
>>            (loop (+ x (/ error (+ x x))))))))
>> 
>> Our compiler should probably implement reduction of strength optimizations 
>> based on this one experiment alone. The savings here are over 10%. 
> 
> In the variant where you divide by 2, are you using `2' or `2.0'?
> 
> I'd expect `(/ error 2.0 x)' to be faster than `(/ error (+ x x))' in
> the case that `x' and `error' are flonums, because it avoids a boxing
> step. But `(/ error 2 x)' would be slower, because it mixes a fixnum
> with floats.
> 
> Of course, if you want the code to go fast, either use flonum
> operations or make the type `Float':
> 
> (: my-sqrt : Natural -> Float)
> (define (my-sqrt y)
>   (let loop [(x (/ (exact->inexact y) 2.0))]
>     (let [(error (- y (* x x)))]
>       (if (< (abs error) epsilon) 
>           x
>           (loop (+ x (/ error (+ x x))))))))
> 
> Then it's unlikely to matter whether you use `(/ error (+ x x))' or `(/
> error 2 x)' because there's no representation mixing and flonums are
> unboxed.


I typed everything as Float (which is what I had last night). 

I tried (+ x x), 2.0 x, and 2 x on 5 x 1000 iterations over 1000 element lists.
The differences are noise (except for one freaky, large exception). 

-- Matthias