Changeset 1518

Timestamp:

Sep 21, 2008, 6:07:45 AM (13 years ago)

Author:

Peter

Message:

changed implementation of a couple of normalizer so that operator() takes two matrices of which one is an input marix and one is a result matrix, i.e., the result does only depend on the input matrix and the result is only used as a receiver - I think this behaviour is more intuitive, although it is not as general as the previous one. We should probably document somewhere how we expect a 2Dnormalizer to behave (refs #425).

Location:

trunk/yat/normalizer

Files:

• ColumnNormalizer.h (modified) (3 diffs)
• QuantileNormalizer.cc (modified) (3 diffs)
• QuantileNormalizer.h (modified) (2 diffs)

trunk/yat/normalizer/ColumnNormalizer.h

@@ -22 +22 @@
 
 #include "yat/utility/Matrix.h"
+#include "yat/utility/yat_assert.h"
+
+#include <stdexcept>
 
 namespace theplu {
@@ -55 +58 @@
 
     /**
-       Each column in \a result is normalized using class T.
+       Each column in \a matrix is normalized using class T, and
+       assigned to Matrix \a result.
 
-       \note matrix is ignored
+       \note \a result must have same dimensions as \a matrix.
      */
     void operator()(const utility::Matrix& matrix, 
@@ -69 +73 @@
                                        utility::Matrix& result) const
   {
+    using utility::yat_assert;
+    yat_assert<std::runtime_error>(matrix.rows()==result.rows(),
+                                   "ColumnNormalizer: rows mismatch");
+    yat_assert<std::runtime_error>(matrix.columns()==result.columns(),
+                                   "ColumnNormalizer: columns mismatch");
     for (size_t i=0; i<matrix.columns(); ++i)
-      normalizer_(result.begin_column(i), result.end_column(i),
+      normalizer_(matrix.begin_column(i), matrix.end_column(i),
                   result.begin_column(i));
 

trunk/yat/normalizer/QuantileNormalizer.cc

@@ -39 +39 @@
   {
     assert(data.rows()==result.rows());
+    assert(data.columns()==result.columns());
+
+    // create a tmp copy
     utility::Matrix data_copy(data);
     
@@ -48 +51 @@
     // calculate average of each row
     std::vector<yat::statistics::Averager> averager(data_copy.rows());
-    for (size_t row=0; row<data_copy.rows(); ++row){
+    for (size_t row=0; row<result.rows(); ++row){
       add(averager[row], data_copy.begin_row(row), data_copy.end_row(row));
     }
@@ -54 +57 @@
     for (size_t column=0; column<result.columns(); ++column){
       std::vector<size_t> index;
-      utility::sort_index(index, result.column_const_view(column));
+      utility::sort_index(index, data.column_const_view(column));
                                
-      for (size_t row=0; row<result.rows(); ++row)
+      for (size_t row=0; row<data.rows(); ++row)
         result(index[row], column) = averager[row].mean();
     }

trunk/yat/normalizer/QuantileNormalizer.h

@@ -29 +29 @@
 
   /**
-     \brief Perform quantile normalizer
+     \brief Perform quantile normalization
 
      \since New in yat 0.5
@@ -39 +39 @@
        The \a matrix is normalized by sorting each column, replacing
        each value with the average across rows, and undo the sorting
-       in step 1. This results in a \a matrix in which each column has
-       the same distribution of data, and the rank of an element
-       within a column is preserved in the normalizer.
+       in step 1. This results in a Matrix \a result in which each
+       column has the same distribution of data, and the rank of an
+       element within a column is the same as in \a matrix.
 
-       \note Number of rows in \a matrix and \a result must match.
+       \note dimensions of \a matrix and \a result must match.
      */
-    void operator()(const utility::Matrix& matrix, 
+    void operator()(const utility::Matrix& matrix,
                     utility::Matrix& result) const;
   };