Changeset 1509

Timestamp:

Sep 17, 2008, 10:56:30 PM (15 years ago)

Author:

Peter

Message:

fixes #437 and added support for having known issues in test::Suite

Location:

trunk

Files:

• test/Suite.cc (modified) (3 diffs)
• test/Suite.h (modified) (1 diff)
• test/normalization_test.cc (modified) (3 diffs)
• yat/normalizer/Spearman.h (modified) (4 diffs)

trunk/test/Suite.cc

@@ -35 +35 @@
 
   Suite::Suite(int argc, char* argv[])
-    : ok_(true)
+    : known_issues_(0), ok_(true)
   {
     dev_null_ = new std::ofstream("/dev/null");
@@ -128 +128 @@
   int Suite::return_value(void) const
   {
+    if (known_issues_>1)
+      out() << known_issues_ << " known issues were detected.\n";
+    else if (known_issues_==1)
+      out() << known_issues_ << " known issue was detected.\n";
     if (ok()){
       out() << "Test is ok.\n";
@@ -137 +141 @@
 
 
+  bool Suite::xadd(bool ok)
+  {
+    if (!ok)
+      ++known_issues_;
+    else {
+      err() << " test for a known issue returned true\n";
+      add(false);
+    }
+    return ok;
+  }
+
+
 }}}

trunk/test/Suite.h

@@ -100 +100 @@
     bool test_stream(const T&) const;
 
+    /**
+       This function is similar to add(bool) and could be used to
+       detect/count known issues. When the issue is fixed, one can
+       replace the call to xadd(bool) with a call to add(bool).
+
+       If \a b is false a counter is incremented, which is used to in
+       return_value() to generate some printout on how many known
+       issues were detected.
+
+       If \a b is true, ok_ is set to false, becasue the known issue
+       is no longer an issue and one should replace the call with a
+       call to add(bool).
+     */
+    bool xadd(bool b);
+
   private:
+    std::ofstream* dev_null_;
+    unsigned int known_issues_;
+    bool ok_;
     bool verbose_;
-    bool ok_;
-    std::ofstream* dev_null_;
 
   };

trunk/test/normalization_test.cc

@@ -24 +24 @@
 #include "yat/normalizer/Centralizer.h"
 #include "yat/normalizer/ColumnNormalizer.h"
+#include "yat/utility/DataIterator.h"
 #include "yat/normalizer/QuantileNormalizer.h"
 #include "yat/normalizer/Spearman.h"
 
+#include "yat/utility/DataIterator.h"
 #include "yat/utility/Matrix.h"
+#include "yat/utility/MatrixWeighted.h"
+#include "yat/utility/WeightIterator.h"
 
+#include <limits>
 #include <vector>
 
@@ -36 +41 @@
 void test_quantile_normalize(test::Suite&);
 void test_spearman(test::Suite&);
+void test_spearman_weighted(test::Suite&);
 
 int main(int argc, char* argv[])
@@ -124 +130 @@
   correct.push_back(0.25);
   suite.equal_range(vec.begin(), vec.end(), correct.begin());
+  test_spearman_weighted(suite);
 }
+
+
+void test_spearman_weighted(test::Suite& suite)
+{
+  suite.err() << "Testing Weighted Spearman\n";
+  normalizer::Spearman spearman;
+
+  suite.err() << "Testing that unity weights reproduces unweighted case\n";
+  utility::MatrixWeighted m(1,4,0,1);
+  utility::MatrixWeighted res(m.rows(), m.columns(),3.14,0);
+  m(0,0).data()=0;
+  m(0,1).data()=2;
+  m(0,2).data()=3;
+  m(0,3).data()=1;
+  std::vector<double> correct(m.columns());
+  std::vector<double> correct_w(m.columns(), 1.0);
+  std::copy(utility::data_iterator(m.begin_row(0)),
+            utility::data_iterator(m.end_row(0)),
+            correct.begin());
+  spearman(correct.begin(), correct.end(), correct.begin());
+  spearman(m.begin_row(0), m.end_row(0), res.begin_row(0));
+
+  using utility::data_iterator;
+  suite.add(suite.equal_range(data_iterator(res.begin_row(0)),
+                               data_iterator(res.end_row(0)),
+                               correct.begin()));
+  using utility::weight_iterator;
+  suite.add(suite.equal_range(weight_iterator(res.begin_row(0)),
+                               weight_iterator(res.end_row(0)),
+                               correct_w.begin()));
+
+  suite.err() << "Testing rescaling of weights\n";
+  for (size_t i=0; i<m.columns(); ++i) {
+    m(0,i).weight() *= 2;
+    correct_w[i] *= 2;
+  }   
+  spearman(m.begin_row(0), m.end_row(0), res.begin_row(0));
+  suite.add(suite.equal_range(data_iterator(res.begin_row(0)),
+                               data_iterator(res.end_row(0)),
+                               correct.begin()));
+  suite.add(suite.equal_range(weight_iterator(res.begin_row(0)),
+                               weight_iterator(res.end_row(0)),
+                               correct_w.begin()));
+
+  
+  suite.err() << "Testing case with a zero weight\n";
+  m(0,1).data() = std::numeric_limits<double>::quiet_NaN();
+  m(0,1).weight() = 0.0;
+  spearman(m.begin_row(0), m.end_row(0), res.begin_row(0));
+  suite.add(suite.equal(res(0,0).data(), 0)); 
+  suite.add(suite.equal(res(0,2).data(), 2.0/3)); 
+  suite.add(suite.equal(res(0,3).data(), 1.0/3)); 
+}

trunk/yat/normalizer/Spearman.h

@@ -21 +21 @@
 */
 
+#include "yat/utility/DataIterator.h"
 #include "yat/utility/iterator_traits.h"
 #include "yat/utility/sort_index.h"
+#include "yat/utility/WeightIterator.h"
 
+#include <algorithm>
+#include <functional>
 #include <vector>
 
@@ -52 +56 @@
        \return result + (last-first)
      */
-    template<typename InputIterator, typename RandomAccessIterator>
-    RandomAccessIterator operator()(InputIterator first, InputIterator last,
+    template<typename ForwardIterator, typename RandomAccessIterator>
+    RandomAccessIterator operator()(ForwardIterator first, ForwardIterator last,
                                     RandomAccessIterator result) const
     {
-      typename utility::weighted_iterator_traits<InputIterator>::type tag;
+      typename utility::weighted_iterator_traits<ForwardIterator>::type tag;
       return normalize(first, last, result, tag);
     }
@@ -63 +67 @@
   private:
     // unweighted version
-    template<typename InputIterator, typename RandomAccessIterator>
-    RandomAccessIterator normalize(InputIterator first, InputIterator last,
+    template<typename ForwardIterator, typename RandomAccessIterator>
+    RandomAccessIterator normalize(ForwardIterator first, ForwardIterator last,
                                    RandomAccessIterator result, 
                                    utility::unweighted_iterator_tag) const
@@ -78 +82 @@
 
     // weighted version
-    template<typename InputIterator, typename RandomAccessIterator>
-    RandomAccessIterator normalize(InputIterator first, InputIterator last,
+    template<typename ForwardIterator, typename RandomAccessIterator>
+    RandomAccessIterator normalize(ForwardIterator first, ForwardIterator last,
                                    RandomAccessIterator result, 
                                    utility::weighted_iterator_tag) const
     {
-      return result + std::distance(first, last);
+      std::copy(utility::weight_iterator(first), 
+                utility::weight_iterator(last),
+                utility::weight_iterator(result));
+      // set values with w=0 to 0 to avoid problems with NaNs
+      utility::iterator_traits<ForwardIterator> forward_trait;
+      for (ForwardIterator i=first; i!=last; ++i)
+        if (forward_trait.weight(i)==0)
+          forward_trait.data(i)=0.0;
+
+      std::vector<size_t> index(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]);
+      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));
+      return result + n;
     }