ribosum.hh

#ifndef LOCARNA_RIBOSUM_HH
#define LOCARNA_RIBOSUM_HH

#ifdef HAVE_CONFIG_H
#  include <config.h>
#endif

#include <cstdlib>
#include <string>
#include <fstream>
#include <math.h>

#include "matrix.hh"
#include "alphabet.hh"

namespace LocARNA {

    class Ribosum {
    public:
        typedef Matrix<double> matrix_t; 
    protected:
        typedef Alphabet<std::string> alphabet_type; 

        std::string name; 
        matrix_t bm;  
        matrix_t am;  


        alphabet_type basename_alphabet; 
        alphabet_type arcname_alphabet; 

        Alphabet<char> char_basename_alphabet; 


    protected:


        std::istream &
        read_matrix(std::istream &in, 
                    matrix_t &mat,
                    const alphabet_type &names) const;
    
        std::ostream &
        write_matrix(std::ostream &out, 
                     const matrix_t &mat,
                     const alphabet_type &alph) const;
    
        Ribosum();
        
        void
        read_ribosum(std::istream &in);

    
    protected:

        Alphabet<char> make_char_alphabet() const;

        void set_basename_alphabet(const std::string a[]) {
            basename_alphabet=alphabet_type(std::vector<std::string>(&a[0],&a[4]));
            char_basename_alphabet = make_char_alphabet();
        }
    
        void set_arcname_alphabet(const std::string a[]) {
            arcname_alphabet=alphabet_type(std::vector<std::string>(&a[0],&a[16]));
        }

    public:
        explicit
        Ribosum(const std::string &filename);
    
        virtual
        ~Ribosum();
    
        const matrix_t &get_basematch_scores() const {return bm;}
    
        const matrix_t &get_arcmatch_scores() const {return am;}

        const alphabet_type &string_alphabet() const {return basename_alphabet;}
    
        const Alphabet<char> &alphabet() const {return char_basename_alphabet;}
    
        const std::string & get_name() const {return name;}
    
        double basematch_score(char i,char j) const {
            return bm(alphabet().idx(i),alphabet().idx(j));
        }

        double arcmatch_score(char i,char j,char k,char l) const {
            return am(alphabet().idx(i)*4+alphabet().idx(j), alphabet().idx(k)*4+alphabet().idx(l));
        }
    
        friend std::ostream & operator << (std::ostream &out, const Ribosum &ribosum);
        
    };


    class RibosumFreq : public Ribosum {
    public:

        explicit
        RibosumFreq(const std::string &filename);

    protected:
        RibosumFreq();
    
        matrix_t base_probs_; 
        matrix_t base_nonstruct_probs_; 
        matrix_t basepair_probs_; 
        matrix_t basematch_probs_; 
        matrix_t arcmatch_probs_; 

    public:

        double
        base_prob(char i) const {
            return base_probs_(alphabet().idx(i),0);
        }

        double
        base_nonstruct_prob(char i) const {
            return base_nonstruct_probs_(alphabet().idx(i),0);
        }
    
        const matrix_t &
        get_base_probs() const {
            return base_probs_;
        }

        const matrix_t &
        get_base_nonstruct_probs() const {
            return base_nonstruct_probs_;
        }
    
        double
        basepair_prob(char i,char j) const {
            return basepair_probs_(alphabet().idx(i),alphabet().idx(j));
        }

        const matrix_t &
        get_basepair_probs() const {
            return basepair_probs_;
        }
    
        double
        basematch_prob(char i,char j) const {
            return basematch_probs_(alphabet().idx(i),alphabet().idx(j));
        }

        const matrix_t &
        get_basematch_probs() const {
            return basematch_probs_;
        }
    
        double
        arcmatch_prob(char i, char j, char k, char l) const {
            return arcmatch_probs_(alphabet().idx(i)*4+alphabet().idx(j), alphabet().idx(k)*4+alphabet().idx(l));
        }

        const matrix_t &
        get_arcmatch_probs() const {
            return arcmatch_probs_;
        }
    
    
        double
        base_unpaired_prob(char i) const;
    

        double
        basematch_score_corrected(char i,char j) const;

    
        void
        print_basematch_scores_corrected(std::ostream &out) const;
    
        void
        read_matrix(std::istream &in, const std::string &header, matrix_t &mat, size_t xdim, size_t ydim);

        void
        write_ICC_code(std::ostream &out, const std::string &ribname) const;
     
        std::ostream &
        write_matrix(std::ostream &out, const std::string &name, const Matrix<double> &mat) const;
    
        friend std::ostream & operator << (std::ostream &out, const RibosumFreq &ribosum);

    private:
    
        void write_CC_matrix(std::ostream &out,
                             const std::string &ribname,
                             const std::string &matname,
                             int x, int y, const Ribosum::matrix_t &m) const;

        void
        read_frequencies(std::istream &in);
    };

} // end namespace LocARNA

#endif //LOCARNA_RIBOSUM_HH