anchor.diff:             (type double-float tol))
     (let ((worst 0d0))
       (declare (type double-float worst))
  -    (map nil (lambda (x y)
  -               (let ((delta (abs (- x y))))
  -                 (if (< delta tol)
  -                     (setf worst (max worst delta))
  -                     (return-from m= (values nil delta)))))
  -         x y)
  -    (values t worst)))
  +    (dotimes (i (length x))
  +      (let ((x (aref x i))
  +            (y (aref y i)))
  +        (let ((delta (abs (- x y))))
  +          (if (< delta tol)
  +              (setf worst (max worst delta))
  +              (return-from m= (values nil delta i))))))
  +    (values t worst nil)))
   
   (defun make-forward-fun (size)
     (compile nil `(lambda (vec)
  
positive.code:                   vec)))
  
  (defun check-eqv (a b &optional (name "Test"))
    (multiple-value-bind (ok diff)
        (m= a b)
      (assert ok ()
              "~A failed with delta ~A~%" name diff)))
  
  (defun %forward-test-1 (size repeat function)
    (let ((a (make-vector size))
  
negative.code:         (dotimes (i size)
            (setf (aref y1 i) (* mul (aref y1 i))
                  mul         (* mul root)))
          (check-eqv (bit-reverse y1)
                     (bit-reverse y2))))))
  
  (defun forward-test (size &optional (prob 1d-5))
    (let ((repeat (ceiling (log (/ 2d0 prob))))
          (fun    (make-forward-fun size)))
      (assert (plusp repeat))
      (%forward-test-1 size repeat fun)
      (%forward-test-2 size repeat fun)
      (%forward-test-3 size repeat (+ repeat 2) fun)))
  