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

Re: small integers, numerical efficiency

I agree with the recent message by Jim Allard r.e. numerics in Lisp.

Lisp is wonderful, but both its design and its implementations 
usually have a strong bias which hinders the use of the language 
for numerical algorithms.
  Bignums and rational numbers are (IMHO) useful for a relatively
specialized type of application- things like Macsyma.
These features are not generally used in what is probably
a much larger class of numerical algorithms.

David Moon (i recall) commented that he would rather see
floating point removed from Dylan than have a half-baked numeric
system like that in C.  Although I agree that the C (also fortran,...) 
numeric system is poorly designed, nevertheless in fact I would much 
rather see Dylan have a "normal" but efficient numeric system 
than Bignums!!!  The numeric system in Scheme, which may be
considered to be well designed, drives me nuts!

For the current discussion I would like to try to label myself 
as a 'non-AI' user of Lisp, the sort of programmer who will use Dylan.
In ~8 years of Lisp programming, I have
- used Lisp for languages and interactive code with excellent results
- used rational numbers only a couple of times
- never required bignums
- tried many wierd schemes to do efficient numeric work in a Lisp context
- still write most numerical code in C

Dylan is a rare opportunity; i also hope it does not inherit CL's numerical
inefficiencly and problems as described Jim Allard's message.  
Acceptable efficiency is matter of opinion; I would find Dylan 
acceptable for most uses if it were within 1/2-1/3 of the 
speed of C/etc. implementations.  

I am still looking forward to Dylan even if numerical efficiency is not 
practical (the issues are way over my head certainly), 
but I hope that at least an efficient and standard foreign function interface
can be provided.