Align.h

/*  This file is part of Victor.

    Victor is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    Victor is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with Victor.  If not, see <http://www.gnu.org/licenses/>.
 */


#ifndef __Align_H__
#define __Align_H__

#include <Alignment.h>
#include <AlignmentData.h>
#include <GapFunction.h>
#include <IoTools.h>
#include <ScoringScheme.h>
#include <Traceback.h>
#include <algorithm>
#include <iostream>
#include <limits>
#include <math.h>
#include <string>
#include <vector>

#define EQ_EPS   1E-8

#define EQUALS(a, b)   (fabs(a - b) < EQ_EPS ? true : false)

namespace Victor { namespace Align2{

    class Align {
    public:


        enum {
            INVALID_POS = -1
        };


        // CONSTRUCTORS:

        Align(AlignmentData *ad, GapFunction *gf, ScoringScheme *ss);

        Align(const Align &orig);

        virtual ~Align();


        // OPERATORS:

        Align& operator =(const Align &orig);


        // PREDICATES:

        AlignmentData* getAlignmentData();

        GapFunction* getGapFunction();

        ScoringScheme* getScoringScheme();

        virtual Traceback next(const Traceback &tb) const;

        virtual double getScore() const;

        virtual vector<double> getMultiMatchScore(unsigned int num = 10);

        virtual vector<string> getMatch() const;

        virtual void getMultiMatch() = 0;

        virtual vector< vector<int> > getMatchSubset();

        virtual vector<int> shiftMatchSubset(vector<int> inputVector,
                int newStartPos);

        virtual void outputMultiMatch(ostream &os, unsigned int num = 10,
                bool fasta = false);

        virtual vector<Alignment> generateMultiMatch(unsigned int num = 1);

        virtual vector<double> generateMultiMatchScore(unsigned int num = 10);

        virtual void doMatch(ostream &os) const;

        virtual void doMatchPlusHeader(ostream &os, string headerTarget,
                string headerTemplate) const;


        // MODIFIERS:

        virtual void copy(const Align &orig);

        virtual Align* newCopy() = 0;

        void setPenalties(double mul, double add);

        void pModifyMatrix(int i, int j);

        virtual void recalculateMatrix();


        // HELPERS:

        virtual void pCalculateMatrix(bool update = true) = 0;

        virtual void pCalculateMatrix(const vector<unsigned int> &v1,
                const vector<unsigned int> &v2, bool update = true) = 0;


        // ATTRIBUTES:

        AlignmentData *ad; 
        GapFunction *gf; 
        ScoringScheme *ss; 
        vector< vector<double> > F; 
        vector< vector<Traceback> > B; 
        Traceback B0; 
        unsigned int n; 
        unsigned int m; 
        mutable vector<int> res1Pos; 
        mutable vector<int> res2Pos; 
        double penaltyMul; 
        double penaltyAdd; 


    protected:


    private:

    };

    // -----------------------------------------------------------------------------
    //                                    Align
    // -----------------------------------------------------------------------------

    // PREDICATES:

    inline AlignmentData*
    Align::getAlignmentData() {
        return ad;
    }

    inline GapFunction*
    Align::getGapFunction() {
        return gf;
    }

    inline ScoringScheme*
    Align::getScoringScheme() {
        return ss;
    }

    inline Traceback
    Align::next(const Traceback& tb) const {
        if ((B.size() > 0) && (tb.i >= 0) && (tb.j >= 0) &&
                (tb.i < static_cast<int> (B.size())) &&
                (tb.j < static_cast<int> (B[tb.i].size())))
            return B[tb.i][tb.j];
        return Traceback::getInvalidTraceback();
    }

    inline double
    Align::getScore() const {
        return F[B0.i][B0.j];
    }


    // MODIFIERS:
      inline void
    Align::setPenalties(double mul, double add) {
        penaltyMul = mul;
        penaltyAdd = add;
    }
    inline void
    Align::pModifyMatrix(int i, int j) {
        F[i][j] = penaltyMul * F[i][j] - penaltyAdd;
    }

}} // namespace

#endif