source: trunk/test/alignment.cc @ 2815

// $Id: alignment.cc 2815 2012-08-28 02:38:36Z peter $

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

  This file is part of the yat library, http://dev.thep.lu.se/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 3 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 yat. If not, see <http://www.gnu.org/licenses/>.
*/

#include "Suite.h"

#include "yat/utility/Aligner.h"
#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(std::abs(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.resize(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(int argc, char* argv[])
{
  test::Suite suite(argc, argv);

  std::ifstream s(test::filename("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::Aligner(100, 100).smith_waterman(m);
  if (score!=21)
    suite.add(false);

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

  return suite.return_value();
}