WordFrequencySet.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: The Bio++ Development Group
//
// SPDX-License-Identifier: CECILL-2.1
 
#ifndef BPP_PHYL_MODEL_FREQUENCYSET_WORDFREQUENCYSET_H
#define BPP_PHYL_MODEL_FREQUENCYSET_WORDFREQUENCYSET_H
 
#include <Bpp/Seq/Alphabet/CodonAlphabet.h>
#include <Bpp/Seq/Alphabet/WordAlphabet.h>
 
#include "FrequencySet.h"
 
namespace bpp
{
/*********************************************************************/
/****   Frequencies Set in Words *****/
/*********************************************************************/
 
 
class WordFrequencySetInterface :
  public virtual FrequencySetInterface
{
protected:
  virtual size_t getSizeFromVector(const std::vector<std::unique_ptr<FrequencySetInterface>>& freqVector) = 0;
 
public:
  WordFrequencySetInterface* clone() const override = 0;
 
  virtual std::shared_ptr<const CoreWordAlphabet> getWordAlphabet() const = 0;
 
  virtual const FrequencySetInterface& frequencySetForLetter(size_t i) const = 0;
 
  virtual size_t getLength() const = 0;
};
 
 
class AbstractWordFrequencySet :
  public virtual WordFrequencySetInterface,
  public AbstractFrequencySet
{
protected:
  size_t getSizeFromVector(const std::vector<std::unique_ptr<FrequencySetInterface>>& freqVector) override;
 
public:
  AbstractWordFrequencySet(std::shared_ptr<const StateMapInterface> stateMap, const std::string& prefix = "", const std::string& name = "");
 
  AbstractWordFrequencySet* clone() const override = 0;
 
  AbstractWordFrequencySet(const AbstractWordFrequencySet& af) :
    AbstractFrequencySet(af) {}
 
  AbstractWordFrequencySet& operator=(const AbstractWordFrequencySet& af)
  {
    AbstractFrequencySet::operator=(af);
    return *this;
  }
 
  std::shared_ptr<const CoreWordAlphabet> getWordAlphabet() const override
  {
    return std::dynamic_pointer_cast<const CoreWordAlphabet>(getAlphabet());
  }
 
  virtual ~AbstractWordFrequencySet();
 
  size_t getLength() const override;
};
 
 
class WordFromIndependentFrequencySet :
  public AbstractWordFrequencySet
{
protected:
  std::vector<std::unique_ptr<FrequencySetInterface>> vFreq_;
  std::vector<std::string> vNestedPrefix_;
 
public:
  WordFromIndependentFrequencySet(
      std::shared_ptr<const WordAlphabet> pWA,
      std::vector<std::unique_ptr<FrequencySetInterface>>& freqVector,
      const std::string& prefix = "",
      const std::string& name = "WordFromIndependent");
 
  WordFromIndependentFrequencySet(
      std::shared_ptr<const CodonAlphabet> pWA,
      std::vector<std::unique_ptr<FrequencySetInterface>>& freqVector,
      const std::string& prefix = "",
      const std::string& name = "WordFromIndependent");
 
  WordFromIndependentFrequencySet(const WordFromIndependentFrequencySet& iwfs);
 
  virtual ~WordFromIndependentFrequencySet();
 
  WordFromIndependentFrequencySet& operator=(const WordFromIndependentFrequencySet& iwfs);
 
  WordFromIndependentFrequencySet* clone() const override
  {
    return new WordFromIndependentFrequencySet(*this);
  }
 
public:
  void fireParameterChanged(const ParameterList& pl) override;
 
  virtual void updateFrequencies();
 
  virtual void setFrequencies(const std::vector<double>& frequencies) override;
 
  const FrequencySetInterface& frequencySetForLetter(size_t i) const override
  {
    return *vFreq_[i];
  }
 
  virtual size_t getLength() const override;
 
  void setNamespace(const std::string& prefix) override;
 
  std::string getDescription() const;
};
 
class WordFromUniqueFrequencySet :
  public AbstractWordFrequencySet
{
protected:
  std::unique_ptr<FrequencySetInterface> pFreq_;
  std::string NestedPrefix_;
  size_t length_;
 
public:
  WordFromUniqueFrequencySet(
      std::shared_ptr<const WordAlphabet> pWA,
      std::unique_ptr<FrequencySetInterface> pabsfreq,
      const std::string& prefix = "",
      const std::string& name = "WordFromUnique");
 
  WordFromUniqueFrequencySet(
      std::shared_ptr<const CodonAlphabet> pWA,
      std::unique_ptr<FrequencySetInterface> pabsfreq,
      const std::string& prefix = "",
      const std::string& name = "WordFromUnique");
 
  WordFromUniqueFrequencySet(const WordFromUniqueFrequencySet& iwfs);
 
  WordFromUniqueFrequencySet& operator=(const WordFromUniqueFrequencySet& iwfs);
 
  virtual ~WordFromUniqueFrequencySet();
 
  WordFromUniqueFrequencySet* clone() const override
  {
    return new WordFromUniqueFrequencySet(*this);
  }
 
public:
  virtual void fireParameterChanged(const ParameterList& pl) override;
 
  virtual void setFrequencies(const std::vector<double>& frequencies) override;
 
  virtual void updateFrequencies();
 
  const FrequencySetInterface& frequencySetForLetter(size_t i) const override
  {
    return *pFreq_;
  }
 
  size_t getLength() const override { return length_; }
 
  void setNamespace(const std::string& prefix) override;
 
  std::string getDescription() const;
};
} // end of namespace bpp.
#endif // BPP_PHYL_MODEL_FREQUENCYSET_WORDFREQUENCYSET_H