AbstractMixedTransitionModel.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: The Bio++ Development Group
//
// SPDX-License-Identifier: CECILL-2.1
 
#ifndef BPP_PHYL_MODEL_ABSTRACTMIXEDTRANSITIONMODEL_H
#define BPP_PHYL_MODEL_ABSTRACTMIXEDTRANSITIONMODEL_H
 
#include <Bpp/Seq/Container/SequenceContainerTools.h>
#include <cstring> // C lib for string copy
#include <map>
#include <string>
#include <vector>
 
#include "AbstractSubstitutionModel.h"
#include "MixedTransitionModel.h"
 
namespace bpp
{
class AbstractMixedTransitionModel :
  public virtual MixedTransitionModelInterface,
  public virtual AbstractTransitionModel
{
protected:
  std::vector< std::shared_ptr<TransitionModelInterface>> modelsContainer_;
 
  std::vector<double> vProbas_;
 
  std::vector<double> vRates_;
 
public:
  AbstractMixedTransitionModel(
      std::shared_ptr<const Alphabet>,
      std::shared_ptr<const StateMapInterface> stateMap,
      const std::string& prefix);
 
  AbstractMixedTransitionModel(const AbstractMixedTransitionModel&);
 
  AbstractMixedTransitionModel& operator=(const AbstractMixedTransitionModel&);
 
  virtual AbstractMixedTransitionModel* clone() const override = 0;
 
public:
  virtual size_t getNumberOfModels() const override
  {
    return modelsContainer_.size();
  }
 
  const TransitionModelInterface& nModel(size_t i) const override
  {
    return *modelsContainer_[i];
  }
 
  std::shared_ptr<const TransitionModelInterface> getNModel(size_t i) const override
  {
    return modelsContainer_[i];
  }
 
  double getNRate(size_t i) const override
  {
    return vRates_[i];
  }
 
  virtual void setRate(double rate) override;
 
  virtual void setVRates(const Vdouble& vd) override;
 
  virtual void normalizeVRates() override;
 
  const std::vector<double>& getVRates() const override
  {
    return vRates_;
  }
 
  virtual double getNProbability(size_t i) const override
  {
    return vProbas_[i];
  }
 
  virtual const std::vector<double>& getProbabilities() const override
  {
    return vProbas_;
  }
 
  virtual void setNProbability(size_t i, double prob) override
  {
    if (prob < 0)
      prob = 0;
    if (prob > 1)
      prob = 1;
 
    vProbas_[i] = prob;
  }
 
  virtual const Matrix<double>& getPij_t(double t) const override;
  virtual const Matrix<double>& getdPij_dt(double t) const override;
  virtual const Matrix<double>& getd2Pij_dt2(double t) const override;
 
  bool computeFrequencies() const override
  {
    return modelsContainer_[0]->computeFrequencies();
  }
 
  void computeFrequencies(bool yn) override
  {
    for (auto& sm : modelsContainer_)
    {
      sm->computeFrequencies(yn);
    }
  }
 
  void setFreq(std::map<int, double>& frequ) override
  {
    for (auto& sm : modelsContainer_)
    {
      sm->setFreq(frequ);
    }
  }
 
  void setFreqFromData(const SequenceDataInterface& data, double pseudoCount) override
  {
    std::map<int, double> freqs;
    SequenceContainerTools::getFrequencies(data, freqs, pseudoCount);
    setFreq(freqs);
  }
 
protected:
  TransitionModelInterface& nModel_(size_t i) override
  {
    return *modelsContainer_[i];
  }
};
} // end of namespace bpp.
#endif // BPP_PHYL_MODEL_ABSTRACTMIXEDTRANSITIONMODEL_H