fitonoff.hh

#ifndef LOCARNA_FIT_ON_OFF_HH
#define LOCARNA_FIT_ON_OFF_HH
 
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
 
#include <string>
#include <vector>
 
#include <cmath>
 
namespace LocARNA {
 
    typedef std::vector<double> numseq_t;
    typedef std::vector<double>::size_type size_type;
 
    typedef long double pf_t;
 
    class FitOnOff {
        numseq_t x;
        double delta_val;
        double beta;
 
        pf_t exp_delta_val; 
 
        std::vector<std::vector<pf_t> > v; 
 
        std::vector<std::vector<bool> > t; 
 
        std::vector<bool> trace;
 
        /*
        * helper-functions for switching between position
        * and non-position dependent penalties
        */
 
        protected:
                virtual
                double delta(int i) const {return delta_val;}
                virtual
                double exp_delta(int i) const {return exp_delta_val;}
 
    public:
        FitOnOff(numseq_t &x_, double delta_, double beta_)
            : x(x_), delta_val(delta_), beta(beta_) {
            v.resize(2);
            v[0].resize(x.size() + 1);
            v[1].resize(x.size() + 1);
 
            t.resize(2);
            t[0].resize(x.size() + 1);
            t[1].resize(x.size() + 1);
            trace.resize(x.size() + 1);
 
            exp_delta_val = exp(-beta * delta_val);
        }
 
        double
        viterbi(double c0, double c1, bool traceback);
 
        double
        best_once_on(double c0, double c1);
 
        pf_t
        forward(double c0, double c1);
 
        std::pair<double, double>
        optimize(double c0, double c1);
 
        void
        write_viterbi_path_compact(std::ostream &out, double c0, double c1);
 
        void
        write_viterbi_path(std::ostream &out, double c0, double c1) const;
 
        // DEBUGGING
 
        void
        print_table(const std::string &name, const std::vector<bool> &v) const;
 
        void
        print_table(const std::string &name, const std::vector<pf_t> &v) const;
 
        void
        print_tables() const;
    };
 
    class FitOnOffVarPenalty : public FitOnOff {
    public:
        FitOnOffVarPenalty(numseq_t &x_, numseq_t &penalties_, double beta_)
            : FitOnOff(x_, 0, beta_), penalties(penalties_) {
 
            // pre-calculation of exp_penalties parameter
            int length_penalties = penalties.size();
            for (int i = 0; i < length_penalties; i++) {
                exp_penalties.push_back(exp(-beta_ * penalties.at(i)));
            }
        }
 
    protected:
        virtual
        double delta(int i) const {return penalties.at(i-1);}
        virtual
        double exp_delta(int i) const {return exp_penalties.at(i-1);}
 
    private:
        numseq_t penalties;
        numseq_t exp_penalties;
    };
} // END namespace LocARNA
 
#endif // LOCARNA_FIT_ON_OFF_HH