SubstitutionModel.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: The Bio++ Development Group
//
// SPDX-License-Identifier: CECILL-2.1
 
#ifndef BPP_PHYL_MODEL_SUBSTITUTIONMODEL_H
#define BPP_PHYL_MODEL_SUBSTITUTIONMODEL_H
 
#include <Eigen/Core>
 
#include "FrequencySet/FrequencySet.h"
#include "StateMap.h"
 
// From bpp-core:
#include <Bpp/Exceptions.h>
#include <Bpp/Numeric/Parameter.h>
#include <Bpp/Numeric/ParameterList.h>
#include <Bpp/Numeric/ParameterAliasable.h>
#include <Bpp/Numeric/VectorTools.h>
#include <Bpp/Numeric/Matrix/Matrix.h>
 
// From bpp-seq:
#include <Bpp/Seq/Alphabet/Alphabet.h>
#include <Bpp/Seq/Container/AlignmentData.h>
 
// From the STL:
#include <cstdlib>
#include <map>
#include <string>
 
namespace bpp
{
class BranchModelInterface :
  public virtual ParameterAliasable
{
public:
  BranchModelInterface() {}
  virtual ~BranchModelInterface() {}
 
  BranchModelInterface* clone() const = 0;
 
public:
  virtual std::string getName() const = 0;
 
  virtual const std::vector<int>& getAlphabetStates() const = 0;
 
  virtual const StateMapInterface& stateMap() const = 0;
 
  virtual std::shared_ptr<const StateMapInterface> getStateMap() const = 0;
 
  virtual std::vector<size_t> getModelStates(int code) const = 0;
 
  virtual std::vector<size_t> getModelStates(const std::string& code) const = 0;
 
  virtual int getAlphabetStateAsInt(size_t index) const = 0;
 
  virtual std::string getAlphabetStateAsChar(size_t index) const = 0;
 
  virtual const Alphabet& alphabet() const = 0;
 
  virtual std::shared_ptr<const Alphabet> getAlphabet() const = 0;
 
 
  virtual const FrequencySetInterface& frequencySet() const = 0;
 
  virtual size_t getNumberOfStates() const = 0;
 
  virtual double getInitValue(size_t i, int state) const = 0;
 
  virtual const Eigen::VectorXd& Lik_t(const Eigen::VectorXd& values, double t) const = 0;
  virtual const Eigen::VectorXd& dLik_dt(const Eigen::VectorXd& values, double t) const = 0;
  virtual const Eigen::VectorXd& d2Lik_dt2(const Eigen::VectorXd& values, double t) const = 0;
 
  virtual double getRate() const = 0;
 
  virtual void setRate(double rate) = 0;
 
  virtual void addRateParameter() = 0;
};
 
 
class TransitionModelInterface :
  public virtual BranchModelInterface
{
private:
 
public:
  TransitionModelInterface() {}
  virtual ~TransitionModelInterface() {}
 
  TransitionModelInterface* clone() const = 0;
 
public:
  virtual double freq(size_t i) const = 0;
 
  virtual double Pij_t(size_t i, size_t j, double t) const = 0;
 
  virtual double dPij_dt(size_t i, size_t j, double t) const = 0;
 
  virtual double d2Pij_dt2(size_t i, size_t j, double t) const = 0;
 
  virtual const Vdouble& getFrequencies() const = 0;
 
  virtual bool computeFrequencies() const = 0;
 
  virtual void computeFrequencies(bool yn) = 0;
 
  virtual const Matrix<double>& getPij_t(double t) const = 0;
 
  virtual const Matrix<double>& getdPij_dt(double t) const = 0;
 
  virtual const Matrix<double>& getd2Pij_dt2(double t) const = 0;
 
  virtual const Eigen::VectorXd& Lik_t(const Eigen::VectorXd& values, double t) const = 0;
 
  virtual const Eigen::VectorXd& dLik_dt(const Eigen::VectorXd& values, double t) const = 0;
 
  virtual const Eigen::VectorXd& d2Lik_dt2(const Eigen::VectorXd& values, double t) const = 0;
 
  virtual void setFreqFromData(const SequenceDataInterface& data, double pseudoCount = 0) = 0;
 
  virtual void setFreq(std::map<int, double>& frequencies) = 0;
 
protected:
  virtual Vdouble& getFrequencies_() = 0;
 
  friend class AbstractTotallyWrappedTransitionModel;
  friend class AbstractFromSubstitutionModelTransitionModel;
  friend class InMixedSubstitutionModel;
};
 
 
class SubstitutionModelInterface :
  public virtual TransitionModelInterface
{
public:
  SubstitutionModelInterface() {}
  virtual ~SubstitutionModelInterface() {}
 
  SubstitutionModelInterface* clone() const override = 0;
 
protected:
  // virtual void updateMatrices() = 0;
 
public:
  virtual double Qij(size_t i, size_t j) const = 0;
 
  virtual const Matrix<double>& generator() const = 0;
 
  virtual const Matrix<double>& exchangeabilityMatrix() const = 0;
 
  virtual double Sij(size_t i, size_t j) const = 0;
 
  virtual void enableEigenDecomposition(bool yn) = 0;
 
  virtual bool enableEigenDecomposition() = 0;
 
  virtual const Vdouble& getEigenValues() const = 0;
 
  virtual const Vdouble& getIEigenValues() const = 0;
 
  virtual bool isDiagonalizable() const = 0;
 
  virtual bool isNonSingular() const = 0;
 
  virtual const Matrix<double>& getRowLeftEigenVectors() const = 0;
 
  virtual const Matrix<double>& getColumnRightEigenVectors() const = 0;
 
  virtual void setScalable(bool scalable) = 0;
 
  virtual bool isScalable() const = 0;
 
  virtual double getScale() const = 0;
 
  virtual void setScale(double scale) = 0;
 
  virtual void normalize() = 0;
 
  virtual void setDiagonal() = 0;
};
 
 
class ReversibleSubstitutionModelInterface :
  public virtual SubstitutionModelInterface
{
public:
  ReversibleSubstitutionModelInterface() {}
  virtual ~ReversibleSubstitutionModelInterface() {}
 
  ReversibleSubstitutionModelInterface* clone() const override = 0;
};
} // end of namespace bpp.
#endif // BPP_PHYL_MODEL_SUBSTITUTIONMODEL_H