Mutator.hpp

/*
    Copyright 2009, 2010, 2012 Stéphane De Mita, Mathieu Siol

    This file is part of the EggLib library.

    EggLib 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.

    EggLib 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 EggLib.  If not, see <http://www.gnu.org/licenses/>.
*/

#ifndef EGGLIB_MUTATOR_HPP
#define EGGLIB_MUTATOR_HPP


#include "DataMatrix.hpp"
#include "Random.hpp"
#include "Arg.hpp"
#include "Mutation.hpp"


namespace egglib {
    

    class Mutator {

        public:
        
            Mutator();

            
            ~Mutator();
            
            
            Mutator(const Mutator&);
        
        
            Mutator& operator=(const Mutator&);


            void reset();
            
            
            unsigned int fixedNumberOfMutations() const;
        

            void fixedNumberOfMutations(unsigned int);


            double mutationRate() const;
        
        
            void mutationRate(double);


            char mutationModel() const;
            
            
            void mutationModel(char);
            
            
            unsigned int numberOfAlleles() const;
           
            
            void numberOfAlleles(unsigned int);
           
           
            void transitionWeight(unsigned int i, unsigned int j, double value);


            double transitionWeight(unsigned int i, unsigned int j);
            
            
            void randomAncestralAllele(bool flag);

            
            bool randomAncestralAllele() const;

           
            double TPMproba() const;
            
            
            void TPMproba(double value);
           
            
            double TPMparam() const;
            
            
            void TPMparam(double value);


            unsigned int numberOfSites() const;
           
            
            void numberOfSites(unsigned int);
            
            
            double sitePosition(unsigned int siteIndex) const;

            
            void sitePosition(unsigned int siteIndex, double position);


            double siteWeight(unsigned int siteIndex) const;

            
            void siteWeight(unsigned int siteIndex, double weight);


            DataMatrix mute(Arg* arg, Random* random);


            unsigned int numberOfMutations() const; 


        private:
        
            void clear();
            void init();
            void copy(const Mutator&);

            //int nextAllele(int allele, Random* random);
            int TPMstep(double inTPMproba, Random* random);
            void apply_mutation(unsigned int matrixIndex,
                                unsigned int actualSite, DataMatrix& data,
                                const Edge* edge, int allele,
                                unsigned int segment, Random* random);

        
            char _model;
            double _mutationRate;
            unsigned int _fixedNumberOfMutations;
            unsigned int _numberOfAlleles;
            double** _transitionWeights;
            bool _randomAncestralAllele;
            unsigned int _numberOfSites;
            double* _sitePositions;
            double* _siteWeights;
            double _TPMproba;
            double _TPMparam;
            int maxAllele;
            unsigned int _numberOfMutations;
            std::vector<Mutation> _cache_mutations;
            unsigned int _cache_mutations_reserved;

    };


    bool compare(Mutation mutation1, Mutation mutation2); // returns True if mutation1 is older

}




#endif