AllelicAlphabet.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: The Bio++ Development Group
//
// SPDX-License-Identifier: CECILL-2.1
 
#ifndef BPP_SEQ_ALPHABET_ALLELICALPHABET_H
#define BPP_SEQ_ALPHABET_ALLELICALPHABET_H
 
#include "AbstractAlphabet.h"
 
// From the STL:
#include <string>
#include <vector>
 
#include "../Transliterator.h"
#include <Bpp/Seq/ProbabilisticSequence.h>
 
namespace bpp
{
class AllelicAlphabet :
  public AbstractAlphabet
{
protected:
  std::shared_ptr<const Alphabet> alph_;
 
  unsigned int nbAlleles_;
 
  int nbUnknown_;
 
public:
  // Constructor and destructor.
  AllelicAlphabet(std::shared_ptr<const Alphabet> alph, unsigned int nbAlleles);
 
  AllelicAlphabet(const AllelicAlphabet& bia) :
    AbstractAlphabet(bia),
    alph_(bia.alph_),
    nbAlleles_(bia.nbAlleles_),
    nbUnknown_(bia.nbUnknown_)
  {}
 
  AllelicAlphabet* clone() const override
  {
    return new AllelicAlphabet(*this);
  }
 
  virtual ~AllelicAlphabet() {}
 
public:
  int charToInt(const std::string& state) const override
  {
    if (state.size() != getStateCodingSize())
      throw BadCharException(state, "AllelicAlphabet::charToInt", this);
    else
      return AbstractAlphabet::charToInt(state);
  }
 
  unsigned int getSize() const override
  {
    return getNumberOfChars() - 2;
  }
 
  unsigned int getNumberOfTypes() const override
  {
    return getNumberOfChars() - 1;
  }
 
  bool isResolvedIn(int state1, int state2) const override;
 
  unsigned int getNbAlleles() const
  {
    return nbAlleles_;
  }
 
  std::shared_ptr<const Alphabet> getStateAlphabet() const
  {
    return alph_;
  }
 
  const Alphabet& stateAlphabet() const
  {
    return *alph_;
  }
 
  std::string getAlphabetType() const override;
 
  int getUnknownCharacterCode() const override
  {
    return nbUnknown_;
  }
 
  bool isUnresolved(int state) const override { return state == getUnknownCharacterCode(); }
 
  bool isUnresolved(const std::string& state) const override { return charToInt(state) == getUnknownCharacterCode(); }
 
  std::vector<int> getAlias(int state) const override;
 
  std::vector<std::string> getAlias(const std::string& state) const override;
 
  int getGeneric(const std::vector<int>& states) const override
  {
    return states[0];
  }
 
  std::string getGeneric(const std::vector<std::string>& states) const override
  {
    return states[0];
  }
 
  class AllelicTransliterator : public AbstractTransliterator
  {
private:
    std::shared_ptr<const AllelicAlphabet> alph_;
 
public:
    AllelicTransliterator(std::shared_ptr<const AllelicAlphabet> alph) :
      AbstractTransliterator(), alph_(alph)
    {}
 
    std::shared_ptr<const Alphabet> getSourceAlphabet() const override
    {
      return alph_->getStateAlphabet();
    }
    std::shared_ptr<const Alphabet> getTargetAlphabet() const override { return alph_; }
 
    std::string translate(const std::string& state) const override
    {
      return getTargetAlphabet()->intToChar(getSourceAlphabet()->charToInt(state));
    }
 
    int translate(int state) const override
    {
      return state;
    }
 
    std::unique_ptr<Sequence> translate(const SequenceInterface& sequence) const override
    {
      return AbstractTransliterator::translate(sequence);
    }
  };
 
  std::unique_ptr<ProbabilisticSequence> convertFromStateAlphabet(const CoreSequenceInterface& sequence) const;
 
  void computeLikelihoods(const Vdouble& counts, Vdouble& likelihoods) const;
 
private:
  // bool containsUnresolved(const std::string& state) const;
  // bool containsGap(const std::string& state) const;
 
  unsigned int getStateCodingSize() const override
  {
    auto x = 2 * ((unsigned int)alph_->getStateCodingSize() + (unsigned int)std::to_string(nbAlleles_).size());
    return x;
  }
 
};
} // end of namespace bpp.
 
#endif // BPP_SEQ_ALPHABET_ALLELICALPHABET_H