source: trunk/test/alignment_test.cc @ 875

// $Id: alignment_test.cc 875 2007-09-19 00:17:05Z peter $

/*
  Copyright (C) 2005 Jari Häkkinen, Peter Johansson
  Copyright (C) 2006, 2007 Jari Häkkinen

  This file is part of the yat library, http://trac.thep.lu.se/trac/yat

  The yat library is free software; you can redistribute it and/or
  modify it under the terms of the GNU General Public License as
  published by the Free Software Foundation; either version 2 of the
  License, or (at your option) any later version.

  The yat library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  02111-1307, USA.
*/

#include "yat/utility/Alignment.h"

#include "yat/utility/matrix.h"

#include <gsl/gsl_cdf.h>

#include <cassert>
#include <cmath>
#include <fstream>
#include <iostream>
#include <sstream>
#include <string>
#include <vector>

using namespace theplu::yat;

void read_vector(std::vector<double>& v,std::string& str)
{
  std::istringstream s(str);
  while (!s.eof()) {
    double d;
    s >> d;
    if (!s.fail())
      v.push_back(d);
  }
}

std::istream& operator>>(std::istream& s,
                         std::vector<std::vector<double> >& m)
{
  while (!s.eof()) {
    std::string row;
    char ch;
    while (((ch=s.get())!='\n') && s.good())
      row+=ch;
    if (row.size() || s.good()) { // if stream good, read an empty peak set
      std::vector<double> v;
      read_vector(v,row);
      m.push_back(v);
    }
  }
  return s;
}

double match(const double x, const double y, const double s)
{ 
  return 2*gsl_cdf_gaussian_Q(fabs(x-y),sqrt(2)*s); 
}
  

double score(const std::vector<double>& l1,
             const std::vector<double>& l2,
             const double sigma, 
             theplu::yat::utility::matrix& dot_matrix,
             std::vector<std::pair<size_t,size_t> >& path)
{
  dot_matrix.clone(theplu::yat::utility::matrix(l1.size(),l2.size()));
  for (size_t i=0; i<l1.size(); i++) 
    for (size_t j=0; j<l2.size(); j++) {
      assert(i<dot_matrix.rows());
      assert(j<dot_matrix.columns());
      dot_matrix(i,j)=match(l1[i],l2[j],sigma);
    }
  return theplu::yat::utility::NeedlemanWunsch(dot_matrix,path,0);
}


int main(const int argc,const char* argv[])
{
  bool ok=true;
  std::ostream* error;
  if (argc>1 && argv[1]==std::string("-v"))
    error = &std::cerr;
  else {
    error = new std::ofstream("/dev/null");
    if (argc>1)
      std::cout << "alignment_test -v : for printing extra "  
                << "information\n";
  }

  std::ifstream s(std::string("data/isoform.peaks").c_str());
  std::vector<std::vector<double> > peaksets;
  s >> peaksets;

  for (size_t i=0; i<peaksets.size()-1; i++) 
    for (size_t j=i+1; j<peaksets.size(); j++) {
      utility::matrix dot_m;
      std::vector<std::pair<size_t,size_t> > path;
      score(peaksets[i], peaksets[j], 1.0, dot_m, path);
    }

  std::string a("AGGUUGUCCGUGGUGAGUUCGCA");
  std::string b("GAGGUUGUCCGUGGUGAGUUCG");
  utility::matrix m(a.size(), b.size());
  for (size_t j=0; j<a.size(); ++j)
    for (size_t k=0; k<b.size(); ++k)
      m(j,k) = (a[j]==b[k] ? 1 : -1000);
  double score=utility::SmithWaterman(m, 100, 100);
  if (score!=21)
    ok=false;

  // testing ssearch
  if (utility::ssearch("Hello", "Hll", 0.0, 1.0)!=2){
    *error << "aligning 'Hello' and 'Hll' gives score " 
           << utility::ssearch("Hello", "Hll", 0.0, 1.0)
           << " expected " << 2 << std::endl;
    ok=false;
  }
  if (utility::ssearch("Hello", "Peter said you can't say 'allo", 1, 1)!=3)
    ok=false;

  if (ok)
    *error << "Test is ok." << std::endl;
  else
    *error << "Test fails." << std::endl;
    
  if (error!=&std::cerr)
    delete error;

  if (ok) {
    return 0;
  }
  return -1;

}