From: John McClain
Subject: CL and Floating Point
Date: 
Message-ID: <PDP8.94Jun29110559@teenage-mutant.ai.mit.edu>
Last March there was a discussion in comp.lang.lisp about the quality
of various Common Lisp implementation w.r.t. floating point arithmetic.

To summarize:

	You can get good FP code out of CL but its sensitive to
	seemingly minor protobations in the source code.  This problem
	is compounded by the fact that for any two implementations of
	CL they will have different idiosyncrasies w.r.t. to FP code
	generation.

	You can have problems with excessive consing

	One example of bad FP was Lucid CL where you can't pass or
	return unboxed floats to/from functions.

	You could pass floats around as arrays but this is often klugy
	and did not always work (ie Lucid not optimizing 0-d
	double-float arrays)

Its also my impression that you have no hope for good FP if you
program without declarations (scheme any one?).  Can a simmilar
statement be made about safety? 

I rather not have usenet be my only citation on this matter; does
anyone know of a reference that talks about these issues. [I do have
"Fast Floating-Point Processing in Common Lisp" which speeks to this
somewhat, but it does not talk about why CL is slower than optimized
FORTRAN]

Just so you all know what axe I am grinding, my thesis is a Lisp
friendly architecture and I am looking for a justification of memory
type tags/type checking logic.

John "LispMs R Us" McClain