Changeset 1512 for trunk/yat

Timestamp:

Sep 19, 2008, 4:29:24 PM (15 years ago)

Author:

Peter

Message:

fixes #439 - and also took care of ties

File:

• trunk/yat/normalizer/Spearman.h (modified) (3 diffs)

trunk/yat/normalizer/Spearman.h

@@ -52 +52 @@
        same.
 
-       Each element x is replaced by \f$ sum(w_i)/sum(w) \f$ where the
-       first sum runs over elements for which \f$ x_i < x \f$. 
+       Each element x is replaced by \f$ \frac{\sum I(x_i-x)
+       w_i}{\sum w_i} \f$ where I(x) = 1 for x>0, I(x) = 0.5 for x=0,
+       and I(x) = 0 for x<0.
 
-       In the unweighted case that can be simplified to \f$ rank/n
-       \f$, i.e., the samllest element is assigned to 0, next smallest
-       \f$ 1/n \f$ etc.
-       
        \return result + (last-first)
      */
@@ -80 +77 @@
       utility::sort_index(first, last, perm);
       double n = perm.size();
-      for ( size_t i=0; i<perm.size(); ++i)
-        result[perm[i]] = static_cast<double>(i)/n;
+      size_t i=0; 
+      while ( i<perm.size() ) {
+        size_t min_i = i;
+        while (i<perm.size() && first[perm[i]]<=first[perm[min_i]])
+          ++i;
+        double res = static_cast<double>(i + min_i)/(2*n);
+        for ( ; min_i < i; ++min_i)
+          result[perm[min_i]] = res;
+      }
       return result + std::distance(first, last);
     }
@@ -96 +100 @@
                 utility::weight_iterator(result));
       // set values with w=0 to 0 to avoid problems with NaNs
-      utility::iterator_traits<ForwardIterator> forward_trait;
+      utility::iterator_traits<ForwardIterator> trait;
       for (ForwardIterator i=first; i!=last; ++i)
-        if (forward_trait.weight(i)==0)
-          forward_trait.data(i)=0.0;
+        if (trait.weight(i)==0)
+          trait.data(i)=0.0;
 
-      std::vector<size_t> index(std::distance(first, last));
+      std::vector<size_t> perm(std::distance(first, last));
       utility::sort_index(utility::data_iterator(first), 
-                          utility::data_iterator(last), index);
-      utility::iterator_traits<RandomAccessIterator> trait;
-      trait.data(result+index[0])=0;
-      for (size_t i=1; i<index.size(); ++i)
-        trait.data(result+index[i]) = 
-          trait.data(result+index[i-1]) + trait.weight(result+index[i-1]);
+                          utility::data_iterator(last), perm);
+      utility::iterator_traits<RandomAccessIterator> rtrait;
+
+      double sum_w=0;
+      size_t i=0; 
+      while ( i<perm.size() ) {
+        double w=0;
+        size_t min_i = i;
+        while (i<perm.size() && (trait.weight(first+perm[i])==0 ||
+                                 trait.data(first+perm[i]) <= 
+                                 trait.data(first+perm[min_i])) ) {
+          w += trait.weight(first+perm[i]);
+          ++i;
+        }
+        double res=sum_w + 0.5*w;
+        for ( size_t j=min_i; j<i; ++j)
+          rtrait.data(result+perm[j]) = res;
+        sum_w += w;
+      }       
+
       size_t n = std::distance(first, last);
-      double w_sum = trait.data(result+index.back()) + 
-        trait.weight(result+index.back());
       std::transform(utility::data_iterator(result),
                      utility::data_iterator(result+n),
                      utility::data_iterator(result),
-                     std::bind2nd(std::divides<double>(), w_sum));
+                     std::bind2nd(std::divides<double>(), sum_w));
       return result + n;
     }