Interaction.h

Go to the documentation of this file.

 
#ifndef INTARNA_INTERACTION_H_
#define INTARNA_INTERACTION_H_
 
#include <algorithm>
#include <sstream>
#include <set>
#include <utility>
#include <vector>
 
#include <boost/functional/hash.hpp>
 
#include "IntaRNA/general.h"
#include "IntaRNA/IndexRangeList.h"
#include "IntaRNA/RnaSequence.h"
#include "IntaRNA/InteractionRange.h"
 
 
namespace IntaRNA {
 
// dummy declaration to avoid inclusion loop
class InteractionRange;
 
 
class Interaction {
 
public:
 
    class BasePair {
 
    public:
 
        size_t first;  
        size_t second;  
 
        BasePair( const size_t first=RnaSequence::lastPos,
                  const size_t second=RnaSequence::lastPos )
            : first(first), second(second)
        {}
 
        struct Hash {
            size_t operator()(const BasePair &i ) const
          {
              size_t key = 0;
              boost::hash_combine(key, i.first);
              boost::hash_combine(key, i.second);
              return key;
          }
        };
 
        const bool
        operator <  ( const BasePair &bp ) const {
            return (first < bp.first)
                    || (first == bp.first && second < bp.second);
        }
 
        const bool
        operator ==  ( const BasePair &bp ) const {
            return first == bp.first
                && second == bp.second;
        }
 
    };
 
    typedef std::vector<BasePair> PairingVec;
 
    class Boundary {
 
    public:
 
        size_t i1;  
        size_t j1;  
        size_t i2;  
        size_t j2;  
 
        Boundary( const size_t i1=RnaSequence::lastPos, const size_t j1=RnaSequence::lastPos
             , const size_t i2=RnaSequence::lastPos, const size_t j2=RnaSequence::lastPos )
            : i1(i1), j1(j1), i2(i2), j2(j2)
        {}
 
        struct Hash {
            size_t operator()(const Boundary &i ) const
            {
                size_t key = 0;
                boost::hash_combine(key, i.i1);
                boost::hash_combine(key, i.j1);
                boost::hash_combine(key, i.i2);
                boost::hash_combine(key, i.j2);
                return key;
            }
        };
 
        const bool
        operator == ( const Boundary & rhs ) const
        {
            return i1 == rhs.i1
                && i2 == rhs.i2
                && j1 == rhs.j1
                && j2 == rhs.j2 ;
        }
 
    };
 
 
    class Seed {
    public:
 
        Seed();
 
        Seed(   const BasePair & bp_i
                , const BasePair & bp_j
                , const E_type energy );
 
        BasePair bp_i;
        BasePair bp_j;
        E_type energy;
 
        const bool
        operator <  ( const Seed &s ) const {
            if (! E_equal(energy, s.energy )) {
                return energy < s.energy;
            }
            if (bp_i.first != s.bp_i.first) {
                return bp_i.first < s.bp_i.first;
            }
            if (bp_i.second != s.bp_i.second) {
                return bp_i.second < s.bp_i.second;
            }
            if (bp_j.first != s.bp_j.first) {
                return bp_j.first < s.bp_j.first;
            }
            return bp_j.second < s.bp_j.second;
        }
 
        const bool
        operator ==  ( const Seed &s ) const {
            return E_equal(energy, s.energy )
                    && bp_i == s.bp_i
                    && bp_j == s.bp_j
                    ;
        }
 
    };
 
    typedef std::set<Seed> SeedSet;
 
public:
 
    const RnaSequence * s1;
 
    const RnaSequence * s2;
 
    PairingVec basePairs;
 
    E_type energy;
 
    SeedSet * seed;
 
    Interaction( const RnaSequence & s1, const RnaSequence & s2 );
 
    Interaction( const Interaction & toCopy );
 
    Interaction( const InteractionRange & range );
 
    virtual ~Interaction();
 
    bool
    isValid() const;
 
    bool
    isEmpty() const;
 
    void
    sort();
 
    void
    clear();
 
    void
    setSeedRange( const BasePair bp_left, const BasePair bp_right, const E_type energy );
 
    IndexRangeList
    getSeedRanges1() const;
 
    IndexRangeList
    getSeedRanges2() const;
 
    Interaction &
    operator= ( const Interaction & toCopy );
 
    Interaction &
    operator= ( const InteractionRange & range );
 
    bool operator < ( const Interaction &i ) const;
 
    bool operator == ( const Interaction &i ) const;
 
    static
    bool
    compareEnergy( const E_type& energy, const Interaction & hasLargerE );
 
    friend std::ostream& operator<<(std::ostream& out, const BasePair& bp);
 
    friend std::ostream& operator<<(std::ostream& out, const Boundary& b);
 
    friend std::ostream& operator<<(std::ostream& out, const Interaction& i);
 
    static
    std::string
    dotBar( const Interaction & i, const bool fullLength = false );
 
    static
    std::string
    dotBracket( const Interaction & i, const char symOpen = '(', const char symClose = ')', const bool fullLength = false);
 
 
protected:
 
    template < typename bpIterator >
    static
    std::string
    dotSomething( bpIterator bpBegin, const bpIterator bpEnd, const bool handleSeq1, const char bpSymbol );
 
 
};
 
 
 
 
 
inline
Interaction::Interaction( const RnaSequence & s1, const RnaSequence & s2 )
:
    s1(&s1)
    , s2(&s2)
    , basePairs()
    , energy( E_INF )
    , seed( NULL )
{
}
 
 
inline
Interaction::Interaction( const Interaction & toCopy )
:
    s1(toCopy.s1)
    , s2(toCopy.s2)
    , basePairs(toCopy.basePairs)
    , energy( toCopy.energy )
    , seed( toCopy.seed == NULL ? NULL : new SeedSet() )
{
    // copy seed if needed
    if (seed != NULL) {
        // copy all seeds
        seed->insert(toCopy.seed->begin(), toCopy.seed->end());
    }
}
 
 
inline
Interaction::Interaction( const InteractionRange & range )
:
    s1(NULL)
    , s2(NULL)
    , basePairs()
    , energy( E_INF )
    , seed( NULL )
{
    // init data
    this->operator =( range );
}
 
 
inline
Interaction::~Interaction()
{
    INTARNA_CLEANUP(seed);
}
 
 
inline
bool
Interaction::
isEmpty() const
{
    return basePairs.size()==0;
}
 
 
inline
void
Interaction::
sort()
{
    // sort based on STL functionalities for vector and pair
    std::sort(basePairs.begin(), basePairs.end());
}
 
 
inline
void
Interaction::
clear()
{
    // clear interaction base pairing information
    basePairs.clear();
    // clear energy
    energy = E_INF;
    // undo seed information
    INTARNA_CLEANUP(seed);
 
}
 
 
inline
bool
Interaction::
compareEnergy( const E_type & energy, const Interaction & hasLargerE )
{
    return energy < hasLargerE.energy && !(E_equal(energy,hasLargerE.energy));
}
 
 
inline
bool
Interaction::
operator < ( const Interaction &i ) const
{
#if INTARNA_IN_DEBUG_MODE
    if (i.s1 != s1 || i.s2 != s2) throw std::runtime_error("Interaction::operator < () : comparing interactions for different sequences");
    if (basePairs.empty() || i.basePairs.empty()) throw std::runtime_error("Interaction::operator < () : comparing empty interactions");
#endif
    // check if energy is larger
    if (energy > i.energy && !(E_equal(energy, i.energy))) {
        return false;
    }
    // check if energy is equal
    if (E_equal(energy, i.energy)) {
        return
        // i1 is smaller
            basePairs.begin()->first < i.basePairs.begin()->first // i1
        // i1 is equal BUT i2 smaller
        || (basePairs.begin()->first == i.basePairs.begin()->first // i1
                && basePairs.begin()->second < i.basePairs.begin()->second) // i2
        // i1 and i2 are equal BUT j1 smaller
        || (basePairs.begin()->first == i.basePairs.begin()->first // i1
                && basePairs.begin()->second == i.basePairs.begin()->second // i2
                && basePairs.rbegin()->first < i.basePairs.rbegin()->first) // j1
        // i1, i2 and j1 are equal BUT j2 smaller
        || (basePairs.begin()->first == i.basePairs.begin()->first // i1
                && basePairs.begin()->second == i.basePairs.begin()->second // i2
                && basePairs.rbegin()->first == i.basePairs.rbegin()->first // j1
                && basePairs.rbegin()->second < i.basePairs.rbegin()->second) // j2
        // i1, i2, j1, j2 are equal BUT more base pairs
        || (basePairs.begin()->first == i.basePairs.begin()->first // i1
                && basePairs.begin()->second == i.basePairs.begin()->second // i2
                && basePairs.rbegin()->first == i.basePairs.rbegin()->first // j1
                && basePairs.rbegin()->second == i.basePairs.rbegin()->second // j2
                && basePairs.size() > i.basePairs.size())
        // i1, i2, j1, j2, #bps are equal BUT first seed energy smaller
        || (basePairs.begin()->first == i.basePairs.begin()->first // i1
                && basePairs.begin()->second == i.basePairs.begin()->second // i2
                && basePairs.rbegin()->first == i.basePairs.rbegin()->first // j1
                && basePairs.rbegin()->second == i.basePairs.rbegin()->second // j2
                && basePairs.size() == i.basePairs.size()
                && seed != NULL && seed->size() > 0 && i.seed != NULL && i.seed->size() > 0 && seed->begin()->energy < i.seed->begin()->energy)
            ;
    } else {
        // has to have smaller energy
        return true;
    }
}
 
 
template < typename bpIterator >
inline
std::string
Interaction::
dotSomething( bpIterator bp, const bpIterator bpEnd, const bool handleSeq1, const char bpSymbol )
{
    // stream to compile output
    std::stringstream dotBracket;
    // compile dotBracket1
    for (bpIterator bpLast = bp; bp!=bpEnd; bp++) {
        // fill unpaired up to current bp in seq1
        for ( size_t u = handleSeq1 ? (bp->first - bpLast->first) : (bp->second - bpLast->second); u>1; u-- ) {
            dotBracket <<'.';
        }
        // add base pair
        dotBracket <<bpSymbol;
        // update last bp for next round
        bpLast = bp;
    }
    // return compiled string
    return dotBracket.str();
}
 
 
} // namespace
 
 
#endif /* INTERACTION_H_ */