confusion_matrix.hh

#ifndef LOCARNA_CONFUSION_MATRIX
#define LOCARNA_CONFUSION_MATRIX

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

#include <cstddef>
#include <cassert>
#include <string>

namespace LocARNA {
    class RnaStructure;

    class ConfusionMatrix {
    public:
        typedef std::pair<size_t,size_t> bp_t;
        
        class BPFilter {
        public:
            BPFilter()
            {};

            virtual
            ~BPFilter()
            {};
            
            virtual
            bool
            operator () (size_t i, size_t j) const {
                assert(1<=i); // sequences are 1-based
                assert(i<=j);
                return true;
            }
            
            virtual 
            bool operator () (const bp_t &bp) const {
                return (*this)(bp.first,bp.second);
            }
        };

        class BPMinLoopSizeFilter : public BPFilter {
            size_t mls_;
        public:

            explicit
            BPMinLoopSizeFilter(size_t mls)
            : BPFilter(),
              mls_(mls)
            {}
            
            ~BPMinLoopSizeFilter() {};

            bool
            operator () (size_t i, size_t j) const {
                assert(i>=1);
                return i+mls_<j;
            }
        };
        
        class SpanRangeBPFilter: public BPFilter {
            size_t lo_;
            size_t up_;
        public:
            SpanRangeBPFilter(size_t lo, size_t up)
                : BPFilter(), lo_(lo), up_(up)
            {
                assert(1<=lo);
            }

             ~SpanRangeBPFilter() {};
            
            bool
            operator () (size_t i, size_t j) const {
                assert(i<=j);
                return lo_<=(j-i) && (up_==0 || (j-i)<=up_);
            }
        };

        class CanonicalBPFilter: public BPFilter {
            const std::string &sequence_;
        public:

            explicit
            CanonicalBPFilter(const std::string &sequence)
                : BPFilter(), 
                  sequence_(sequence)
            {}
            
            ~CanonicalBPFilter() {};
            
            bool
            operator () (size_t i, size_t j) const {
                return BPFilter::operator ()(i,j) && canonical(sequence_[i],sequence_[j]);
            }
        private:
            static
            bool
            canonical(char x, char y) {
                static std::string cpairs="AUCGGUUAGCUG";
                for(size_t i=0; i<cpairs.length(); i+=2) {
                    if (x==cpairs[i] && y==cpairs[i+1]) return true;
                }
                return false;
            }
        };

        class CombinedBPFilter: public BPFilter {
            const BPFilter &fa_;
            const BPFilter &fb_;
        public:
            CombinedBPFilter(const BPFilter &fa, const BPFilter &fb): 
                BPFilter(),fa_(fa),fb_(fb)
            {}
            
            ~CombinedBPFilter()
            {}
            
            bool
            operator () (size_t i, size_t j) const {
                return fa_(i,j) && fb_(i,j);
            }
        };

        
        ConfusionMatrix(const std::string &ref,
                        const std::string &pred,
                        const bool slide,
                        const bool conflict,
                        const BPFilter &filter=BPMinLoopSizeFilter(3)
                        );
        
        ConfusionMatrix(const RnaStructure &ref,
                        const RnaStructure &pred,
                        const bool slide,
                        const bool conflict,
                        const BPFilter &filter=BPMinLoopSizeFilter(3)
                        );

        size_t
        tp() const { return tp_; }
    
        size_t
        tn() const { return tn_; }

        size_t
        fp( ) const { return fp_; }

        size_t
        fn() const {    
            return fn_;
        }

        double
        ppv() const;

        double
        sens() const;

        double
        spec() const;

        double
        f1_score() const;

        double
        mcc() const;
        
    protected:
        
        size_t
        count_common_bps(const RnaStructure &s1,
                         const RnaStructure &s2);
        
        size_t
        count_tps(const RnaStructure &pred,
                  const RnaStructure &ref);
        
        size_t
        count_conflicting_base_pairs(const RnaStructure &s1,
                                     const RnaStructure &s2);
        size_t
        count_potential_base_pairs(size_t length);
        

        size_t
        count_base_pairs(const RnaStructure &s);
        
    private:
        void
        compute_confusion_matrix(const RnaStructure &ref, 
                                 const RnaStructure &pred);
        
        bool slide_;
        bool conflict_;
        const BPFilter &filter_;
        
        size_t tp_;  
        size_t tn_;  
        size_t fp_;  
        size_t fn_;  
    };

} // end namespace LocARNA


#endif // LOCARNA_CONFUSION_MATRIX