Changeset 1043

Timestamp:

Apr 23, 2009, 6:55:02 PM (14 years ago)

Author:

Jari Häkkinen

Message:

Addresses #118 and #206. This code produces the same result as the preivous code but fails miserably with missing values.

Location:

plugins/base2/net.sf.basedb.normalizers/trunk/src

Files:

• c++/bin/qQN.cc (modified) (9 diffs)
• net/sf/basedb/plugins/qQuantileNormalization.java (modified) (1 diff)

plugins/base2/net.sf.basedb.normalizers/trunk/src/c++/bin/qQN.cc

@@ -29 +29 @@
 
 #include <yat/utility/CommandLine.h>
-#include <yat/utility/Matrix.h>
+#include <yat/utility/MatrixWeighted.h>
 #include <yat/utility/OptionHelp.h>
 #include <yat/utility/OptionInFile.h>
@@ -43 +43 @@
 using namespace theplu::yat::utility;
 
-void create_target(std::vector<double>&, const Matrix&);
-void create_target(std::vector<double>&, const Matrix&, const std::string&);
+void create_target(std::vector<double>&, const MatrixWeighted&);
+void create_target(std::vector<double>&, const MatrixWeighted&,
+                   const std::string&);
+/**
+   writes the data values in the matrix ignoring the weights, i.e.,
+   produces the same output as the Matrix output operator does.
+ */
+std::ostream& operator<< (std::ostream&, const MatrixWeighted&);
 
 
@@ -79 +85 @@
     return EXIT_SUCCESS;
   }
-
   std::ifstream* infile=NULL;
   std::streambuf* cin_buffer=NULL;
@@ -87 +92 @@
     std::cin.rdbuf(infile->rdbuf());
   }
-  Matrix m(std::cin,'\t');
+  MatrixWeighted m(std::cin,'\t');
   if (indata.present()) {
     std::cin.rdbuf(cin_buffer); // restore old input buffer
@@ -94 +99 @@
   }
 
-  std::vector<double> target(m.rows(),0);
+  std::vector<double> target(m.rows());
   ( assay.present() ? create_target(target,m,assay.value()) :
                       create_target(target,m) );
   qQuantileNormalizer qqn(target.begin(), target.end(), 100);
   ColumnNormalizer<qQuantileNormalizer> cn(qqn);
-  Matrix result(m.rows(),m.columns());
+  MatrixWeighted result(m.rows(),m.columns());
   cn(m,result);
 
@@ -120 +125 @@
 
 
-void create_target(std::vector<double>& t, const Matrix& m,
+void create_target(std::vector<double>& t, const MatrixWeighted& m,
                    const std::string& assay)
 {
@@ -126 +131 @@
   std::string line;
   size_t column=0;
-  size_t yes=0;
+  std::vector<size_t> yes(m.rows(),0);
   for (size_t row=0; row<m.rows(); ++row)
     t[row]=0;
@@ -133 +138 @@
     if (found!=std::string::npos) {
       for (size_t row=0; row<m.rows(); ++row)
-        t[row]+=m(row,column);
-      ++yes;
+        if (m(row,column).weight()) { // weight either 0 or 1
+          t[row]+=m(row,column).data();
+          ++yes[row];
+        }
     }
     ++column;
@@ -140 +147 @@
       throw std::runtime_error("Too many annotation columns wrt data matrix");
   }
-  if (!yes)
-    throw std::runtime_error("No columns marked as reference");
-  for (size_t row=0; row<m.rows(); ++row)
-    t[row]/=yes;
+  for (size_t row=0; row<m.rows(); ++row) {
+    if (!yes[row])
+      throw std::runtime_error("At least one row with no valid reference");
+    t[row]/=yes[row];
+  }
 }
 
 
-void create_target(std::vector<double>& t, const Matrix& m)
+void create_target(std::vector<double>& t, const MatrixWeighted& m)
 {
   for (size_t row=0; row<m.rows(); ++row) {
     t[row]=0;
     for (size_t column=0; column<m.columns(); ++column)
-      t[row]+=m(row,column);
+      t[row]+=m(row,column).data();
     t[row]/=m.columns();
   }
 }
+
+
+std::ostream& operator<< (std::ostream& s, const MatrixWeighted& m)
+{
+  s.setf(std::ios::dec);
+  s.precision(12);
+  for(size_t i=0, j=0; i<m.rows(); i++)
+    for (j=0; j<m.columns(); j++) {
+      s << m(i,j).data();
+      if (j<m.columns()-1)
+        s << s.fill();
+      else if (i<m.rows()-1)
+        s << "\n";
+    }
+  return s;
+}

plugins/base2/net.sf.basedb.normalizers/trunk/src/net/sf/basedb/plugins/qQuantileNormalization.java

@@ -263 +263 @@
           // C/C++ style string nan's (Java expects NaN) will cause a
           // NumberFormatException which also an emtpy string
-          // does. However, we do not expect missing values in the
-          // resulting matrix. Postponing exception catching until
-          // they start occuring.
-          batcher.insert(column.get(i), position,
-                         Float.parseFloat(lineSplit[i]));
+          // does.
+          try
+          {
+            float value=Float.parseFloat(lineSplit[i]);
+            if (value!=Float.NaN) batcher.insert(column.get(i), position, value);
+          }
+          catch (NumberFormatException e)
+          {
+            // Assume all NumberFormatExceptions are triggered by
+            // nan's in the result file. Nan's in the result file
+            // represents a missing value and should not be stored in
+            // BASE since BASE missing values are really missing in
+            // BASE.
+          }
         }
       }