anchor.diff:  
   (defun 0p (quat)
     (let ((w (w quat)) (x (x quat)) (y (y quat)) (z (z quat)))
  -    (cl:= 0f0 (+ (* w w) (* x x) (* y y) (* z z)))))
  +    (cl:= 0f0 (cl:+ (cl:* w w) (cl:* x x) (cl:* y y) (cl:* z z)))))
   
   (defun unitp (quat)
     (let ((w (w quat)) (x (x quat)) (y (y quat)) (z (z quat)))
  -    (cl:= 0f0 (- 1.0 (* w w) (* x x) (* y y) (* z z)))))
  +    (cl:= 0f0 (cl:- 1.0 (cl:* w w) (cl:* x x) (cl:* y y) (cl:* z z)))))
   
   (defun identity ()
     (q! 1.0 0.0 0.0 0.0))
   
   (defun identity-p (quat)
  -  (and (cl:= 0f0 (- 1.0 (w quat)))
  +  (and (cl:= 0f0 (cl:- 1.0 (w quat)))
          (cl:= 0f0 (x quat))
          (cl:= 0f0 (y quat))
          (cl:= 0f0 (z quat))))
  
positive.code:     (let ((cos-x (cos x-rot)) (sin-x (sin x-rot))
            (cos-y (cos y-rot)) (sin-y (sin y-rot))
            (cos-z (cos z-rot)) (sin-z (sin z-rot)))
        (q! (- (* cos-x cos-y cos-z) (* sin-x sin-y sin-z))
  	  (- (* sin-x cos-y cos-z) (* cos-x sin-y sin-z))
  	  (- (* cos-x sin-y cos-z) (* sin-x cos-y sin-z))
  	  (- (* cos-x cos-y sin-z) (* sin-x sin-y cos-x))))))
  
  (defun magnitude (quat)
    (let ((w (w quat)) (x (x quat)) (y (y quat)) (z (z quat)))
      (sqrt (+ (* w w) (* x x) (* y y) (* z z)))))
  
  (defun norm (quat)
    (let ((w (w quat)) (x (x quat)) (y (y quat)) (z (z quat)))
      (+ (* w w) (* x x) (* y y) (* z z))))
  
  (defun = (q1 q2)
    (and (cl:= 0f0 (- (w q2) (w q1))) (cl:= 0f0 (- (x q2) (x q1)))
         (cl:= 0f0 (- (y q2) (y q1))) (cl:= 0f0 (- (z q2) (z q1)))))
  
  ;;[TODO] This seems wrong!...but book says it's right
  (defun /= (q1 q2)
    (not (or (cl:= 0f0 (- (w q2) (w q1))) (cl:= 0f0 (- (x q2) (x q1)))
             (cl:= 0f0 (- (y q2) (y q1))) (cl:= 0f0 (- (z q2) (z q1))))))
  
  (defun copy (quat)
    (q! (w quat) (x quat) (y quat) (z quat)))
  
  (defun get-axis-angle (quat)
    (list
     (let ((length (sqrt (- 1.0 (* (w quat) (w quat))))))
       (if (cl:= 0f0 length)
           (v3:make 0.0 0.0 0.0)
           (let ((length (/ 1.0 length)))
             (v3:make (* length (x quat))
  		    (* length (y quat))
  		    (* length (z quat))))))
     (* 2.0 (acos (w quat)))))
  
  (defun normalize (quat)
    (let ((length-squared (v4:dot quat quat)))
      (if (cl:= 0f0 length-squared)
          (q0)
          (let ((factor (inv-sqrt length-squared)))
            (q! (* (w quat) factor)
  	      (* (x quat) factor)
  	      (* (y quat) factor)
  	      (* (z quat) factor))))))
  
  (defun qconjugate (quat)
    (q! (w quat) (- (x quat)) (- (y quat)) (- (z quat))))
  
  (defun inverse (quat)
    (let ((norm (norm quat)))
      (if (cl:= 0f0 norm)
          (identity)
          (let ((norm-recip (/ 1.0 norm)))
            (q! (* norm-recip (w quat))
  	      (- (* norm-recip (x quat)))
  	      (- (* norm-recip (y quat)))
  	      (- (* norm-recip (z quat))))))))
  
  (defun + (&rest quats)
    (apply #'v4:+ quats))
  
  (defun - (&rest quats)
    (apply #'v4:- quats))
  
  (defun *s (quat-a scalar)
    (v4:* quat-a scalar))
  
  (defun * (quat-a quat-b)
    (q! (- (* (w quat-a) (w quat-b))
  	 (* (x quat-a) (x quat-b))
  	 (* (y quat-a) (y quat-b))
  	 (* (z quat-a) (z quat-b)))
        (- (+ (* (w quat-a) (x quat-b))
  	    (* (x quat-a) (w quat-b))
  	    (* (y quat-a) (z quat-b)))
  	 (* (z quat-a) (y quat-b)))
        (- (+ (* (w quat-a) (y quat-b))
  	    (* (y quat-a) (w quat-b))
  	    (* (z quat-a) (x quat-b)))
  	 (* (x quat-a) (z quat-b)))
        (- (+ (* (w quat-a) (z quat-b))
  	    (* (z quat-a) (w quat-b))
  	    (* (x quat-a) (y quat-b)))
  	 (* (y quat-a) (x quat-b)))))
  
  (defun to-mat3 (quat)
    (let ((w (w quat)) (x (x quat)) (y (y quat)) (z (z quat)))
      (let ((x2 (+ x x)) (y2 (+ y y)) (z2 (+ z z)))
        (let ((wx (* w x2))  (wy (* w y2))  (wz (* w z2))
              (xx (* x x2))  (xy (* x y2))  (xz (* x z2))
              (yy (* y y2))  (yz (* y z2))
              (zz (* z z2)))
          (m3:make
           (- 1.0 (+ yy zz)) (- xy wz)         (+ xz wy)
           (+ xy wz)         (- 1.0 (+ xx zz)) (- yz wx)
           (- xz wy)         (+ yz wx)         (- 1.0 (+ xx yy)))))))
  
  (defun to-mat4 (quat)
    (let ((w (w quat))  (x (x quat))  (y (y quat))  (z (z quat)))
      (let ((x2 (+ x x)) (y2 (+ y y)) (z2 (+ z z)))
        (let ((wx (* w x2))  (wy (* w y2))  (wz (* w z2))
              (xx (* x x2))  (xy (* x y2))  (xz (* x z2))
              (yy (* y y2))  (yz (* y z2))
              (zz (* z z2)))
          (m4:make
           (- 1.0 (+ yy zz)) (- xy wz) (+ xz wy) 0.0
           (+ xy wz) (- 1.0 (+ xx zz)) (- yz wx) 0.0
           (- xz wy) (+ yz wx) (- 1.0 (+ xx yy)) 0.0
           0.0 0.0 0.0 1.0)))))
  
  (defun dot (quat-a quat-b)
  
negative.code: ;; [TODO] Look into assets (this should be a unit quaternion
  (defun rotate (vec3 quat)
    "Rotate vec3 by quaternion. Assumes quaternion is normalized."
    (let* ((v-mult (cl:* 2.0 (cl:+ (cl:* (x quat) (aref vec3 0))
  				 (cl:* (y quat) (aref vec3 1))
  				 (cl:* (z quat) (aref vec3 2)))))
           (cross-mult (cl:* 2.0 (w quat)))
           (p-mult (cl:- (cl:* cross-mult (w quat)) 1.0)))
      (v3:make (cl:+ (cl:* p-mult (aref vec3 0))
  		   (cl:* v-mult (x quat))
  		   (cl:* cross-mult
  			 (cl:- (cl:* (y quat) (aref vec3 2))
  			       (cl:* (z quat) (aref vec3 1)))))
  	     (cl:+ (cl:* p-mult (aref vec3 1))
  		   (cl:* v-mult (y quat))
  		   (cl:* cross-mult
  			 (cl:- (cl:* (z quat) (aref vec3 0))
  			       (cl:* (x quat) (aref vec3 2)))))
  	     (cl:+ (cl:* p-mult (aref vec3 2))
  		   (cl:* v-mult (z quat))
  		   (cl:* cross-mult
  			 (cl:- (cl:* (x quat) (aref vec3 1))
  			       (cl:* (y quat) (aref vec3 0))))))))
  
  ;; [TODO] Could be faster (see q+1 area)
  (defun lerp (start-quat end-quat pos)
  