anchor.diff:                      (cl:* length (z quat))))))
      (cl:* 2.0 (acos (w quat)))))
   
  -(defun normalize (quat)
  -  (let ((length-squared (v4:dot quat quat)))
  +(defn normalize ((quat quaternion)) quaternion
  +  ;;(declare (optimize (speed 3) (safety 1) (debug 1)))
  +  (let ((length-squared (dot quat quat)))
       (if (cl:= 0f0 length-squared)
           (0!)
           (let ((factor (inv-sqrt length-squared)))
  
positive.code: 
  ;;----------------------------------------------------------------
  
  (defun w (quat)
    "Returns the w component of the quaternion"
    (aref quat 0))
  
  (defun x (quat)
    "Returns the x component of the quaternion"
    (aref quat 1))
  
  (defun y (quat)
    "Returns the y component of the quaternion"
    (aref quat 2))
  
  (defun z (quat)
    "Returns the z component of the quaternion"
    (aref quat 3))
  
  ;;----------------------------------------------------------------;;
  
  (declaim (inline q!)
           (ftype (function (single-float
                             single-float
                             single-float
                             single-float)
                            quaternion)
                  q!))
  (defun q! (w x y z)
    "This takes 4 floats and give back a vector4, this is just an
     array but it specifies the array type and populates it.
     For speed reasons it will not accept integers so make sure
     you hand it floats."
    (declare (single-float x y z w))
    (let ((q (make-array 4 :element-type `single-float)))
      (setf (aref q 0) w
            (aref q 1) x
  
negative.code:     (+ (*s start-quat start-mult)
         (*s end-quat end-mult))))
  
  (defn approx-slerp ((start-quat quaternion) (end-quat quaternion)
  					(pos single-float)) quaternion
    (declare (optimize (speed 3) (safety 1) (debug 1)))
    (let* ((cos-angle (dot start-quat end-quat))
           (factor (expt (cl:- 1.0 (cl:* 0.7878088 cos-angle)) 2.0))
           (k (cl:* 0.5069269 factor))
           (b (cl:* 2.0 k))
  