anchor.diff:      (let* ((n (make-1-to-n-vector len))
   	   (pnull (./ n len))
   	   (maximum 0))
  -      (loop for i from 0 to (1- (length pobs)) do
  -	 ;; pobs has the same length as sorted-vec,
  -	 ;; and pnull has the same length as vec.
  -	   (let ((good (<= (aref probs (- (1- n) i)) (* param (aref pnull i)))))
  -	     (if (and good (> (aref n i) maximum))
  -		 (setf maximum (aref n i)))))
  +      ;; (LENGTH POBS) = (LENGTH SORTED-VEC) = (LENGTH VEC)
  +      (loop for i from 0 to (1- len) do
  +	   (let ((good (<= (aref pobs (- (1- len) i)) (* param (aref pnull i)))))
  +	     ;; Here (AREF N I) = (1+ I) so replace them to be more efficient.
  +	     (if (and good (> (1+ i) maximum))
  +		 (setf maximum (1+ i)))))
         (if (/= maximum 0)
   	  ;; We've found some GOOD non-nil.
   	  (aref abs-vec (nth (- (1+ len) maximum) sort-index))
   	  ;; All GOODs are nil, return trivial value.
   	  (+ 0.01 (vector-max abs-vec))))))
   
  -;;; Untested.
   (defun hardthresh (vec param)
     "Apply the hard threshold PARAM to VEC."
     (declare (type vector vec)
  
positive.code: 	 (residual vec)
  	 (vnorm (norm vec))
  	 (i-full (make-1-to-n-vector col))
  	 (i-now ())
  	 (active ())
  	 (j-active ())
  	 (x-i (make-array col :initial-element 0))
  	 ;; Now the output sparse vector is zero-sparse vector.
  	 (out (make-sparse-vector :len col)))
      ;; Iterate ITER times and output the result in sparse vector form.
      (loop for i from 0 to (1- iter) do
  	 (let* ((corr (./ (matrix-*-vector (.* (transpose matrix) (sqrt n))
  					   residual)
  			  (norm residual)))
  		(thr (funcall thresh corr param)))
  	   (setf i-now (1d-array-to-list (hardthresh (vector-abs corr) thr))
  		 ;; UNION apply on lists, change them...
  		 j-active (union active i-now))
  	   (if (= (length j-active) (length active))
  	       ;; Maybe we shall use some more gentle way?
  
negative.code: 		    nil)))
  	 (mapcar #'second (sort seq-index #'first-predicate)))))
      (vector
       (let* ((seq-list (1d-array-to-list seq))
  					;:texonomy-util::1d-array-to-list seq))
  	    (seq-index (mapcar #'list seq-list (make-1-to-n-list (length seq)))))
         (flet ((first-predicate (lst1 lst2)
  		(if (funcall predicate (first lst1) (first lst2))
  