Double vs DFloNum equivalency

[Per Bothner <per at bothner dot com>]

As mentioned, I'm trying to make uniform vectors more compatible
with Java arrays, and also trying to make "boxing" primitive number
types be the standard java.lang class.  Thus indexing a f64vector
returns a double which is boxed as a java.lang.Double.

That may break some existing code.  However, Java really wants
double to be boxed as Double, and for performance we want
indexing a f64vector to return a double when inlined.  So I think
we're being pushed to have f64vector-ref return a Double.

Long-term we might want to drop the DFloNum class and just
use Double, but I think that is too big a change for right now.
(I think it is worth pursuing in conjunction with using
invokedynamic for arithmetic (when compile-time type information
is lacking).

Surprising very little in the testsuite breaks.  One issue is
the tests for quaternion->rotation-matrix in quaternion-test.scm.
With my current changes, as an example (m1 0 0) returns a Double,
but 0.0 is a DFloNum.

One solution is to fix the test - see the attached patch.

Another solution is to treat DFloNum and Double objects with
identical (bit-bits) values for doubleValue as equivalent in
terms of eqv? and thus equal?.  I haven't tried this, since I
just through of it. It looks like a relatively simple
change to IsEqual.numberEquals might do it.  It might be a
better longer-term solution, especially if we end up moving
away from DFloNum.

Thoughts?
--
	--Per Bothner
per@bothner.com   http://per.bothner.com/

Index: testsuite/quaternion-test.scm
===================================================================
--- testsuite/quaternion-test.scm	(revision 8483)
+++ testsuite/quaternion-test.scm	(working copy)
@@ -167,19 +167,19 @@
        (m3 (quaternion->rotation-matrix (* q q q)))) ; 360 degrees
   ;; for a 120-degree rotation about (1,1,1),  +X->+Y, +Y->+Z, +Z->+X
   ;; m1 is #2a((0 0 1) (1 0 0) (0 1 0))
-  (test-equal '(0.0 1.0 0.0) (list (m1 0 0) (m1 1 0) (m1 2 0))) ; col 0
-  (test-equal '(0.0 0.0 1.0) (list (m1 0 1) (m1 1 1) (m1 2 1))) ; col 1
-  (test-equal '(1.0 0.0 0.0) (list (m1 0 2) (m1 1 2) (m1 2 2))) ; col 2
+  (test-equal '(0.0d0 1.0d0 0.0d0) (list (m1 0 0) (m1 1 0) (m1 2 0))) ; col 0
+  (test-equal '(0.0d0 0.0d0 1.0d0) (list (m1 0 1) (m1 1 1) (m1 2 1))) ; col 1
+  (test-equal '(1.0d0 0.0d0 0.0d0) (list (m1 0 2) (m1 1 2) (m1 2 2))) ; col 2
   ;; for 240 degrees, +X->+Z, +Y->+X, +Z->+Y
-  (test-equal '(0.0 0.0 1.0) (list (m2 0 0) (m2 1 0) (m2 2 0))) ; col 0
-  (test-equal '(1.0 0.0 0.0) (list (m2 0 1) (m2 1 1) (m2 2 1))) ; col 1
-  (test-equal '(0.0 1.0 0.0) (list (m2 0 2) (m2 1 2) (m2 2 2))) ; col 2
+  (test-equal '(0.0d0 0.0d0 1.0d0) (list (m2 0 0) (m2 1 0) (m2 2 0))) ; col 0
+  (test-equal '(1.0d0 0.0d0 0.0d0) (list (m2 0 1) (m2 1 1) (m2 2 1))) ; col 1
+  (test-equal '(0.0d0 1.0d0 0.0d0) (list (m2 0 2) (m2 1 2) (m2 2 2))) ; col 2
   ;; for 360 degrees, matrix is identity -- but we're on the other
   ;; side of the hypersphere: q^3 == -1
   (test-equal -1 (* q q q))
-  (test-equal '(1.0 0.0 0.0) (list (m3 0 0) (m3 1 0) (m3 2 0))) ; col 0
-  (test-equal '(0.0 1.0 0.0) (list (m3 0 1) (m3 1 1) (m3 2 1))) ; col 1
-  (test-equal '(0.0 0.0 1.0) (list (m3 0 2) (m3 1 2) (m3 2 2)))) ; col 2
+  (test-equal '(1.0d0 0.0d0 0.0d0) (list (m3 0 0) (m3 1 0) (m3 2 0))) ; col 0
+  (test-equal '(0.0d0 1.0d0 0.0d0) (list (m3 0 1) (m3 1 1) (m3 2 1))) ; col 1
+  (test-equal '(0.0d0 0.0d0 1.0d0) (list (m3 0 2) (m3 1 2) (m3 2 2)))) ; col 2
 (test-end "rotation-matrix")
 
 (test-begin "rotation-axis/angle")