alg/conserved_path.cxx

   1 #include "alg/conserved_path.h"
   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 /////////////////////
 130 ExtendedConservedPath::ExtendedConservedPath()
 131   : ConservedPath(),
 132     window_size(0)
 133 {
 134 }
 135
 136 ExtendedConservedPath::ExtendedConservedPath(const ExtendedConservedPath& other)
 137   : ConservedPath(other),
 138     window_size(other.window_size)
 139 {
 140 }
 141
 142 ExtendedConservedPath::ExtendedConservedPath(int win_size, ConservedPath other)
 143   : ConservedPath(other),
 144     window_size(win_size)
 145 {
 146 }
 147
 148 ExtendedConservedPath::ExtendedConservedPath(int win_size,
 149                                              double s,
 150                                              ConservedPath::path_type p)
 151   : ConservedPath(s, p),
 152     window_size(win_size)
 153 {
 154 }
 155
 156 ExtendedConservedPath& ExtendedConservedPath::extend(int growth)
 157 {
 158   window_size += growth;
 159
 160   // What does this actually do? Tristan's code was doing this operation
 161   // but I don't understand how it properly adjusts reverse compliment
 162   // windows?
 163   for(ConservedPath::iterator path_i = begin();
 164       path_i != end();
 165       ++path_i)
 166   {
 167     if (*path_i < 0)
 168       *path_i += growth;
 169   }
 170   return *this;
 171 }
 172
 173