StateMap.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: The Bio++ Development Group
//
// SPDX-License-Identifier: CECILL-2.1
 
#ifndef BPP_PHYL_MODEL_STATEMAP_H
#define BPP_PHYL_MODEL_STATEMAP_H
 
#include <Bpp/Clonable.h>
#include <Bpp/Numeric/VectorTools.h>
#include <Bpp/Seq/Alphabet/Alphabet.h>
#include <Bpp/Seq/Alphabet/NucleicAlphabet.h>
 
 
// From the STL:
#include <vector>
#include <string>
 
namespace bpp
{
class StateMapInterface :
  public virtual Clonable
{
public:
  virtual ~StateMapInterface() {}
  virtual StateMapInterface* clone() const override = 0;
 
public:
  virtual const Alphabet& alphabet() const = 0;
 
  virtual std::shared_ptr<const Alphabet> getAlphabet() const = 0;
 
  virtual size_t getNumberOfModelStates() const = 0;
 
  virtual std::string getStateDescription(size_t index) const = 0;
 
  virtual const std::vector<int>& getAlphabetStates() const = 0;
 
  virtual std::string getAlphabetStateAsChar(size_t index) const = 0;
 
  virtual int getAlphabetStateAsInt(size_t index) const = 0;
 
  virtual std::vector<size_t> getModelStates(const std::string& code) const = 0;
 
  virtual std::vector<size_t> getModelStates(int code) const = 0;
 
  virtual bool operator==(const StateMapInterface& sm) const = 0;
 
  virtual bool operator!=(const StateMapInterface& sm) const = 0;
};
 
class AbstractStateMap :
  public virtual StateMapInterface
{
protected:
  std::shared_ptr<const Alphabet> alphabet_;
  std::vector<int> states_;
 
public:
  AbstractStateMap(std::shared_ptr<const Alphabet> alphabet) :
    alphabet_(alphabet),
    states_()
  {}
 
  AbstractStateMap(const AbstractStateMap& absm) :
    alphabet_(absm.alphabet_),
    states_(absm.states_)
  {}
 
  AbstractStateMap& operator=(const AbstractStateMap& absm)
  {
    alphabet_ = absm.alphabet_;
    states_ = absm.states_;
    return *this;
  }
 
public:
  const Alphabet& alphabet() const override { return *alphabet_; }
  std::shared_ptr<const Alphabet> getAlphabet() const override { return alphabet_; }
  size_t getNumberOfModelStates() const override { return states_.size(); }
  const std::vector<int>& getAlphabetStates() const override { return states_; }
  int getAlphabetStateAsInt(size_t index) const override { return states_[index]; }
  std::string getAlphabetStateAsChar(size_t index) const override { return alphabet_->intToChar(states_[index]); }
  std::vector<size_t> getModelStates(int code) const override
  {
    return VectorTools::whichAll(states_, code);
  }
  std::vector<size_t> getModelStates(const std::string& code) const override
  {
    return VectorTools::whichAll(states_, alphabet_->charToInt(code));
  }
 
  bool operator==(const StateMapInterface& sm) const override
  {
    if (alphabet_->getAlphabetType() != sm.alphabet().getAlphabetType()) return false;
    if (states_ != sm.getAlphabetStates()) return false;
    return true;
  }
 
  bool operator!=(const StateMapInterface& sm) const override
  {
    if (alphabet_->getAlphabetType() != sm.alphabet().getAlphabetType()) return true;
    if (states_ != sm.getAlphabetStates()) return true;
    return false;
  }
};
 
class CanonicalStateMap :
  public AbstractStateMap
{
public:
  CanonicalStateMap(std::shared_ptr<const Alphabet> alphabet, bool includeGaps);
 
  CanonicalStateMap(const StateMapInterface& sm, bool includeGaps);
 
  virtual CanonicalStateMap* clone() const { return new CanonicalStateMap(*this); }
 
  virtual std::string getStateDescription(size_t index) const { return getAlphabetStateAsChar(index); }
};
 
 
class MarkovModulatedStateMap :
  public AbstractStateMap
{
private:
  unsigned int nbClasses_;
 
public:
  MarkovModulatedStateMap(const StateMapInterface& unitMap, unsigned int nbClasses);
  virtual MarkovModulatedStateMap* clone() const { return new MarkovModulatedStateMap(*this); }
 
  virtual std::string getStateDescription(size_t index) const { return getAlphabetStateAsChar(index) + TextTools::toString(index % nbClasses_); }
};
} // end of namespace bpp
#endif // BPP_PHYL_MODEL_STATEMAP_H