Range.h

Go to the documentation of this file.

#ifndef RANGE_H
#define RANGE_H

#include <iostream>
#include <list>

using namespace std;

class Range {
        public:
                Range() : b(0), e(0) {}
                Range(int begin, int end) : b(begin), e(end) {} 
      Range(pair<int,int> p) : b(p.first), e(p.second) { }
                Range(const Range &r) : b(r.b), e(r.e) {}
      Range(int p) : b(p), e(p) { }
                Range& operator=(const Range &r);
                ~Range() { }
      Range operator+(int c) const { return Range(b+c, e+c); }
      Range operator-(int c) const { return Range(b-c, e-c); }
      friend Range operator-(int c, const Range &r) { return Range(c-r.b, c-r.e); }
      friend Range operator+(int c, const Range &r) { return Range(c+r.b, c+r.e); }
      Range& operator+=(int c) { b += c; e += c; return *this; }
      Range& operator-=(int c) { b -= c; e -= c; return *this; }


      int begin() const { return b; }
      int end() const { return e; }
      bool empty() const { return b==0 && e==0; }
      virtual bool isNull() const { return b==0 && e==0; }
      virtual void setNull() { b=0; e=0; }
                int length() const;
                int smallerEnd() const { return b<e? b : e; }
      int low() const { return b<e? b : e; }
                int largerEnd() const { return e>b? e : b; }
      int high() const { return e>b? e : b; }
                char direction() const { return e>b? '+' : (b>e? '-' : '?'); }
      bool isPlus() const { return e>b; }
      bool isMinus() const { return e<b; }
      bool isPoint() const { return b==e; }


      int distance(const Range &r) const;

                int overlap(const Range &r, bool sameDirection=true) const;
                int overlay(const Range &r) const;

      float overlapFraction(const Range &r, bool sd=true) const;
      float overlayFraction(const Range &r) const;
                int plusOverlap(const Range &r) const;
                int minusOverlap(const Range &r) const;
                int plusminusOverlap(const Range &r) const;
                int minusplusOverlap(const Range &r) const;
                bool plusContain(const Range &r) const;
                bool minusContain(const Range &r) const;
                bool plusminusContain(const Range &r) const;
                bool minusplusContain(const Range &r) const;

                bool contain(const Range &r, bool sameDirection=true) const;
      bool contain(int p) const;

      bool inside(const Range &r) const {
         return min(b,e) >= min(r.b, r.e) && max(b,e) <= max(r.b, r.e);
      }
                bool similar(const Range &r, bool sameDirection=true) const;

                bool similar(const Range &r, const int marg=20, const float frac=0.1,
            bool sameDirection=true) const;

                int compare(const Range &r) const;
                int compare(const Range *r) const { return compare(*r); }
      bool less(const Range &r) const { return compare(r) == -1; }
                int compareDirectional(const Range &r) const;
      int compareByDirection(const Range &r) const;

                bool directionalLess(const Range &r) const { return compareDirectional(r) == -1; }

      bool sameDirection(const Range &r) const;
      int topology(const Range &r) const;

                bool operator==(const Range &r) const { return b==r.b && e==r.e; }
                bool operator!=(const Range &r) const { return b!=r.b || e!=r.e; }
                bool operator<(const Range &r) const {
                        return compare(r) == -1; }
                bool operator>(const Range &r) const {
                        return compare(r) == 1; }
      bool lessByDirection(const Range &r) const;
      bool lessByDirection(const Range *r) const;
      bool lessByDirection(int p, char direc='+') const;
      bool greaterByDirection(const Range &r) const { return !lessByDirection(r); }
      bool greaterByDirection(const Range *r) const { return !lessByDirection(r); }
      bool greaterByDirection(int p) const { return !lessByDirection(p); }
      bool before(const Range &r) const;
      bool after(const Range &r) const;


                bool merge(const Range &r, bool sd=true);
      bool fuse(const Range &r);
      void forceFuse(const Range &r);

      int combine(const Range &r);

      void set(int be, int en) { b=be; e=en; }
      void set(const Range &r) { b=r.begin(); e=r.end(); }
      void setEnd(int en) { e=en; }
      void endUpdate(int len) { e += len; }
      void setBegin(int be) { b=be; }
      void beginUpdate(int len) { b += len; }
      Range& reverse() { set(e, b); return *this; }
      //void reverse() { set(e, b); }
      Range getReverse() const { return Range(e,b); }
      Range copyReverse() const { return Range(e, b); }
      Range copyShrinkBothEnds(int del) const;
      void growEnd(int icr);


                friend ostream& operator<<(ostream &ous, const Range &r);
                // output in a row
                ostream& output(ostream &ous, const char delimiter[]="\t") const { 
                        ous << b << delimiter << e; return ous; }
                ostream& output(ostream &ous, char delim='\t') const { 
                        ous << b << delim << e; return ous; }
                string asDelimitedString(const char delimiter[]=",") const;
                string asDelimitedString(const char delimiter=',') const;

      static void setMargin(const int mg) { margin=mg; }


        protected:
                int b, e;  // begin and end

                static int margin; // default 16
                static float marginFraction; // default 0.1
};


bool lessRangeByDirectional(const Range *r1, const Range *r2);

class DRgreater {
   const Range *given;
   public:
      DRgreater(const Range &r) : given(&r) { }
      bool operator() (const Range *r2) const {
         return r2->greaterByDirection(given);
      }
};


class RangeChain : public Range {
        public:
                RangeChain() : chain(), sumolp(0) {}
                RangeChain(const RangeChain &ch);
      RangeChain(const string &raw);
                RangeChain(const Range &r) : sumolp(0) { 
                        chain.push_back(new Range(r)); }
                ~RangeChain();
      RangeChain& operator=(const RangeChain &rc);

                void add(const Range &r, bool sd=true);
                int getOverlap() const { return sumolp; }
      bool exonMerge(const RangeChain &rc);

                pair<int,int> length() const;
      int outerLength() const;
      Range outerRange() const;
      int sumLength() const;
      int exonLength() const { return sumLength(); }
      pair<int,int> intronLength() const;
      int maxIntronLength() const;
      int begin() const { return chain.front()->begin(); }
      int end() const { return chain.back()->end(); }
                friend ostream& operator<<(ostream &ous, const RangeChain &rc);
      pair<int,int> exonOverlap(const RangeChain &rc) const;
      int numberOfRanges() const { return chain.size(); }
      char direction() const;
      void order();
      ostream& tableRows(ostream &ous, const string &prefix) const;

      typedef list<Range*>::const_iterator const_iterator;
      const_iterator itbegin() const { return chain.begin(); }
      const_iterator itend() const { return chain.end(); }

        protected:
                list<Range*> chain;
                int sumolp; 
};

#endif