TreeTools.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: The Bio++ Development Group
//
// SPDX-License-Identifier: CECILL-2.1
 
#ifndef BPP_PHYL_TREE_TREETOOLS_H
#define BPP_PHYL_TREE_TREETOOLS_H
 
#include <Bpp/Exceptions.h>
#include <Bpp/Numeric/VectorTools.h>
 
#include "BipartitionList.h"
#include "Node.h"
#include "Tree.h"
#include "TreeExceptions.h"
 
// From SeqLib:
#include <Bpp/Seq/Container/VectorSiteContainer.h>
#include <Bpp/Seq/DistanceMatrix.h>
 
namespace bpp
{
class TreeTools
{
public:
  TreeTools() {}
  virtual ~TreeTools() {}
 
public:
  static std::vector<int> getLeavesId(const Tree& tree, int nodeId);
 
  static void getLeavesId(const Tree& tree, int nodeId, std::vector<int>& leaves);
 
  static size_t getNumberOfLeaves(const Tree& tree, int nodeId);
 
  static int getLeafId(const Tree& tree, int nodeId, const std::string& name);
 
  static void searchLeaf(const Tree& tree, int nodeId, const std::string& name, int*& id);
 
  static std::vector<int> getPathBetweenAnyTwoNodes(const Tree& tree, int nodeId1, int nodeId2, bool includeAncestor = true);
 
  static std::vector<int> getAncestors(const Tree& tree, int nodeId);
 
  static int getLastCommonAncestor(const Tree& tree, const std::vector<int>& nodeIds);
 
  static size_t getDepth(const Tree& tree, int nodeId);
 
  static size_t getDepths(const Tree& tree, int nodeId, std::map<int, size_t>& depths);
 
  static double getHeight(const Tree& tree, int nodeId);
 
  static double getHeights(const Tree& tree, int nodeId, std::map<int, double>& heights);
 
  static Vdouble getBranchLengths(const Tree& tree, int nodeId);
 
  static double getTotalLength(const Tree& tree, int nodeId, bool includeAncestor = true);
 
  static void setBranchLengths(Tree& tree, int nodeId, double brLen);
 
  static void setVoidBranchLengths(Tree& tree, int nodeId, double brLen);
 
  static void scaleTree(Tree& tree, int nodeId, double factor);
 
  static void initBranchLengthsGrafen(Tree& tree);
 
  static void computeBranchLengthsGrafen(Tree& tree, double power = 1, bool init = true);
 
private:
  static size_t initBranchLengthsGrafen(Tree& tree, int nodeId);
  static void computeBranchLengthsGrafen(Tree& tree, int nodeId, double power, double total, double& height, double& heightRaised);
 
public:
  static double convertToClockTree(Tree& tree, int nodeId, bool noneg = false);
 
  static double convertToClockTree2(Tree& tree, int nodeId);
 
  static double getDistanceBetweenAnyTwoNodes(const Tree& tree, int nodeId1, int nodeId2);
 
  static std::unique_ptr<DistanceMatrix> getDistanceMatrix(const Tree& tree);
 
  static void midpointRooting(Tree& tree);
  static std::string nodeToParenthesis(const Tree& tree, int nodeId, bool writeId = false);
 
  static std::string nodeToParenthesis(const Tree& tree, int nodeId, bool bootstrap, const std::string& propertyName);
 
  static std::string treeToParenthesis(const Tree& tree, bool writeId = false);
 
  static std::string treeToParenthesis(const Tree& tree, bool bootstrap, const std::string& propertyName);
 
  static std::vector<int> getNodesId(const Tree& tree, int nodeId);
 
  static void getNodesId(const Tree& tree, int nodeId, std::vector<int>& nodes);
 
  static int getMaxId(const Tree& tree, int id);
 
  static int getMPNUId(const Tree& tree, int id);
 
  static bool checkIds(const Tree& tree, bool throwException);
 
  static std::unique_ptr<VectorSiteContainer> MRPEncode(const std::vector<std::unique_ptr<Tree>>& vecTr);
 
  static std::unique_ptr<VectorSiteContainer> MRPEncodeMultilabel(const std::vector<std::unique_ptr<Tree>>& vecTr);
 
  static bool haveSameTopology(const Tree& tr1, const Tree& tr2);
 
  static int robinsonFouldsDistance(const Tree& tr1, const Tree& tr2, bool checkNames = true, int* missing_in_tr2 = NULL, int* missing_in_tr1 = NULL);
 
  static std::unique_ptr<BipartitionList> bipartitionOccurrences(const std::vector<std::unique_ptr<Tree>>& vecTr, std::vector<size_t>& bipScore);
 
  static std::unique_ptr<TreeTemplate<Node>> thresholdConsensus(const std::vector<std::unique_ptr<Tree>>& vecTr, double threshold, bool checkNames = true);
 
  static std::unique_ptr<TreeTemplate<Node>> fullyResolvedConsensus(const std::vector<std::unique_ptr<Tree>>& vecTr, bool checkNames = true);
 
  static std::unique_ptr<TreeTemplate<Node>> majorityConsensus(const std::vector<std::unique_ptr<Tree>>& vecTr, bool checkNames = true);
 
  static std::unique_ptr<TreeTemplate<Node>> strictConsensus(const std::vector<std::unique_ptr<Tree>>& vecTr, bool checkNames = true);
 
  static std::unique_ptr<Tree> MRP(const std::vector<std::unique_ptr<Tree>>& vecTr);
 
  static void computeBootstrapValues(Tree& tree, const std::vector<std::unique_ptr<Tree>>& vecTr, bool verbose = true, int format = 0);
 
  static void constrainedMidPointRooting(Tree& tree);
 
  static std::unique_ptr<Tree> MRPMultilabel(const std::vector<Tree*>& vecTr);
 
 
  static const std::string BOOTSTRAP;
 
private:
  struct Moments_
  {
    double N;
    double sum, squaredSum;
    Moments_() : N(0),
      sum(0),
      squaredSum(0) {}
  };
 
  static Moments_ statFromNode_(Tree& tree, int rootId);
  static double bestRootPosition_(Tree& tree, int nodeId1, int nodeId2, double length);
 
 
};
} // end of namespace bpp.
#endif // BPP_PHYL_TREE_TREETOOLS_H