DistanceMatrix.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: The Bio++ Development Group
//
// SPDX-License-Identifier: CECILL-2.1
 
#ifndef BPP_SEQ_DISTANCEMATRIX_H
#define BPP_SEQ_DISTANCEMATRIX_H
 
#include <Bpp/Exceptions.h>
#include <Bpp/Numeric/Matrix/Matrix.h>
#include <Bpp/Numeric/VectorExceptions.h> // DimensionException
#include <string>
#include <vector>
 
 
namespace bpp
{
class DistanceMatrix final : public virtual Clonable
{
private:
  RowMatrix<double> distances_;
  std::vector<std::string> names_;
 
public:
  DistanceMatrix(const std::vector<std::string>& names)
    : distances_(names.size(), names.size())
    , names_(names)
  {
    reset();
  }
 
  DistanceMatrix(std::size_t n)
    : distances_(n, n)
    , names_(n)
  {
    resize(n);
  }
 
  DistanceMatrix(const DistanceMatrix& dist)
    : distances_(dist.distances_)
    , names_(dist.names_)
  {}
 
  DistanceMatrix& operator=(const DistanceMatrix& dist)
  {
    std::size_t n = dist.size();
    resize(n);
    for (std::size_t i = 0; i < n; ++i)
    {
      for (std::size_t j = 0; j < n; ++j)
      {
        distances_(i, j) = dist(i, j);
      }
    }
    names_ = dist.names_;
    return *this;
  }
 
  DistanceMatrix* clone() const { return new DistanceMatrix(*this); }
 
public:
  void reset()
  {
    std::size_t n = size();
    for (std::size_t i = 0; i < n; ++i)
    {
      for (std::size_t j = 0; j < n; ++j)
      {
        distances_(i, j) = 0;
      }
    }
  }
 
  std::size_t size() const { return names_.size(); }
 
  const std::vector<std::string>& getNames() const { return names_; }
 
  const std::string& getName(std::size_t i) const
  {
    if (i >= size())
      throw IndexOutOfBoundsException("DistanceMatrix::getName. Invalid indice.", i, 0, size());
    return names_[i];
  }
 
  void setName(std::size_t i, const std::string& name)
  {
    if (i >= size())
      throw IndexOutOfBoundsException("DistanceMatrix::setName. Invalid indice.", i, 0, size());
    names_[i] = name;
  }
 
  void setNames(const std::vector<std::string>& names)
  {
    if (names.size() != names_.size())
      throw DimensionException("DistanceMatrix::setNames. Invalid number of names.", names.size(), names_.size());
    names_ = names;
  }
 
  std::size_t getNameIndex(const std::string& name) const;
 
  void resize(std::size_t n)
  {
    // RowMatrix<double>::resize(n, n);
    distances_.resize(n, n);
    names_.resize(n);
    for (std::size_t i = 0; i < n; ++i)
    {
      names_[i] = "Taxon " + std::to_string(i);
    }
    reset();
  }
 
  virtual const double& operator()(const std::string& iName, const std::string& jName) const
  {
    std::size_t i = getNameIndex(iName);
    std::size_t j = getNameIndex(jName);
    // return operator()(i,j);
    return distances_(i, j);
  }
 
  virtual double& operator()(const std::string& iName, const std::string& jName)
  {
    std::size_t i = getNameIndex(iName);
    std::size_t j = getNameIndex(jName);
    // return operator()(i,j);
    return distances_(i, j);
  }
 
  virtual const double& operator()(std::size_t i, std::size_t j) const
  {
    // return RowMatrix<double>::operator()(i, j);
    return distances_(i, j);
  }
  virtual double& operator()(std::size_t i, std::size_t j)
  {
    // return RowMatrix<double>::operator()(i, j);
    return distances_(i, j);
  }
 
  virtual const Matrix<double>& asMatrix() const { return distances_; }
 
  virtual Matrix<double>& asMatrix() { return distances_; }
};
} // end of namespace bpp.
#endif // BPP_SEQ_DISTANCEMATRIX_H