Changeset 3289

Timestamp:

Jul 12, 2014, 6:25:36 PM (9 years ago)

Author:

Peter

Message:

refs #803. use boost concepts in Spearman.

Location:

trunk

Files:

• test/normalization.cc (modified) (1 diff)
• yat/normalizer/Spearman.h (modified) (7 diffs)

trunk/test/normalization.cc

@@ -449 +449 @@
   // compile test should not be run
   if (false) {
-    spearman(boost::random_access_iterator_archetype<double>(), 
-             boost::random_access_iterator_archetype<double>(),
-             boost::mutable_random_access_iterator_archetype<double>());
-    using utility::DataWeight;
-    spearman(boost::random_access_iterator_archetype<DataWeight>(), 
-             boost::random_access_iterator_archetype<DataWeight>(),
-             boost::mutable_random_access_iterator_archetype<DataWeight>());
-    spearman(boost::random_access_iterator_archetype<double>(), 
-             boost::random_access_iterator_archetype<double>(),
-             boost::mutable_random_access_iterator_archetype<DataWeight>());
-    spearman(boost::random_access_iterator_archetype<DataWeight>(), 
-             boost::random_access_iterator_archetype<DataWeight>(),
-             boost::mutable_random_access_iterator_archetype<double>());
+    using boost::iterator_archetype;
+    iterator_archetype<double,
+                       boost::iterator_archetypes::readable_iterator_t,
+                       boost::random_access_traversal_tag>
+      readable_iterator;
+
+    iterator_archetype<double,
+                       boost::iterator_archetypes::readable_writable_iterator_t,
+                       boost::random_access_traversal_tag>
+      writable_iterator;
+
+    // We have to use lvalue here because otherwise proxy classes
+    // provided by boost kick in and they do not provide the needed
+    // data() and weight() functions that e.g. DataWeightProxy does.
+    iterator_archetype<utility::DataWeight,
+                       boost::iterator_archetypes::readable_lvalue_iterator_t,
+                       boost::random_access_traversal_tag>
+      weighted_readable_iterator;
+
+    iterator_archetype<utility::DataWeight,
+                       boost::iterator_archetypes::writable_lvalue_iterator_t,
+                       boost::random_access_traversal_tag>
+      weighted_writable_iterator;
+
+    spearman(readable_iterator, readable_iterator, writable_iterator);
+    spearman(readable_iterator, readable_iterator, weighted_writable_iterator);
+    spearman(weighted_readable_iterator, weighted_readable_iterator,
+             writable_iterator);
+    spearman(weighted_readable_iterator, weighted_readable_iterator,
+             weighted_writable_iterator);
   }
 

trunk/yat/normalizer/Spearman.h

@@ -26 +26 @@
 #include "utility.h"
 
+#include "yat/utility/concept_check.h"
 #include "yat/utility/DataIterator.h"
 #include "yat/utility/iterator_traits.h"
 #include "yat/utility/sort_index.h"
+#include "yat/utility/stl_utility.h"
+#include "yat/utility/utility.h"
 #include "yat/utility/WeightIterator.h"
 
@@ -35 +38 @@
 #include <algorithm>
 #include <functional>
+#include <numeric>
 #include <vector>
 
@@ -64 +68 @@
 
        Type Requirements:
-       - RandomAccessIter1 must be a \random_access_iterator
-       - RandomAccessIter2 must be a mutable \random_access_iterator
-
+       - \c RandomAccessIter1 is \readable_iterator
+       - \c RandomAccessIter1 is \random_access_traversal_iterator
+       - \c RandomAccessIter1 is \ref concept_data_iterator
+       - \c RandomAccessIter2 is \readable_iterator
+       - \c RandomAccessIter2 is \writable_iterator
+       - \c RandomAccessIter2 is \random_access_traversal_iterator
+       - \c RandomAccessIter2 is \ref concept_data_iterator
      */
     template<typename RandomAccessIter1, typename RandomAccessIter2>
@@ -72 +80 @@
                     RandomAccessIter2 result) const
     {
-      BOOST_CONCEPT_ASSERT((boost::RandomAccessIterator<RandomAccessIter1>));
-      BOOST_CONCEPT_ASSERT((boost::Mutable_RandomAccessIterator<RandomAccessIter2>));
+      using boost_concepts::ReadableIterator;
+      BOOST_CONCEPT_ASSERT((ReadableIterator<RandomAccessIter1>));
+      using boost_concepts::RandomAccessTraversal;
+      BOOST_CONCEPT_ASSERT((RandomAccessTraversal<RandomAccessIter1>));
+      using utility::DataIteratorConcept;
+      BOOST_CONCEPT_ASSERT((DataIteratorConcept<RandomAccessIter1>));
+
+      BOOST_CONCEPT_ASSERT((ReadableIterator<RandomAccessIter2>));
+      using boost_concepts::WritableIterator;
+      BOOST_CONCEPT_ASSERT((WritableIterator<RandomAccessIter2>));
+      BOOST_CONCEPT_ASSERT((RandomAccessTraversal<RandomAccessIter2>));
+      BOOST_CONCEPT_ASSERT((DataIteratorConcept<RandomAccessIter2>));
+
       using utility::weighted_if_any2;
       typename weighted_if_any2<RandomAccessIter1,RandomAccessIter2>::type tag;
@@ -84 +103 @@
     template<typename RandomAccessIter1, typename RandomAccessIter2>
     void normalize(RandomAccessIter1 first, RandomAccessIter1 last,
-                   RandomAccessIter2 result, 
+                   RandomAccessIter2 result,
                    utility::unweighted_iterator_tag) const
     {
@@ -90 +109 @@
       utility::sort_index(first, last, perm);
       double n = perm.size();
-      size_t i=0; 
+      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);
+        double res = (i + min_i)/(2.0*n);
         for ( ; min_i < i; ++min_i)
           result[perm[min_i]] = res;
@@ -105 +124 @@
     template<typename RandomAccessIter1, typename RandomAccessIter2>
     void normalize(RandomAccessIter1 first, RandomAccessIter1 last,
-                   RandomAccessIter2 result, 
+                   RandomAccessIter2 result,
                    utility::weighted_iterator_tag) const
     {
       detail::copy_weight_if_weighted(first, last, result);
-      std::vector<double> input_vec;
-      input_vec.reserve(last-first);
-      // set values with w=0 to 0 to avoid problems with NaNs
+      std::vector<size_t> perm;
+      utility::sort_index(first, last, perm);
       utility::iterator_traits<RandomAccessIter1> trait;
-      for (RandomAccessIter1 i=first; i!=last; ++i) {
-        if (trait.weight(i)==0)
-          input_vec.push_back(0.0);
-        else
-          input_vec.push_back(trait.data(i));
-      }
-
-      std::vector<size_t> perm(input_vec.size());
-      utility::sort_index(input_vec.begin(), input_vec.end(), perm);
       utility::iterator_traits<RandomAccessIter2> rtrait;
 
+      double total_w = utility::sum_weight(first, last);
       double sum_w=0;
-      size_t i=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[i]) <=
                                  trait.data(first+perm[min_i])) ) {
           w += trait.weight(first+perm[i]);
           ++i;
         }
-        double res=sum_w + 0.5*w;
+        double res = (sum_w + 0.5*w)/total_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);
-      std::transform(utility::data_iterator(result),
-                     utility::data_iterator(result+n),
-                     utility::data_iterator(result),
-                     std::bind2nd(std::divides<double>(), sum_w));
+      }
     }
-
   };