anchor.diff:    (let ((len (sparse-vector-len svec1))
   	(ilen (length (sparse-vector-index svec2)))
   	(value-index (mapcar #'list
  -			     (1d-array-to-list (sparse-vector-values svec2))
  -			     (1d-array-to-list (sparse-vector-index svec2)))))
  +			     (1d-array-to-list (sparse-vector-values svec1))
  +			     (1d-array-to-list (sparse-vector-index svec1)))))
       (flet ((list-second (lst) (mapcar #'second lst))
   	   (second-< (lst1 lst2)
   	     (if (< (second lst1) (second lst2))
   		 t
   		 nil))
  +	   ;; Assuming no repeat item, since we use it only to index array,
  +	   ;; it will cause no mistakes.
   	   (find-nth (item lst)
  -	     (let ((i 1))
  -	       (dolist (obj lst)
  -		 (if (/= item obj)
  -		     (incf i)))
  -	       i)))
  +	     (loop for i from 0 to (1- (length lst)) do
  +		  (if (= item (nth i lst))
  +		      (return-from find-nth i)))
  +	     nil))
         ;; If we have found a slot are nonzero in both vectors,
         ;; add the value of svec2 to the value of svec1,
         ;; if there's a new slot in svec2, push it to the back.
         (loop for i from 0 to (1- ilen) do
   	   (let ((item (aref (sparse-vector-index svec2) i))
   		 (val (aref (sparse-vector-values svec2) i))
  -		 (nth 0))
  -	     ;; Here in order to evaluate T use n+1 instead of n...
  -	     (if (setf nth (find-nth item (list-second value-index)))
  -		 (incf (first (nth (1- nth) value-index)) val)
  +		 (n 0))
  +	     (if (setf n (find-nth item (list-second value-index)))
  +		 (incf (first (nth n value-index)) val)
   		 ;; Not found, push it to the back.
   		 (push (list val item) value-index))))
         (setf value-index (sort value-index #'second-<)))
  
positive.code: 				    (aref values j)))))
      out))
  
  ;;; Untested.
  (defun sparse-inner-product (svec1 svec2)
    "Inner product of two sparse vectors."
    (declare (type sparse-vector svec1 svec2))
    (assert (= (sparse-vector-len svec1)
  	     (sparse-vector-len svec2))
  
negative.code: (defun sparse-vector---2 (svec1 svec2)
    "Helper function of general sparse vector subtraction."
    (declare (type sparse-vector svec1 svec2))
    (sparse-vector-+-2 svec1 (negative-sparse-vector svec2)))
  
  (defun sparse-vector-+ (svec &rest more)
    "Addition function of sparse vectors, from left to right."
    (declare (type sparse-vector svec))
    (reduce #'sparse-vector-+-2 (cons svec more)))
  
  (defun sparse-vector-- (svec &rest more)
    "Subtraction function of sparse vectors, from left to right."
    (declare (type sparse-vector svec))
    (reduce #'sparse-vector---2 (cons svec more)))
  
  (defun matrix-*-sparse-vector (mat svec)
    "Multiplication routine of a general matrix and a sparse vector."
  