anchor.diff:       list-sent2)
       (if (eq 0
   	    number-of-positives)
  -	nil
  +	(warn "There are no non-projective sentences in LIST-SENT1")
   	(/ (float true-positives)
   	   number-of-positives))))
   
  -(defun projectivity-recall (list-sent1 list-sent2)
  -  (let ((number-of-projectives
  +(defun non-projectivity-recall (list-sent1 list-sent2)
  +  (let ((number-of-non-projectives
   	 (length (remove-if-not
   		  #'non-projective?
   		  list-sent2)))
  
positive.code:     (mapcar
       #'(lambda (x y)
  	 (if (and
  	      (eq (non-projective? x) t)
  	      (eq (non-projective? y) t))
  	     (incf true-positives)))
       list-sent1
       list-sent2)
      (if (eq 0
  	    number-of-projectives)
  	nil
  	(/ (float true-positives)
  	   number-of-projectives))))
  
  
  (defun confusion-matrix (list-sent1 list-sent2 &key (normalize t))
    "Returns a hash table where keys are lists (deprel1 deprel2) and
     values are fraction of classifications as deprel1 of a word that
     originally was deprel2."
    (let* ((M (make-hash-table :test #'equal))
  	 (all-words-pair-list
  	  (mapcar
  
negative.code: 	     :key #'token-deprel-chosen)))
  	  (wrong-words
  	   (length
  	    (mapcar
  	     #'(lambda (sent1 sent2)
  		 (remove-if-not
  		  #'(lambda (x)
  		      (equal x deprel))
  		  (sentence-diff
  		   sent1 sent2
  		   :fields error-type
  		   :simple-dep simple-dep)
  		  :key
  		  ;; deprel in the predicted (SENT1) sentence
  		  #'(lambda (diff-entry)
  		      (let ((diff-entry-id (first diff-entry)))
  			(token-deprel-chosen
  			 (find diff-entry-id
  			       (sentence-tokens sent1)
  			       :key #'token-id))))))
  	     list-sent1
  	     list-sent2))))
        (if (eq classified-words
  	      0)
  	  (warn "There are no tokens predicted as of deprel ~a." deprel)
  	  (/ (float (- classified-words wrong-words))
  	     classified-words)))))
  
  (defun non-projectivity-accuracy (list-sent1 list-sent2)
    (let ((N (length list-sent1))
  	(correct 0))
      (mapcar
       #'(lambda (x y)
  	 (if (eq (non-projective? x)
  		 (non-projective? y))
  	     (incf correct)))
       list-sent1
       list-sent2)
      (if (eq N 0)
  	(error "LIST-SENT1 is empty!")
  	(/ (float correct)
  	   N))))
  
  (defun non-projectivity-precision (list-sent1 list-sent2)
    (let ((number-of-positives
  	 (length (remove-if-not
  		  #'non-projective?
  