Changeset 1738

Timestamp:

Jan 20, 2009, 2:58:44 AM (15 years ago)

Author:

Peter

Message:

added support for creation of an qQuantileNormalizer from a weighted range. Addresses #478

Location:

trunk

Files:

• test/normalization_test.cc (modified) (1 diff)
• yat/normalizer/qQuantileNormalizer.cc (modified) (2 diffs)
• yat/normalizer/qQuantileNormalizer.h (modified) (2 diffs)

trunk/test/normalization_test.cc

@@ -180 +180 @@
   for (size_t i=0; i<100; ++i)
     vec.push_back(utility::DataWeight(i, 1.0));
-  //qQuantileNormalizer(vec.begin(), vec.end(), 5);
+  qQuantileNormalizer(vec.begin(), vec.end(), 5);
 }
 

trunk/yat/normalizer/qQuantileNormalizer.cc

@@ -24 +24 @@
 #include "yat/regression/CSplineInterpolation.h"
 #include "yat/statistics/Averager.h"
+#include "yat/statistics/AveragerWeighted.h"
+#include "yat/utility/DataWeight.h"
 #include "yat/utility/Vector.h"
 #include "yat/utility/VectorBase.h"
+#include "yat/utility/WeightIterator.h"
 
 #include <algorithm>
 #include <cassert>
+#include <numeric>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <vector>
 
 namespace theplu {
@@ -57 +65 @@
 
 
+  void qQuantileNormalizer::Partitioner::init
+  (const std::vector<utility::DataWeight>& sortedvec, unsigned int N)
+  {
+    assert(N>1);
+    assert(N<=sortedvec.size());
+    double total_w = std::accumulate(utility::weight_iterator(sortedvec.begin()),
+                                     utility::weight_iterator(sortedvec.end()), 
+                                     0.0);
+
+    assert(total_w);
+    double sum_w = 0;
+    std::vector<utility::DataWeight>::const_iterator iter(sortedvec.begin());
+    for (unsigned int i=0; i<N; ++i) {
+      statistics::AveragerWeighted av;
+      double end_sum_w = (i+1) * total_w / N - sum_w; 
+      std::cout << "end_sum_w: " << end_sum_w << std::endl;
+      if (i!=N-1) {
+        while(av.sum_w() < end_sum_w) {
+          av.add(iter->data(), iter->weight());
+          ++iter;
+        }
+      }
+      // use all remaining data for last bin (to avoid problems
+      // due to rounding errors)
+      else 
+        add(av, iter, sortedvec.end());
+
+      if (av.sum_w() == 0) {
+        std::stringstream ss;
+        ss << "yat::normalizer::qQuantileNormalizer: relative weight too "
+           << "large in\n";
+        throw std::runtime_error(ss.str());
+      }
+      average_(i) = av.mean();
+      index_(i)   = sum_w + 0.5*av.sum_w();
+      sum_w += av.sum_w();
+    }
+  }
+
+
   const utility::Vector& qQuantileNormalizer::Partitioner::averages(void) const
   {

trunk/yat/normalizer/qQuantileNormalizer.h

@@ -146 +146 @@
     void build(Iterator first, Iterator last, unsigned int N, 
                utility::unweighted_iterator_tag);
+    // weighted "constructor"
+    template<typename Iterator>
+    void build(Iterator first, Iterator last, unsigned int N, 
+               utility::weighted_iterator_tag);
     void init(const utility::VectorBase&, unsigned int N);
+    void init(const std::vector<utility::DataWeight>&, unsigned int N);
 
     utility::Vector average_;
@@ -256 +261 @@
 
 
+  template<typename Iterator>
+  void qQuantileNormalizer::Partitioner::build(Iterator first, 
+                                               Iterator last, unsigned int N, 
+                                               utility::weighted_iterator_tag)
+  {
+    std::vector<utility::DataWeight> vec;
+    vec.reserve(std::distance(first, last));
+    std::back_insert_iterator<std::vector<utility::DataWeight> > inserter(vec);
+    std::copy(first, last, inserter);
+    std::sort(vec.begin(), vec.end());
+    init(vec, N);
+  }
+
+
 }}} // end of namespace normalizer, yat and thep