alg/conserved_path.cpp

   1 #include "alg/conserved_path.hpp"
   2 #include <stdexcept>
   3
   4 using namespace std;
   5
   6 /////////////////////
   7
   8 ConservedPath::ConservedPath()
   9   : score(0.0),
  10     track_indexes()
  11 {
  12 }
  13
  14 ConservedPath::ConservedPath(const ConservedPath::ConservedPath& other)
  15   : score(other.score),
  16     track_indexes(other.track_indexes)
  17 {
  18 }
  19
  20 ConservedPath::ConservedPath(double s, ConservedPath::path_type path)
  21   : score(s),
  22     track_indexes(path)
  23 {
  24 }
  25
  26 void ConservedPath::clear()
  27 {
  28   score = 0.0;
  29   track_indexes.clear();
  30 }
  31
  32 ConservedPath::path_element&
  33 ConservedPath::operator[](ConservedPath::size_type index)
  34 {
  35   return track_indexes[index];
  36 }
  37
  38 bool operator==(const ConservedPath::ConservedPath& a,
  39                 const ConservedPath::ConservedPath& b)
  40 {
  41   // this isn't good as score is now a double
  42   return (     (a.score == b.score)
  43            and (a.track_indexes.size() == b.track_indexes.size())
  44            and (a.track_indexes == b.track_indexes));
  45 }
  46
  47 bool operator!=(const ConservedPath::ConservedPath& a,
  48                 const ConservedPath::ConservedPath& b)
  49 {
  50   return not (a == b);
  51 }
  52
  53 std::ostream& operator<<(std::ostream& out, const ConservedPath& path)
  54 {
  55   out << "<path score=" << path.score
  56       << " len=" << path.track_indexes.size();
  57   if (path.track_indexes.size() > 0)
  58   {
  59     // print the first element
  60     ConservedPath::const_iterator itor = path.begin();
  61     out << ">" << *itor;
  62     // print the remaining elements
  63     for (;
  64         itor != path.end();
  65         ++itor)
  66     {
  67       out << ", " << *itor;
  68     }
  69     out << "</path>";
  70   }
  71   else
  72   {
  73     // if we had no elements just close the block
  74     out << "/>";
  75   }
  76   return out;
  77 }
  78
  79 void ConservedPath::push_back(const ConservedPath::path_element& element)
  80 {
  81   track_indexes.push_back(element);
  82 }
  83
  84 void ConservedPath::pop_back()
  85 {
  86   track_indexes.pop_back();
  87 }
  88
  89 ConservedPath::size_type ConservedPath::size() const
  90 {
  91   return track_indexes.size();
  92 }
  93
  94 ConservedPath::iterator ConservedPath::begin()
  95 {
  96   return track_indexes.begin();
  97 }
  98
  99 ConservedPath::const_iterator ConservedPath::begin() const
 100 {
 101   return track_indexes.begin();
 102 }
 103
 104 ConservedPath::iterator ConservedPath::end()
 105 {
 106   return track_indexes.end();
 107 }
 108
 109 ConservedPath::const_iterator ConservedPath::end() const
 110 {
 111   return track_indexes.end();
 112 }
 113
 114 bool ConservedPath::nextTo(const ConservedPath& next) const
 115 {
 116   if (size() != next.size() ) {
 117     throw runtime_error("paths must be the same length");
 118   }
 119   ConservedPath::const_iterator this_itor = begin();
 120   ConservedPath::const_iterator next_itor = next.begin();
 121   for (; this_itor != end(); ++this_itor, ++next_itor)
 122   {
 123     if ( (*this_itor + 1) != *next_itor )
 124       return false;
 125   }
 126   return true;
 127 }
 128
 129 vector<bool> ConservedPath::reverseComplimented() const
 130 {
 131   vector<bool> reversed;
 132   for (ConservedPath::const_iterator this_itor = begin();
 133        this_itor != end();
 134        ++this_itor)
 135   {
 136     if (*this_itor < 0)
 137       reversed.push_back(true);
 138     else
 139       reversed.push_back(false);
 140   }
 141   return reversed;
 142
 143 }
 144
 145 /////////////////////
 146 ExtendedConservedPath::ExtendedConservedPath()
 147   : ConservedPath(),
 148     window_size(0)
 149 {
 150 }
 151
 152 ExtendedConservedPath::ExtendedConservedPath(const ExtendedConservedPath& other)
 153   : ConservedPath(other),
 154     window_size(other.window_size)
 155 {
 156 }
 157
 158 ExtendedConservedPath::ExtendedConservedPath(int win_size, ConservedPath other)
 159   : ConservedPath(other),
 160     window_size(win_size)
 161 {
 162 }
 163
 164 ExtendedConservedPath::ExtendedConservedPath(int win_size,
 165                                              double s,
 166                                              ConservedPath::path_type p)
 167   : ConservedPath(s, p),
 168     window_size(win_size)
 169 {
 170 }
 171
 172 ExtendedConservedPath& ExtendedConservedPath::extend(int growth)
 173 {
 174   window_size += growth;
 175
 176   // What does this actually do? Tristan's code was doing this operation
 177   // but I don't understand how it properly adjusts reverse compliment
 178   // windows?
 179   for(ConservedPath::iterator path_i = begin();
 180       path_i != end();
 181       ++path_i)
 182   {
 183     if (*path_i < 0)
 184       *path_i += growth;
 185   }
 186   return *this;
 187 }
 188
 189