SequenceStatistics.h

Go to the documentation of this file.

//
// File SequenceStatistics.h
// Authors: Eric Bazin
//          Sylvain Gaillard
//          Khalid Belkhir
//          Benoit Nabholz
// Created on: Wed Aug 04 2004
//

/*
   Copyright or © or Copr. Bio++ Development Team, (November 17, 2004)

   This software is a computer program whose purpose is to provide classes
   for population genetics analysis.

   This software is governed by the CeCILL  license under French law and
   abiding by the rules of distribution of free software.  You can  use,
   modify and/ or redistribute the software under the terms of the CeCILL
   license as circulated by CEA, CNRS and INRIA at the following URL
   "http://www.cecill.info".

   As a counterpart to the access to the source code and  rights to copy,
   modify and redistribute granted by the license, users are provided only
   with a limited warranty  and the software's author,  the holder of the
   economic rights,  and the successive licensors  have only  limited
   liability.

   In this respect, the user's attention is drawn to the risks associated
   with loading,  using,  modifying and/or developing or reproducing the
   software by the user in light of its specific status of free software,
   that may mean  that it is complicated to manipulate,  and  that  also
   therefore means  that it is reserved for developers  and  experienced
   professionals having in-depth computer knowledge. Users are therefore
   encouraged to load and test the software's suitability as regards their
   requirements in conditions enabling the security of their systems and/or
   data to be ensured and,  more generally, to use and operate it in the
   same conditions as regards security.

   The fact that you are presently reading this means that you have had
   knowledge of the CeCILL license and that you accept its terms.
 */

// Secured inclusion of header's file
#ifndef _SEQUENCESTATISTICS_H_
#define _SEQUENCESTATISTICS_H_

// From the bpp-seq library
#include <Bpp/Seq/SymbolListTools.h>
#include <Bpp/Seq/Alphabet/CodonAlphabet.h>
#include <Bpp/Seq/GeneticCode/GeneticCode.h>
#include <Bpp/Seq/Container/SiteContainerIterator.h>
#include <Bpp/Seq/Container/SiteContainer.h>
#include <Bpp/Seq/Container/SiteContainerTools.h>

#include "PolymorphismSequenceContainer.h"

// From the STL
#include <string>
#include <map>
#include <vector>

namespace bpp
{
class SequenceStatistics
{
public:
  static unsigned int numberOfPolymorphicSites(
    const PolymorphismSequenceContainer& psc,
    bool gapflag = true,
    bool ignoreUnknown = true);

  static unsigned int numberOfParsimonyInformativeSites(
    const PolymorphismSequenceContainer& psc,
    bool gapflag = true);

  static unsigned int numberOfSingletons(
    const PolymorphismSequenceContainer& psc,
    bool gapflag = true);

  static unsigned int totalNumberOfMutations(
    const PolymorphismSequenceContainer& psc,
    bool gapflag = true);

  static unsigned int totalNumberOfMutationsOnExternalBranches(
    const PolymorphismSequenceContainer& ing,
    const PolymorphismSequenceContainer& outg)
  throw (Exception);

  static unsigned int numberOfTriplets(
    const PolymorphismSequenceContainer& psc,
    bool gapflag = true);

  static double heterozygosity(
    const PolymorphismSequenceContainer& psc,
    bool gapflag = true);

  static double squaredHeterozygosity(
    const PolymorphismSequenceContainer& psc,
    bool gapflag = true);

  static double gcContent(
    const PolymorphismSequenceContainer& psc);

  static std::vector<unsigned int> gcPolymorphism(
    const PolymorphismSequenceContainer& psc,
    bool gapflag = true);

  static double watterson75(
    const PolymorphismSequenceContainer& psc,
    bool gapflag = true,
    bool ignoreUnknown = true);

  static double tajima83(
    const PolymorphismSequenceContainer& psc,
    bool gapflag = true);

  static double fayWu2000(
    const PolymorphismSequenceContainer& psc,
    const Sequence& ancestralSites);

  static unsigned int dvk(
    const PolymorphismSequenceContainer& psc,
    bool gapflag = true);

  static double dvh(
    const PolymorphismSequenceContainer& psc,
    bool gapflag = true);

  static unsigned int numberOfTransitions(
    const PolymorphismSequenceContainer& psc);

  static unsigned int numberOfTransversions(
    const PolymorphismSequenceContainer& psc);

  static double ratioOfTransitionsTransversions(
    const PolymorphismSequenceContainer& psc )
  throw (Exception);

  static unsigned int numberOfSitesWithStopCodon(
    const PolymorphismSequenceContainer& psc,
    const GeneticCode& gCode,
    bool gapflag = true);

  static unsigned int numberOfMonoSitePolymorphicCodons(
    const PolymorphismSequenceContainer& psc,
    bool stopflag = true,
    bool gapflag = true);

  static unsigned int numberOfSynonymousPolymorphicCodons(
    const PolymorphismSequenceContainer& psc,
    const GeneticCode& gc);

  static double watterson75Synonymous(
    const PolymorphismSequenceContainer& psc,
    const GeneticCode& gc);

  static double watterson75NonSynonymous(
    const PolymorphismSequenceContainer& psc,
    const GeneticCode& gc);

  static double piSynonymous(
    const PolymorphismSequenceContainer& psc,
    const GeneticCode& gc,
    bool minchange = false);

  static double piNonSynonymous(
    const PolymorphismSequenceContainer& psc,
    const GeneticCode& gc,
    bool minchange = false);

  static double meanNumberOfSynonymousSites(
    const PolymorphismSequenceContainer& psc,
    const GeneticCode& gc,
    double ratio = 1.);

  static double meanNumberOfNonSynonymousSites(
    const PolymorphismSequenceContainer& psc,
    const GeneticCode& gc,
    double ratio = 1.);

  static unsigned int numberOfSynonymousSubstitutions(
    const PolymorphismSequenceContainer& psc,
    const GeneticCode& gc,
    double freqmin = 0.);

  static unsigned int numberOfNonSynonymousSubstitutions(
    const PolymorphismSequenceContainer& psc,
    const GeneticCode& gc,
    double freqmin = 0.);

  static std::vector<unsigned int> fixedDifferences(
    const PolymorphismSequenceContainer& pscin,
    const PolymorphismSequenceContainer& pscout,
    PolymorphismSequenceContainer& psccons,
    const GeneticCode& gc);

  static std::vector<unsigned int> mkTable(
    const PolymorphismSequenceContainer& ingroup,
    const PolymorphismSequenceContainer& outgroup,
    const GeneticCode& gc,
    double freqmin = 0.);

  static double neutralityIndex(
    const PolymorphismSequenceContainer& ingroup,
    const PolymorphismSequenceContainer& outgroup,
    const GeneticCode& gc,
    double freqmin = 0.);

  static double tajimaDss(
    const PolymorphismSequenceContainer& psc,
    bool gapflag = true)
  throw (ZeroDivisionException);

  static double tajimaDtnm(
    const PolymorphismSequenceContainer& psc,
    bool gapflag = true)
  throw (ZeroDivisionException);

  static double fuLiD(
    const PolymorphismSequenceContainer& ingroup,
    const PolymorphismSequenceContainer& outgroup,
    bool original = true)
  throw (ZeroDivisionException);

  static double fuLiDStar(
    const PolymorphismSequenceContainer& group)
  throw (ZeroDivisionException);

  static double fuLiF(
    const PolymorphismSequenceContainer& ingroup,
    const PolymorphismSequenceContainer& outgroup,
    bool original = true)
  throw (ZeroDivisionException);

  static double fuLiFStar(
    const PolymorphismSequenceContainer& group)
  throw (ZeroDivisionException);

  double fstHudson92(
    const PolymorphismSequenceContainer& psc,
    size_t id1,
    size_t id2);


  static PolymorphismSequenceContainer* generateLdContainer(
    const PolymorphismSequenceContainer& psc,
    bool keepsingleton = true,
    double freqmin = 0.);

  static Vdouble pairwiseDistances1(
    const PolymorphismSequenceContainer& psc,
    bool keepsingleton = true,
    double freqmin = 0.)
  throw (DimensionException);

  static Vdouble pairwiseDistances2(
    const PolymorphismSequenceContainer& psc,
    bool keepsingleton = true,
    double freqmin = 0.)
  throw (DimensionException);

  static Vdouble pairwiseD(
    const PolymorphismSequenceContainer& psc,
    bool keepsingleton = true,
    double freqmin = 0.)
  throw (DimensionException);

  static Vdouble pairwiseDprime(
    const PolymorphismSequenceContainer& psc,
    bool keepsingleton = true,
    double freqmin = 0.)
  throw (DimensionException);

  static Vdouble pairwiseR2(
    const PolymorphismSequenceContainer& psc,
    bool keepsingleton = true,
    double freqmin = 0.)
  throw (DimensionException);

  static double meanD(
    const PolymorphismSequenceContainer& psc,
    bool keepsingleton = true,
    double freqmin = 0.)
  throw (DimensionException);

  static double meanDprime(
    const PolymorphismSequenceContainer& psc,
    bool keepsingleton = true,
    double freqmin = 0.)
  throw (DimensionException);

  static double meanR2(
    const PolymorphismSequenceContainer& psc,
    bool keepsingleton = true,
    double freqmin = 0.)
  throw (DimensionException);

  static double meanDistance1(
    const PolymorphismSequenceContainer& psc,
    bool keepsingleton = true,
    double freqmin = 0.)
  throw (DimensionException);

  static double meanDistance2(
    const PolymorphismSequenceContainer& psc,
    bool keepsingleton = true,
    double freqmin = 0.)
  throw (DimensionException);

  static double originRegressionD(
    const PolymorphismSequenceContainer& psc,
    bool distance1 = false,
    bool keepsingleton = true,
    double freqmin = 0.)
  throw (DimensionException);

  static double originRegressionDprime(
    const PolymorphismSequenceContainer& psc,
    bool distance1 = false,
    bool keepsingleton = true,
    double freqmin = 0.)
  throw (DimensionException);

  static double originRegressionR2(
    const PolymorphismSequenceContainer& psc,
    bool distance1 = false,
    bool keepsingleton = true,
    double freqmin = 0.)
  throw (DimensionException);

  static Vdouble linearRegressionD(
    const PolymorphismSequenceContainer& psc,
    bool distance1 = false,
    bool keepsingleton = true,
    double freqmin = 0.)
  throw (DimensionException);

  static Vdouble linearRegressionDprime(
    const PolymorphismSequenceContainer& psc,
    bool distance1 = false,
    bool keepsingleton = true,
    double freqmin = 0.) throw (DimensionException);

  static Vdouble linearRegressionR2(
    const PolymorphismSequenceContainer& psc,
    bool distance1 = false,
    bool keepsingleton = true,
    double freqmin = 0.)
  throw (DimensionException);

  static double inverseRegressionR2(
    const PolymorphismSequenceContainer& psc,
    bool distance1 = false,
    bool keepsingleton = true,
    double freqmin = 0.)
  throw (DimensionException);

  static double hudson87(
    const PolymorphismSequenceContainer& psc,
    double precision = 0.000001,
    double cinf = 0.001,
    double csup = 10000.);

  static void testUsefulValues(
    std::ostream& s,
    size_t n);

private:
  static unsigned int getNumberOfMutations_(const Site& site);

  static unsigned int getNumberOfSingletons_(const Site& site);

  static unsigned getNumberOfDerivedSingletons_(
    const Site& site_in,
    const Site& site_out);

  static std::map<std::string, double> getUsefulValues_(
    size_t n);

  static double getVD_(
    size_t n,
    double a1,
    double a2,
    double cn);

  static double getUD_(
    double a1,
    double vD);

  static double getVDstar_(
    size_t n,
    double a1,
    double a2,
    double dn);

  static double getUDstar_(
    size_t n,
    double a1,
    double vDs);

  static double leftHandHudson_(
    const PolymorphismSequenceContainer& psc);

  static double rightHandHudson_(
    double c,
    size_t n);

  /************************************************************************/
};
} // end of namespace bpp;

#endif // _SEQUENCESTATISTICS_H_