anchor.diff:  	     :key #'token-deprel-chosen)))
   	  (wrong-words
   	   (length
  -	    (remove-if-not
  -	     #'(lambda (x)
  -		 (equal x deprel))
  -	     (mappend
  -	      #'identity
  -	      (mapcar
  -	       #'(lambda (sent1 sent2)
  -		   (disagreeing-words
  -		    sent1 sent2
  -		    :head-error head-error
  -		    :label-error label-error))
  -	       list-sent1
  -	       list-sent2))
  -	     :key #'(lambda (disag-pair)
  -		      (token-deprel-chosen
  -		       (first disag-pair)))))))
  +	    (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)
  -	  nil
  +	  (warn "There are no tokens predicted as of deprel ~a." deprel)
   	  (/ (float (- classified-words wrong-words))
   	     classified-words)))))
   
  -(defun projectivity-accuracy (list-sent1 list-sent2)
  +(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)))
  +	 (if (eq (non-projective? x)
  +		 (non-projective? y))
  +	     (incf correct)))
        list-sent1
        list-sent2)
       (if (eq N 0)
  -	nil
  +	(error "LIST-SENT1 is empty!")
   	(/ (float correct)
   	   N))))
   
  -(defun projectivity-precision (list-sent1 list-sent2)
  +(defun non-projectivity-precision (list-sent1 list-sent2)
     (let ((number-of-positives
   	 (length (remove-if-not
   		  #'non-projective?
  
positive.code:      list-sent2)
      (if (eq 0
  	    number-of-positives)
  	nil
  	(/ (float true-positives)
  	   number-of-positives))))
  
  (defun projectivity-recall (list-sent1 list-sent2)
    (let ((number-of-projectives
  	 (length (remove-if-not
  		  #'non-projective?
  		  list-sent2)))
  
negative.code:    score (LAS) considers both the head and the arc label (dependency
     label / syntactic class).
  
     In order to choose between labeled or unlabeled,
     set the key argument LABELED.
  
     References:
       - Dependency Parsing. Kubler, Mcdonald and Nivre (pp.79-80)"
    
    (sentence-average-score list-sent1 list-sent2
                            :fields (if labeled
                                        '(head deprel)
                                        '(head))
                            :ignore-punct ignore-punct
                            :simple-dep simple-dep))
  
  
  (defun attachment-score-by-word (list-sent1 list-sent2
  				 &key (labeled t)
  				   (ignore-punct nil) (simple-dep nil))
  
    "Attachment score by word (micro-average).
  
     The attachment score is the percentage of words that have correct
     arcs to their heads. The unlabeled attachment score (UAS) considers
     only who is the head of the token, while the labeled attachment
     score (LAS) considers both the head and the arc label (dependency
     label / syntactic class).
  
     In order to choose between labeled or unlabeled,
     set the key argument LABELED.
  
     References:
       - Dependency Parsing. Kubler, Mcdonald and Nivre (pp.79-80)"
  
    (word-average-score list-sent1 list-sent2
  		      :fields (if labeled
  				  '(head deprel)
  				  '(head))
  		      :ignore-punct ignore-punct
  		      :simple-dep simple-dep))
  
  
  (defun recall (list-sent1 list-sent2 deprel
                 &key (error-type '(deprel)) (simple-dep nil))
    "Restricted to words which are originally of syntactic class
    (dependency type to head) DEPREL, returns the recall:
     the number of true positives divided by the number of words
     originally positive (that is, originally of class DEPREL).
  
     We assume that LIST-SENT1 is the classified result
     and LIST-SENT2 is the list of golden (correct) sentences.
  
     ERROR-TYPE defines what is considered an error (a false negative).
     Some usual values are:
      - '(deprel) :: for the deprel tagging task only
      - '(head) :: for considering errors for each syntactic class
      - '(deprel head) :: for considering correct only when both deprel
                          and head are correct."
  
    (labels ((token-deprel-chosen (tk)
               (if simple-dep
                   (simple-deprel (token-deprel tk))
                   (token-deprel tk))))
      (assert
       (and (listp error-type)
            (not (null error-type)))
       ()
       "Error: ERROR-TYPE should be a list and at least one error must be used!")
      (let ((total-words
             (length
              (remove-if-not
               #'(lambda (x)
                   (equal x deprel))
               (mappend #'sentence-tokens
                        list-sent2)
               :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 original (SENT2) sentence
                    #'(lambda (diff-entry)
                        (let ((diff-entry-id (first diff-entry)))
                          (token-deprel-chosen
                           (find diff-entry-id
                                 (sentence-tokens sent2)
                                 :key #'token-id))))))
               list-sent1
               list-sent2))))
        
        (if (eq total-words
  	      0)
  	  (warn "There are no tokens correctly of deprel ~a." deprel)
  	  (/ (float (- total-words wrong-words))
  	     total-words)))))
  
  (defun precision (list-sent1 list-sent2 deprel
  		  &key (error-type '(deprel)) (simple-dep nil))
    "Restricted to words which are classified as of syntactical class
     (dependency type to head) DEPREL, returns the precision:
     the number of true positives divided by the number of words
     predicted positive (that is, predicted as of class DEPREL).
  
     We assume that LIST-SENT1 is the classified (predicted) result
     and LIST-SENT2 is the list of golden (correct) sentences.
  
     ERROR-TYPE defines what is considered an error (a false negative).
     Some usual values are:
      - '(deprel) :: for the deprel tagging task only
      - '(head) :: for considering errors for each syntactic class
      - '(deprel head) :: for considering correct only when both deprel
                          and head are correct."
    
    (labels ((token-deprel-chosen (tk)
  	     (if simple-dep
  		 (simple-deprel (token-deprel tk))
  		 (token-deprel tk))))
      (assert
       (and (listp error-type)
  	  (not (null error-type)))
       ()
       "Error: ERROR-TYPE should be a list and at least one error must be used!")
      
      (let ((classified-words
  	   (length
  	    (remove-if-not
  