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