anchor.diff:  
   ;;---------------------------------------------------------------
   
  -;;[TODO] What is faster (cl:* x x) or (expt x 2) ?
  -(declaim (inline 0p)
  -         (ftype (function (vec3) (boolean))
  -                0p))
  -(defun 0p (vector-a)
  +(defn 0p ((vector-a vec3)) boolean
     "Checks if the length of the vector is zero. As this is a
      floating point number it checks to see if the length is
      below a threshold set in the base-maths package"
  -  (declare (vec3 vector-a))
  +  (declare (optimize (speed 3) (safety 1) (debug 1)))
     (cl:= 0f0 (cl:+ (expt (aref vector-a 0) 2)
                     (expt (aref vector-a 1) 2)
                     (expt (aref vector-a 2) 2))))
   
   ;;---------------------------------------------------------------
   
  -(declaim (inline unitp)
  -         (ftype (function (vec3) (boolean))
  -                unitp))
  -(defun unitp (vector-a)
  +(defn unitp ((vector-a vec3)) boolean
     "Checks if the vector is of unit length. As this is a
      floating point number it checks to see if the length is
      within the range of 1 + or - and threshold set in base-maths"
  -  (declare (vec3 vector-a))
  +  (declare (optimize (speed 3) (safety 1) (debug 1)))
     (cl:= 0f0 (cl:- 1.0 (cl:+ (expt (aref vector-a 0) 2)
                               (expt (aref vector-a 1) 2)
                               (expt (aref vector-a 2) 2)))))
   ;;---------------------------------------------------------------
   
  -(declaim (inline =)
  -         (ftype (function (vec3 vec3) (boolean))
  -                =))
  -(defun = (vector-a vector-b)
  +(defn = ((vector-a vec3) (vector-b vec3)) boolean
     "Returns either t if the two vectors are equal.
      Otherwise it returns nil."
  -  (declare (vec3 vector-a vector-b))
  +  (declare (optimize (speed 3) (safety 1) (debug 1)))
     (and (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))))
   
   ;;----------------------------------------------------------------
   
  -(defun +s (vec2 scalar)
  -  (make (cl:+ (x vec2) scalar)
  -        (cl:+ (y vec2) scalar)
  -        (cl:+ (z vec2) scalar)))
  -
  -;;----------------------------------------------------------------
  -
  -(defun -s (vec2 scalar)
  -  (make (cl:- (x vec2) scalar)
  -        (cl:- (y vec2) scalar)
  -        (cl:- (z vec2) scalar)))
  -
  -;;---------------------------------------------------------------
  -
  -(defun + (&rest vec3s)
  +(defn +s ((vec3 vec3) (scalar single-float)) vec3
  +  (declare (optimize (speed 3) (safety 1) (debug 1)))
  +  (make (cl:+ (x vec3) scalar)
  +        (cl:+ (y vec3) scalar)
  +        (cl:+ (z vec3) scalar)))
  +
  +;;----------------------------------------------------------------
  +
  +(defn -s ((vec3 vec3) (scalar single-float)) vec3
  +  (declare (optimize (speed 3) (safety 1) (debug 1)))
  +  (make (cl:- (x vec3) scalar)
  +        (cl:- (y vec3) scalar)
  +        (cl:- (z vec3) scalar)))
  +
  +;;---------------------------------------------------------------
  +
  +(defn + (&rest (vec3s vec3)) vec3
     "takes any number of vectors and add them all together
      returning a new vector"
  +  (declare (optimize (speed 3) (safety 1) (debug 1)))
     (if vec3s
  -      (loop :for vec :in vec3s
  -         :summing (x vec) :into x
  -         :summing (y vec) :into y
  -         :summing (z vec) :into z
  -         :finally (return (make x y z)))
  +      (let ((x 0f0)
  +            (y 0f0)
  +            (z 0f0))
  +        (declare (single-float x y z))
  +        (loop :for vec :in vec3s :do
  +           (incf x (x vec))
  +           (incf y (y vec))
  +           (incf z (z vec)))
  +        (make x y z))
         (make 0s0 0s0 0s0)))
   
   (define-compiler-macro + (&whole whole &rest vec3s)
  
positive.code: 
  ;;----------------------------------------------------------------
  
  (declaim (inline bezier)
           (ftype (function (vec3 vec3 vec3 vec3 single-float) vec3)
                  bezier))
  (defun bezier (a1 a2 b1 b2 ammount)
    (declare (vec3 a1 a2 b1 b2)
             (single-float ammount))
    (lerp (lerp a1 a2 ammount)
          (lerp b1 b2 ammount)
          ammount))
  
negative.code: 
  ;;---------------------------------------------------------------
  
  (defn / ((vector-a vec3) (vector-b vec3)) vec3
    "Divides 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 negate ((vector-a vec3)) vec3
    "Return a vector that is the negative of the vector passed in"
    (declare (optimize (speed 3) (safety 1) (debug 1)))
    (make (cl:- (aref vector-a 0))
          (cl:- (aref vector-a 1))
          (cl:- (aref vector-a 2))))
  
  ;;----------------------------------------------------------------
  
  (defn dot ((vector-a vec3) (vector-b vec3)) single-float
    "Return the dot product of the vector-a and vector-b."
    (declare (optimize (speed 3) (safety 1) (debug 1)))
    (cl:+ (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 face-foreward ((vector-a vec3) (vector-b vec3)) vec3
    (declare (optimize (speed 3) (safety 1) (debug 1)))
    (if (> (dot vector-a vector-b) 0)
        vector-a
        (negate vector-a)))
  
  ;;---------------------------------------------------------------
  
  (defn length-squared ((vector-a vec3)) single-float
    "Return the squared length of the vector. A regular length
     is the square root of this value. The sqrt function is slow
     so if all thats needs doing is to compare lengths then always
     use the length squared function"
    (declare (optimize (speed 3) (safety 1) (debug 1)))
    (let ((x (x vector-a))
          (y (y vector-a))
          (z (z vector-a)))
  