AbstractAgglomerativeDistanceMethod.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: The Bio++ Development Group
//
// SPDX-License-Identifier: CECILL-2.1
 
#ifndef BPP_PHYL_DISTANCE_ABSTRACTAGGLOMERATIVEDISTANCEMETHOD_H
#define BPP_PHYL_DISTANCE_ABSTRACTAGGLOMERATIVEDISTANCEMETHOD_H
 
 
#include "../Tree/Node.h"
#include "../Tree/TreeTemplate.h"
#include "DistanceMethod.h"
 
// From the STL:
#include <map>
 
namespace bpp
{
class AbstractAgglomerativeDistanceMethod :
  public virtual AgglomerativeDistanceMethodInterface
{
protected:
  DistanceMatrix matrix_;
  std::unique_ptr<Tree> tree_;
 
  std::map<size_t, Node*> currentNodes_;
  bool verbose_;
  bool rootTree_;
 
public:
  AbstractAgglomerativeDistanceMethod(
      bool verbose = true,
      bool rootTree = false) :
    matrix_(0),
    tree_(nullptr),
    currentNodes_(),
    verbose_(verbose),
    rootTree_(rootTree) {}
 
  AbstractAgglomerativeDistanceMethod(
      const DistanceMatrix& matrix,
      bool verbose = true,
      bool rootTree = false) :
    matrix_(0),
    tree_(nullptr),
    currentNodes_(),
    verbose_(verbose),
    rootTree_(rootTree)
  {
    setDistanceMatrix(matrix);
  }
 
  virtual ~AbstractAgglomerativeDistanceMethod() {}
 
  AbstractAgglomerativeDistanceMethod(const AbstractAgglomerativeDistanceMethod& a) :
    matrix_(a.matrix_), tree_(nullptr), currentNodes_(), verbose_(a.verbose_), rootTree_(a.rootTree_)
  {
    // Hard copy of inner tree:
    if (a.tree_)
      tree_.reset(new TreeTemplate<Node>(*a.tree_));
  }
 
  AbstractAgglomerativeDistanceMethod& operator=(const AbstractAgglomerativeDistanceMethod& a)
  {
    matrix_ = a.matrix_;
    // Hard copy of inner tree:
    if (a.tree_)
      tree_.reset(new TreeTemplate<Node>(*a.tree_));
    else tree_ = 0;
    currentNodes_.clear();
    verbose_ = a.verbose_;
    rootTree_ = a.rootTree_;
    return *this;
  }
 
public:
  virtual void setDistanceMatrix(const DistanceMatrix& matrix) override;
 
  bool hasTree() const override
  {
    return tree_ != nullptr;
  }
 
  const Tree& tree() const override
  {
    if (tree_)
      return *tree_;
 
    throw NullPointerException("AbstractAgglomerativeDistanceMethod::tree(). No tree was computed.");
  }
 
  void computeTree() override;
 
  void setVerbose(bool yn) override { verbose_ = yn; }
  bool isVerbose() const override { return verbose_; }
 
protected:
  virtual std::vector<size_t> getBestPair() = 0;
 
  virtual std::vector<double> computeBranchLengthsForPair(const std::vector<size_t>& pair) = 0;
 
  virtual double computeDistancesFromPair(const std::vector<size_t>& pair, const std::vector<double>& branchLengths, size_t pos) = 0;
 
  virtual void finalStep(int idRoot) = 0;
 
  virtual Node* getLeafNode(int id, const std::string& name);
 
  virtual Node* getParentNode(int id, Node* son1, Node* son2);
};
} // end of namespace bpp.
#endif // BPP_PHYL_DISTANCE_ABSTRACTAGGLOMERATIVEDISTANCEMETHOD_H