anchor.diff:          (dotimes (i size)
             (setf (aref y1 i) (* mul (aref y1 i))
                   mul         (* mul root)))
  -        (check-eqv y1 y2)))))
  +        (check-eqv (bit-reverse y1)
  +                   (bit-reverse y2))))))
   
   (defun forward-test (size &optional (prob 1d-5))
  -  (let ((repeat (log (/ prob 2d0)))
  +  (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)))
  
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:            (type double-float tol))
    (let ((worst 0d0))
      (declare (type double-float 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)
  