anchor.diff:  		0))
   	g))
   
  -;; Arithmetic (addition, subtractions, scalar multiplication)
  -
  -(defmethod gbc+ ((g g) (b integer) c)
  -  "Add scalar C to GA object's B coefficient"
  +;;; Arithmetic (addition, subtractions, scalar multiplication)
  +
  +;;; Addition
  +
  +(defmethod ga-coef+ ((g g) (b integer) c)
  +  "Add scalar C to GA object's coefficient corresponfing to basis blade bitmap B"
     (mapg #'(lambda (bi ci)
   	    (if (= bi b)
   		(+ ci c)
   		ci))
   	g))
   
  -(defmethod gs+ ((g g) s)
  -  "Add GA object and scalar"
  -  (gbc+ g 0 s))
  -
  -(defmethod g2+ ((g1 g) (g2 g))
  -  "Add two GA objects"
  -  (assert (typep g1 (type-of g2)))
  -  (mapcg #'(lambda (c1 c2)
  -	     (if (and (numberzerop c1) (numberzerop c2))
  -		 0
  -		 (+ c1 c2)))
  -	 g1
  -	 g2))
  -
   (defmeth2 + ((g g) (s t))
  -  (gbc+ g 0 s))
  +  (ga-coef+ g 0 s))
   
   (defmeth2 + ((s t) (g g))
  -  (gbc+ g 0 s))
  +  (ga-coef+ g 0 s))
   
   (defmeth2 + ((g1 g) (g2 g))
     (mapcg #'(lambda (c1 c2)
  
positive.code: 		 (+ c1 c2)))
  	 g1 g2))
  
  (defun g+ (&rest args)
    "Add a series of GA objects"
    (reduce #'g2+ args))
  
  (defmethod g2- ((g1 g) (g2 g))
    "Subtract one GA object from another"
    (assert (typep g1 (type-of g2)))
    (mapcg #'(lambda (c1 c2)
  	     (if (and (numberzerop c1) (numberzerop c2))		      
  		 0
  		 (- c1 c2)))
  	 g1
  	 g2))
  
  (defmeth2 - ((g g) (s t))
    (+ g (- s)))
  
negative.code:      unless (zerop (logand meet 1)) do (setq pairsign (* pairsign sigi))
       finally (return pairsign)))
  
  (defmacro defgpe (name euclidean-bitmap-fn doc)
    "Define derived geometric product function on a Euclidean basis given name, euclidean function of bitmaps, and documentation string"
    `(defmethod ,name ((g1 g) (g2 g))
       ,doc
       (w/newg g3 g1
         (ong b1 c1 g1
  	 (ong b2 c2 g2
  	   (multiple-value-bind (b3 sign) (,euclidean-bitmap-fn b1 b2)
  	     (setq g3 (ga-coef+ g3 b3 (* sign (* c1 c2))))))))))
  
  (defmacro defgpo (name orthogonal-bitmap-fn doc)
    "Define a derived geometric product function on an orthogonal basis given name, orthogonal function of bitmaps & metric, and documentation string"
    `(defmethod ,name ((g1 g) (g2 g) (m vector))
       ,doc
       (w/newg g3 g1
         (ong b1 c1 g1
  	 (ong b2 c2 g2
  	   (multiple-value-bind (b3 sign) (,orthogonal-bitmap-fn b1 b2 m)
  	     (setq g3 (ga-coef+ g3 b3 (* sign (* c1 c2))))))))))
  
  ;; Bitmap products (Euclidean & orthogonal)
  
  (defun *gbe (b1 b2)
    "Geometric product of basis blade bitmaps in Euclidean space"
    (values (logxor b1 b2)
  	  (reordersign b1 b2)))
  
  (defun *ob (b1 b2)
    "Outer product of basis blade bitmaps (Euclidean, orthogonal, and non-orthogonal spaces)"
    (if (not (zerop (logand b1 b2)))
        (values 0 0)
        (*gbe b1 b2)))
  
  (defun *gbo (b1 b2 m)
    "Geometric product of basis blade bitmaps in orthogonal space with vector metric"
    (values (logxor b1 b2)
  	  (* (reordersign b1 b2)
  	     (pairsign b1 b2 m))))
  
  (defun *ibe (b1 b2)
    "Inner product of basis blade bitmaps in Euclidean space"
    (multiple-value-bind (basis sign) (*gbe b1 b2)
      (if (= (gradeb basis) (- (gradeb b2) (gradeb b1)))
  	(values basis sign)
  	(values 0 0))))
  
  (defun *ibo (b1 b2 m)
    "Inner product of basis blade bitmaps in orthogonal space with vector metric"
    (multiple-value-bind (basis sign) (*gbo b1 b2 m)
      (if (= (gradeb basis) (- (gradeb b2) (gradeb b1)))
  	(values basis sign)
  	(values 0 0))))
  
  (defun *cbe (b1 b2)
    "Commutator product of basis blade bitmaps in Euclidean space"
    (let ((s1 (* (reordersign b1 b2)))
  	(s2 (* (reordersign b2 b1)))
  	(basis (logxor b1 b2)))
      (values basis (/ (- s1 s2) 2))))
  
  (defun *cbo (b1 b2 m)
    "Commutator product of basis blade bitmaps in orthogonal space with vector metric"
    (let ((s1 (* (reordersign b1 b2) (pairsign b1 b2 m)))
  	(s2 (* (reordersign b2 b1) (pairsign b2 b1 m)))
  	(basis (logxor b1 b2)))
  