anchor.diff:  
   ;;---------------------------------------------------------------
   
  -(declaim (inline length)
  -         (ftype (function (vec3) single-float)
  -                length))
  -(defun length (vector-a)
  +(defn length ((vector-a vec3)) single-float
     "Returns the length of a vector
      If you only need to compare relative lengths then definately
      stick to length-squared as the sqrt is a slow operation."
  -  (declare (vec3 vector-a))
  +  (declare (optimize (speed 3) (safety 1) (debug 1)))
     (sqrt (length-squared vector-a)))
   
   ;;---------------------------------------------------------------
   
  -(declaim (inline distance-squared)
  -         (ftype (function (vec3 vec3) single-float)
  -                distance-squared))
  -(defun distance-squared (vector-a vector-b)
  +(defn distance-squared ((vector-a vec3) (vector-b vec3)) single-float
     "finds the squared distance between 2 points defined by vectors
      vector-a & vector-b"
  -  (declare (vec3 vector-a vector-b))
  +  (declare (optimize (speed 3) (safety 1) (debug 1)))
     (length-squared (- vector-b vector-a)))
   
   ;;---------------------------------------------------------------
   
  -(declaim (inline distance)
  -         (ftype (function (vec3 vec3) single-float)
  -                distance))
  -(defun distance (vector-a vector-b)
  +(defn distance ((vector-a vec3) (vector-b vec3)) single-float
     "Return the distance between 2 points defined by vectors
      vector-a & vector-b. If comparing distances, use
      c-distance-squared as it desnt require a sqrt and thus is
      faster."
  -  (declare (vec3 vector-a vector-b))
  +  (declare (optimize (speed 3) (safety 1) (debug 1)))
     (sqrt (distance-squared vector-a vector-b)))
   
   ;;---------------------------------------------------------------
   
  -(declaim (inline abs)
  -         (ftype (function (vec3) vec3) abs))
  -(defun abs (vector-a)
  +(defn abs ((vector-a vec3)) vec3
     "Return the vec3 containing the abs of the original vec3's components."
  -  (declare (vec3 vector-a))
  -  (make (cl:abs (x vector-a)) (cl:abs (y vector-a)) (cl:abs (y vector-a))))
  -
  -;;---------------------------------------------------------------
  -
  -(declaim (inline absolute-dot)
  -         (ftype (function (vec3 vec3) single-float)
  -                absolute-dot))
  -(defun absolute-dot (vector-a vector-b)
  +  (declare (optimize (speed 3) (safety 1) (debug 1)))
  +  (make (cl:abs (x vector-a))
  +        (cl:abs (y vector-a))
  +        (cl:abs (y vector-a))))
  +
  +;;---------------------------------------------------------------
  +
  +(defn absolute-dot ((vector-a vec3) (vector-b vec3)) single-float
     "Return the absolute dot product of the vector-a and vector-b."
  -  (declare (vec3 vector-a vector-b))
  -  (cl:+ (CL:ABS (cl:* (AREF VECTOR-A 0) (AREF VECTOR-B 0)))
  -        (CL:ABS (cl:* (AREF VECTOR-A 1) (AREF VECTOR-B 1)))
  -        (CL:ABS (cl:* (AREF VECTOR-A 2) (AREF VECTOR-B 2)))))
  -
  -;;---------------------------------------------------------------
  -
  -;; [TODO] shouldnt this return a zero vector in event of zero
  -;; length? does it matter?
  -(declaim (inline normalize)
  -         (ftype (function (vec3) vec3)
  -                normalize))
  -(defun normalize (vector-a)
  +  (declare (optimize (speed 3) (safety 1) (debug 1)))
  +  (cl:+ (cl:abs (cl:* (aref vector-a 0) (aref vector-b 0)))
  +        (cl:abs (cl:* (aref vector-a 1) (aref vector-b 1)))
  +        (cl:abs (cl:* (aref vector-a 2) (aref vector-b 2)))))
  +
  +;;---------------------------------------------------------------
  +
  +(defn normalize ((vector-a vec3)) vec3
     "This normalizes the vector, it makes sure a zero length
      vector won't throw an error."
  -  (declare (vec3 vector-a))
  +  (declare (optimize (speed 3) (safety 1) (debug 1)))
     (let ((len (length-squared vector-a)))
       (if (cl:= 0f0 len)
           vector-a
  
positive.code:    will be sin(a) where a is the angle between the two vectors.
     The fact that we don't normalize may be useful in our
     quaternion functions later on."
    (declare (vec3 vec-a vec-b))
    (make
     (cl:- (cl:* (y vec-a) (z vec-b)) (cl:* (z vec-a) (y vec-b)))
     (cl:- (cl:* (z vec-a) (x vec-b)) (cl:* (x vec-a) (z vec-b)))
  
negative.code:     (2 `(*v ,@vec3s))
      (otherwise whole)))
  
  (defn *v ((vector-a vec3) (vector-b vec3)) vec3
    "Multiplies components"
    (declare (optimize (speed 3) (safety 1) (debug 1)))
    (make (cl:* (aref vector-a 0) (aref vector-b 0))
          (cl:* (aref vector-a 1) (aref vector-b 1))
          (cl:* (aref vector-a 2) (aref vector-b 2))))
  
  ;;---------------------------------------------------------------
  
  (defn /s ((vector-a vec3) (a single-float)) vec3
    "divide vector by scalar and return result as new vector"
    (declare (optimize (speed 3) (safety 1) (debug 1)))
    (let ((b (cl:/ 1 a)))
      (make (cl:* (aref vector-a 0) b)
            (cl:* (aref vector-a 1) b)
  