anchor.diff:    (define-mfun m- -)
     (define-mfun m* *))
   
  -(defvar *default-abs-tol* 1d-9)
  +(defvar *default-abs-tol* 1d-6)
   
   (defun m= (x y &optional (tol *default-abs-tol*))
     (declare (type complex-sample-array x y)
  
positive.code:     (setf (aref dst 0) last)
      dst))
  
  (defun %forward-test-3 (size outer-repeat inner-repeat function)
    (let ((a (make-vector size))
          (b (make-vector size))
  
negative.code:         (funcall function diff)
          (m+ b diff b)
          (check-eqv y2 b))
        (let ((y1 (if *bit-reversed*
                      (slow-bit-reverse y1)
                      y1))
              (y2 (if *bit-reversed*
                      (slow-bit-reverse y2)
                      y2))
              (root (exp (* -2 pi (complex 0 1d0) (/ size))))
              (mul (complex 1d0 0d0)))
          (declare (type complex-sample root mul)
                   (type complex-sample-array y1 y2))
          (dotimes (i size)
            (setf (aref y1 i) (* mul (aref y1 i))
                  mul         (* mul root)))
          (if *bit-reversed*
              (check-eqv (slow-bit-reverse y1)
                         (slow-bit-reverse y2))
              (check-eqv y1 y2))))))
  
  (defun forward-test (size &key (prob 1d-5)
                              (maker 'make-forward-fun)
                              ((:bit-reversed *bit-reversed*) t))
    (let ((repeat (ceiling (log (/ 2d0 prob) 2d0)))
          (fun    (funcall maker size)))
      (assert (plusp repeat))
      (%forward-test-1 size repeat fun)
      (%forward-test-2 size repeat fun)
  