SymbolListTools.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: The Bio++ Development Group
//
// SPDX-License-Identifier: CECILL-2.1
 
#ifndef BPP_SEQ_SYMBOLLISTTOOLS_H
#define BPP_SEQ_SYMBOLLISTTOOLS_H
 
#include <Bpp/Numeric/VectorExceptions.h>
 
#include "Alphabet/AlphabetExceptions.h"
#include "IntSymbolList.h"
#include "ProbabilisticSymbolList.h"
 
// From the STL:
#include <map>
 
namespace bpp
{
class SymbolListTools
{
public:
  SymbolListTools() {}
  virtual ~SymbolListTools() {}
 
public:
  static bool hasGap(const IntSymbolListInterface& site);
  static bool hasGap(const ProbabilisticSymbolListInterface& site);
 
  static bool hasGap(const CruxSymbolListInterface& site)
  {
    try
    {
      return hasGap(dynamic_cast<const ProbabilisticSymbolListInterface&>(site));
    }
    catch (std::bad_cast&) {}
    try
    {
      return hasGap(dynamic_cast<const IntSymbolListInterface&>(site));
    }
    catch (std::bad_cast&) {}
    throw Exception("SymbolListTools::hasGap : unsupported CruxSymbolListInterface implementation.");
  }
 
  static bool hasUnresolved(const IntSymbolListInterface& site);
 
  static bool isGapOnly(const IntSymbolListInterface& site);
  static bool isGapOnly(const ProbabilisticSymbolListInterface& site);
 
  static bool isGapOnly(const CruxSymbolListInterface& site)
  {
    try
    {
      return isGapOnly(dynamic_cast<const ProbabilisticSymbolListInterface&>(site));
    }
    catch (std::bad_cast&) {}
    try
    {
      return isGapOnly(dynamic_cast<const IntSymbolListInterface&>(site));
    }
    catch (std::bad_cast&) {}
    throw Exception("SymbolListTools::numberOfGaps : unsupported CruxSymbolListInterface implementation.");
  }
 
  static size_t numberOfGaps(const IntSymbolListInterface& site);
  static size_t numberOfGaps(const ProbabilisticSymbolListInterface& site);
 
  static size_t numberOfGaps(const CruxSymbolListInterface& site)
  {
    try
    {
      return numberOfGaps(dynamic_cast<const ProbabilisticSymbolListInterface&>(site));
    }
    catch (std::bad_cast&) {}
    try
    {
      return numberOfGaps(dynamic_cast<const IntSymbolListInterface&>(site));
    }
    catch (std::bad_cast&) {}
    throw Exception("SymbolListTools::numberOfGaps : unsupported CruxSymbolListInterface implementation.");
  }
 
  static bool isGapOrUnresolvedOnly(const IntSymbolListInterface& site);
  static bool isGapOrUnresolvedOnly(const ProbabilisticSymbolListInterface& site);
 
  static bool isGapOrUnresolvedOnly(const CruxSymbolListInterface& site)
  {
    try
    {
      return isGapOrUnresolvedOnly(dynamic_cast<const ProbabilisticSymbolListInterface&>(site));
    }
    catch (std::bad_cast&) {}
    try
    {
      return isGapOrUnresolvedOnly(dynamic_cast<const IntSymbolListInterface&>(site));
    }
    catch (std::bad_cast&) {}
    throw Exception("SymbolListTools::isGapOrUnresolvedOnly : unsupported CruxSymbolListInterface implementation.");
  }
 
  static size_t numberOfUnresolved(const IntSymbolListInterface& site);
  static size_t numberOfUnresolved(const ProbabilisticSymbolListInterface& site);
 
  static size_t numberOfUnresolved(const CruxSymbolListInterface& site)
  {
    try
    {
      return numberOfUnresolved(dynamic_cast<const ProbabilisticSymbolListInterface&>(site));
    }
    catch (std::bad_cast&) {}
    try
    {
      return numberOfUnresolved(dynamic_cast<const IntSymbolListInterface&>(site));
    }
    catch (std::bad_cast&) {}
    throw Exception("SymbolListTools::numberOfUnresolved : unsupported CruxSymbolListInterface implementation.");
  }
 
  static bool hasUnknown(const IntSymbolListInterface& site);
  static bool hasUnknown(const ProbabilisticSymbolListInterface& site);
 
  static bool hasUnknown(const CruxSymbolListInterface& site)
  {
    try
    {
      return hasUnknown(dynamic_cast<const ProbabilisticSymbolListInterface&>(site));
    }
    catch (std::bad_cast&) {}
    try
    {
      return hasUnknown(dynamic_cast<const IntSymbolListInterface&>(site));
    }
    catch (std::bad_cast&) {}
    throw Exception("SymbolListTools::hasUnknown : unsupported CruxSymbolListInterface implementation.");
  }
 
  static bool isComplete(const IntSymbolListInterface& site);
  static bool isComplete(const ProbabilisticSymbolListInterface& site);
 
  static bool isComplete(const CruxSymbolListInterface& site)
  {
    try
    {
      return isComplete(dynamic_cast<const ProbabilisticSymbolListInterface&>(site));
    }
    catch (std::bad_cast&) {}
    try
    {
      return isComplete(dynamic_cast<const IntSymbolListInterface&>(site));
    }
    catch (std::bad_cast&) {}
    throw Exception("SymbolListTools::isComplete : unsupported CruxSymbolListInterface implementation.");
  }
 
 
  static bool isConstant(
      const IntSymbolListInterface& site,
      bool ignoreUnknown = false,
      bool unresolvedRaisesException = true);
 
  static bool isConstant(
      const ProbabilisticSymbolListInterface& site,
      bool unresolvedRaisesException = true);
 
  static bool isConstant(
      const CruxSymbolListInterface& site,
      bool ignoreUnknown = false,
      bool unresolvedRaisesException = true)
  {
    try
    {
      return isConstant(dynamic_cast<const ProbabilisticSymbolListInterface&>(site), unresolvedRaisesException);
    }
    catch (std::bad_cast&) {}
    try
    {
      return isConstant(dynamic_cast<const IntSymbolListInterface&>(site), ignoreUnknown, unresolvedRaisesException);
    }
    catch (std::bad_cast&) {}
    throw Exception("SymbolListTools::isConstant : unsupported CruxSymbolListInterface implementation.");
  }
 
  static bool areSymbolListsIdentical(
      const IntSymbolListInterface& list1,
      const IntSymbolListInterface& list2);
 
  static bool areSymbolListsIdentical(
      const ProbabilisticSymbolListInterface& list1,
      const ProbabilisticSymbolListInterface& list2);
 
  static bool areSymbolListsIdentical(
      const CruxSymbolListInterface& l1,
      const CruxSymbolListInterface& l2)
  {
    try
    {
      return areSymbolListsIdentical(dynamic_cast<const ProbabilisticSymbolListInterface&>(l1), dynamic_cast<const ProbabilisticSymbolListInterface&>(l2));
    }
    catch (std::bad_cast&) {}
    try
    {
      return areSymbolListsIdentical(dynamic_cast<const IntSymbolListInterface&>(l1), dynamic_cast<const IntSymbolListInterface&>(l2));
    }
    catch (std::bad_cast&) {}
    throw Exception("SymbolListTools::areSymbolListsIdentical : unsupported CruxSymbolListInterface implementation.");
  }
 
 
  template<class count_type>
  static void getCounts(
      const IntSymbolListInterface& list,
      std::map<int, count_type>& counts)
  {
    for (size_t i = 0; i < list.size(); ++i)
    {
      counts[list[i]]++;
    }
  }
 
  static void getCounts(
      const ProbabilisticSymbolListInterface& list,
      std::map<int, double_t>& counts)
  {
    for (size_t i = 0; i < list.size(); ++i)
    {
      const std::vector<double>& c = list[i];
      for (size_t j = 0; j < c.size(); ++j)
      {
        counts[(int)j] += c.at(j);
      }
    }
  }
 
  static void getCountsResolveUnknowns(
      const IntSymbolListInterface& list,
      std::map<int, double>& counts)
  {
    for (size_t i = 0; i < list.size(); ++i)
    {
      std::vector<int> alias = list.getAlphabet()->getAlias(list[i]);
      double n = static_cast<double>(alias.size());
      for (auto j : alias)
      {
        counts[j] += 1. / n;
      }
    }
  }
 
  static void getCountsResolveUnknowns(
      const ProbabilisticSymbolListInterface& list,
      std::map<int, double>& counts)
  {
    for (size_t i = 0; i < list.size(); ++i)
    {
      const std::vector<double>& c = list[i];
      double s = VectorTools::sum(c);
 
      if (s != 0)
        for (size_t j = 0; j < c.size(); j++)
        {
          counts[(int)j] += c.at(j) / s;
        }
    }
  }
 
 
  static void getCounts(
      const CruxSymbolListInterface& list,
      std::map<int, double>& counts,
      bool resolveUnknowns = false)
  {
    try
    {
      if (resolveUnknowns)
      {
        getCountsResolveUnknowns(dynamic_cast<const ProbabilisticSymbolListInterface&>(list), counts);
        return;
      }
      else
      {
        getCounts(dynamic_cast<const ProbabilisticSymbolListInterface&>(list), counts);
        return;
      }
    }
    catch (std::bad_cast&) {}
 
    try
    {
      if (resolveUnknowns)
      {
        getCountsResolveUnknowns(dynamic_cast<const IntSymbolListInterface&>(list), counts);
        return;
      }
      else
      {
        getCounts<double>(dynamic_cast<const IntSymbolListInterface&>(list), counts);
        return;
      }
    }
    catch (std::bad_cast&) {}
 
    throw Exception("SymbolListTools::getCounts : unsupported CruxSymbolListInterface implementation (" + std::string(typeid(list).name()) + ").");
  }
 
 
  template<class count_type>
  static void getCounts(
      const IntSymbolListInterface& list1,
      const IntSymbolListInterface& list2,
      std::map<int, std::map<int, count_type>>& counts)
  {
    if (list1.size() != list2.size()) throw DimensionException("SymbolListTools::getCounts: the two sites must have the same size.", list1.size(), list2.size());
    for (size_t i = 0; i < list1.size(); ++i)
    {
      counts[list1[i]][list2[i]]++;
    }
  }
 
  static void getCounts(
      const ProbabilisticSymbolListInterface& list1,
      const ProbabilisticSymbolListInterface& list2,
      std::map<int, std::map<int, double>>& counts)
  {
    if (list1.size() != list2.size()) throw DimensionException("SymbolListTools::getCounts: the two sites must have the same size.", list1.size(), list2.size());
    for (size_t i = 0; i < list1.size(); ++i)
    {
      const std::vector<double>& c1(list1[i]), &c2(list2[i]);
      for (size_t j = 0; j < c1.size(); ++j)
      {
        for (size_t k = 0; k < c2.size(); ++k)
        {
          counts[(int)j][(int)k] += c1.at(j) * c2.at(k);
        }
      }
    }
  }
 
 
  static void getCountsResolveUnknowns(
      const IntSymbolListInterface& list1,
      const IntSymbolListInterface& list2,
      std::map< int, std::map<int, double>>& counts);
 
  static void getCountsResolveUnknowns(
      const ProbabilisticSymbolListInterface& list1,
      const ProbabilisticSymbolListInterface& list2,
      std::map< int, std::map<int, double>>& counts);
 
  static void getCounts(
      const CruxSymbolListInterface& list1,
      const CruxSymbolListInterface& list2,
      std::map<int, std::map<int, double>>& counts,
      bool resolveUnknowns)
  {
    try
    {
      if (resolveUnknowns)
      {
        getCountsResolveUnknowns(dynamic_cast<const ProbabilisticSymbolListInterface&>(list1), dynamic_cast<const ProbabilisticSymbolListInterface&>(list2), counts);
        return;
      }
      else
      {
        getCounts(dynamic_cast<const ProbabilisticSymbolListInterface&>(list1), dynamic_cast<const ProbabilisticSymbolListInterface&>(list2), counts);
        return;
      }
    }
    catch (std::bad_cast&) {}
 
    try
    {
      if (resolveUnknowns)
      {
        getCountsResolveUnknowns(dynamic_cast<const IntSymbolListInterface&>(list1), dynamic_cast<const IntSymbolListInterface&>(list2), counts);
        return;
      }
      else
      {
        getCounts<double>(dynamic_cast<const IntSymbolListInterface&>(list1), dynamic_cast<const IntSymbolListInterface&>(list2), counts);
        return;
      }
    }
    catch (std::bad_cast&) {}
 
    throw Exception("SymbolListTools::getCounts : unsupported CruxSymbolListInterface implementation (" + std::string(typeid(list1).name()) + ", " + std::string(typeid(list2).name()) + ").");
  }
 
 
  static void getFrequencies(
      const CruxSymbolListInterface& list,
      std::map<int, double>& frequencies,
      bool resolveUnknowns = false);
 
  static void getFrequencies(
      const CruxSymbolListInterface& list1,
      const CruxSymbolListInterface& list2,
      std::map<int, std::map<int, double>>& frequencies,
      bool resolveUnknowns = false);
 
  static double getGCContent(
      const IntSymbolListInterface& list,
      bool ignoreUnresolved = true,
      bool ignoreGap = true);
 
  static double getGCContent(
      const ProbabilisticSymbolListInterface& list,
      bool ignoreUnresolved = true,
      bool ignoreGap = true);
 
  static double getGCContent(
      const CruxSymbolListInterface& list,
      bool ignoreUnresolved = true,
      bool ignoreGap = true)
  {
    try
    {
      return getGCContent(dynamic_cast<const ProbabilisticSymbolListInterface&>(list));
    }
    catch (std::bad_cast&) {}
    try
    {
      return getGCContent(dynamic_cast<const IntSymbolListInterface&>(list));
    }
    catch (std::bad_cast&) {}
    throw Exception("SymbolListTools::getGCContent : unsupported CruxSymbolListInterface implementation.");
  }
 
  static size_t getNumberOfDistinctPositions(
      const IntSymbolListInterface& l1,
      const IntSymbolListInterface& l2);
 
  static size_t getNumberOfDistinctPositions(
      const ProbabilisticSymbolListInterface& l1,
      const ProbabilisticSymbolListInterface& l2);
 
  static size_t getNumberOfDistinctPositions(
      const CruxSymbolListInterface& l1,
      const CruxSymbolListInterface& l2)
  {
    try
    {
      return getNumberOfDistinctPositions(dynamic_cast<const ProbabilisticSymbolListInterface&>(l1), dynamic_cast<const ProbabilisticSymbolListInterface&>(l2));
    }
    catch (std::bad_cast&) {}
    try
    {
      return getNumberOfDistinctPositions(dynamic_cast<const IntSymbolListInterface&>(l1), dynamic_cast<const IntSymbolListInterface&>(l2));
    }
    catch (std::bad_cast&) {}
    throw Exception("SymbolListTools::getNumberOfDistinctPositions : unsupported CruxSymbolListInterface implementation.");
  }
 
  static size_t getNumberOfPositionsWithoutGap(
      const IntSymbolListInterface& l1,
      const IntSymbolListInterface& l2);
 
  static size_t getNumberOfPositionsWithoutGap(
      const ProbabilisticSymbolListInterface& l1,
      const ProbabilisticSymbolListInterface& l2);
 
  static size_t getNumberOfPositionsWithoutGap(
      const CruxSymbolListInterface& l1,
      const CruxSymbolListInterface& l2)
  {
    try
    {
      return getNumberOfPositionsWithoutGap(dynamic_cast<const ProbabilisticSymbolListInterface&>(l1), dynamic_cast<const ProbabilisticSymbolListInterface&>(l2));
    }
    catch (std::bad_cast&) {}
    try
    {
      return getNumberOfPositionsWithoutGap(dynamic_cast<const IntSymbolListInterface&>(l1), dynamic_cast<const IntSymbolListInterface&>(l2));
    }
    catch (std::bad_cast&) {}
    throw Exception("SymbolListTools::getNumberOfPositionsWithoutGap : unsupported CruxSymbolListInterface implementation.");
  }
 
  static void changeGapsToUnknownCharacters(IntSymbolListInterface& l);
 
  static void changeGapsToUnknownCharacters(ProbabilisticSymbolListInterface& l);
 
  static void changeGapsToUnknownCharacters(CruxSymbolListInterface& l)
  {
    try
    {
      changeGapsToUnknownCharacters(dynamic_cast<ProbabilisticSymbolListInterface&>(l));
      return;
    }
    catch (std::bad_cast&) {}
    try
    {
      changeGapsToUnknownCharacters(dynamic_cast<IntSymbolListInterface&>(l));
      return;
    }
    catch (std::bad_cast&) {}
    throw Exception("SymbolListTools::changeGapsToUnknownCharacters : unsupported CruxSymbolListInterface implementation.");
  }
 
  static void changeUnresolvedCharactersToGaps(IntSymbolListInterface& l);
 
  static void changeUnresolvedCharactersToGaps(ProbabilisticSymbolListInterface& l);
 
  static void changeUnresolvedCharactersToGaps(CruxSymbolListInterface& l)
  {
    try
    {
      changeUnresolvedCharactersToGaps(dynamic_cast<ProbabilisticSymbolListInterface&>(l));
      return;
    }
    catch (std::bad_cast&) {}
    try
    {
      changeUnresolvedCharactersToGaps(dynamic_cast<IntSymbolListInterface&>(l));
      return;
    }
    catch (std::bad_cast&) {}
    throw Exception("SymbolListTools::changeUnresolvedCharactersToGaps : unsupported CruxSymbolListInterface implementation.");
  }
 
  static double variabilityShannon(
      const CruxSymbolListInterface& list,
      bool resolveUnknowns);
 
  static double variabilityFactorial(const IntSymbolListInterface& list);
 
  static double mutualInformation(
      const CruxSymbolListInterface& list1,
      const CruxSymbolListInterface& list2,
      bool resolveUnknowns);
 
  static double entropy(const CruxSymbolListInterface& list, bool resolveUnknowns)
  {
    return variabilityShannon(list, resolveUnknowns);
  }
 
  static double jointEntropy(
      const CruxSymbolListInterface& list1,
      const CruxSymbolListInterface& list2,
      bool resolveUnknowns);
 
  static double heterozygosity(const CruxSymbolListInterface& list);
 
  static size_t getNumberOfDistinctCharacters(const IntSymbolListInterface& list);
 
  static size_t getMajorAlleleFrequency(const IntSymbolListInterface& list);
 
  static int getMajorAllele(const CruxSymbolListInterface& list);
 
  static size_t getMinorAlleleFrequency(const IntSymbolListInterface& list);
 
  static int getMinorAllele(const CruxSymbolListInterface& list);
 
  static bool hasSingleton(const IntSymbolListInterface& list);
 
  static bool isParsimonyInformativeSite(const IntSymbolListInterface& site);
 
 
  static bool isTriplet(const IntSymbolListInterface& list);
 
  static bool isDoubleton(const IntSymbolListInterface& list);
};
} // end of namespace bpp.
#endif // BPP_SEQ_SYMBOLLISTTOOLS_H