anchor.diff:  (defmacro float4-incf-cpu (var val)
     `(setf ,var (float4-add-cpu ,var ,val)))
   
  +(defkernel norm (float ((x float4)))
  +  (return (sqrt (+ (* (float4-x x) (float4-x x))
  +                   (* (float4-y x) (float4-y x))
  +                   (* (float4-z x) (float4-z x))
  +                   (* (float4-w x) (float4-w x))))))
  +
   (defun norm-cpu (val)
     (with-float4-cpu (x y z w) val
       (sqrt (+ (* x x) (* y y) (* z z) (* w w)))))
  
positive.code:   (alexandria:with-gensyms (n index)
      `(when (valid-cell-index ,info ,i ,j ,k)
         (let ((,n (number-of-particles-in-cell ,nbr ,info ,i ,j ,k)))
           (do ((,index 0 (+ ,index 1)))
               ((>= ,index ,n))
             (let ((,p (nth-particle-in-cell ,index ,nbr ,info ,i ,j ,k)))
               ,@body))))))
  
  
negative.code:        ((> ,var ,to))
       ,@body))
  
  (defmacro do-range-cpu ((var from to) &body body)
    `(do ((,var ,from (+ ,var 1)))
         ((> ,var ,to))
       ,@body))
  
  (defkernelmacro do-neighbor-particles ((p nbr info x) &body body)
    (alexandria:with-gensyms (i0 j0 k0 i j k shared-info)
      `(with-shared-memory ((,shared-info float 15))
         ;; set neighbor map info into shared memory
         (do-range (,i 0 14)
           (set (aref ,shared-info ,i) (aref ,info ,i)))
         ;; do body forms using neighbor map info contained in shared memory
         (with-cell (,i0 ,j0 ,k0 ,shared-info ,x)
           (do-range (,i (- ,i0 1) (+ ,i0 1))
             (do-range (,j (- ,j0 1) (+ ,j0 1))
               (do-range (,k (- ,k0 1) (+ ,k0 1))
                 (do-particles-in-cell (,p ,nbr ,shared-info ,i ,j ,k)
                   ,@body))))))))
  
  (defmacro do-neighbor-particles-cpu ((p nbr info x) &body body)
    (alexandria:with-gensyms (i0 j0 k0 i j k)
  