src/LocARNA/mcc_matrices.hh

#ifndef LOCARNA_MCC_MATRICES_HH
#define LOCARNA_MCC_MATRICES_HH

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

#include <assert.h>

#define PUBLIC // for Vienna

extern "C" {
#include <ViennaRNA/params.h> // import pf_paramT definition
}

namespace LocARNA {

    class McC_matrices_base {
    protected:
        vrna_fold_compound_t *vc_;

        explicit
        McC_matrices_base(vrna_fold_compound_t *vc);

    public:
        virtual ~McC_matrices_base();

        size_t
        iidx(size_t i, size_t j) const {
            assert(1 <= i);
            assert(i <= j);
            assert(j <= vc_->length);

            return vc_->iindx[i] - j;
        }

        size_t
        jidx(size_t i, size_t j) const {
            assert(1 <= i);
            assert(i <= j);
            assert(j <= vc_->length);

            return vc_->jindx[j] + i;
        }

        FLT_OR_DBL
        bppm(size_t i, size_t j) const {
            return vc_->exp_matrices->probs[iidx(i, j)];
        }

        FLT_OR_DBL
        qb(size_t i, size_t j) const {
            return vc_->exp_matrices->qb[iidx(i, j)];
        }

        FLT_OR_DBL
        qm(size_t i, size_t j) const {
            return vc_->exp_matrices->qm[iidx(i, j)];
        }

        vrna_exp_param_t *
        exp_params() const {
            return vc_->exp_params;
        }

        FLT_OR_DBL
        scale(size_t i) const {
            return vc_->exp_matrices->scale[i];
        }

        FLT_OR_DBL
        expMLbase(size_t i) const {
            return vc_->exp_matrices->expMLbase[i];
        }

        FLT_OR_DBL
        kT() const {
            return vc_->exp_params->kT;
        }

        FLT_OR_DBL
        q1k(size_t k) const {
            return vc_->exp_matrices->q1k[k];
        }

        FLT_OR_DBL
        qln(size_t l) const {
            return vc_->exp_matrices->qln[l];
        }

        int
        pair(size_t c, size_t d) const {
            assert(vc_);
            assert(vc_->exp_params);
            return vc_->exp_params->model_details.pair[c][d];
        }
    };

    class McC_matrices_t : public McC_matrices_base {
    public:
        explicit
        McC_matrices_t(vrna_fold_compound_t *vc);

        virtual ~McC_matrices_t();

        char
        ptype(size_t i, size_t j) const {
            return vc_->ptype[jidx(i, j)];
        }

        char
        rev_ptype(size_t i, size_t j) const {
            return vc_->exp_params->model_details.rtype[(size_t)ptype(i, j)];
        }

        short
        S1(size_t i) const {
            return vc_->sequence_encoding[i];
        }

        char *
        sequence() const {
            return vc_->sequence;
        }
    };

    class McC_ali_matrices_t : public McC_matrices_base {
    public:
        explicit
        McC_ali_matrices_t(vrna_fold_compound_t *vc);

        virtual ~McC_ali_matrices_t();

        short
        pscore(size_t i, size_t j) const {
            return vc_->pscore[jidx(i, j)];
        }

        short
        S(size_t s, size_t i) const {
            return vc_->S[s][i];
        }

        short
        S3(size_t s, size_t i) const {
            return vc_->S3[s][i];
        }

        short
        S5(size_t s, size_t i) const {
            return vc_->S5[s][i];
        }

        short
        a2s(size_t s, size_t i) const {
            return vc_->a2s[s][i];
        }

        char *
        Ss(size_t s) const {
            return vc_->Ss[s];
        }
    };

} // end namespace LocARNA

#endif // LOCARNA_MCC_MATRICES_HH