src/LocARNA/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