TransitionMatrix.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: The Bio++ Development Group
//
// SPDX-License-Identifier: CECILL-2.1
 
#ifndef BPP_PHYL_LIKELIHOOD_DATAFLOW_TRANSITIONMATRIX_H
#define BPP_PHYL_LIKELIHOOD_DATAFLOW_TRANSITIONMATRIX_H
 
#include <Bpp/Exceptions.h>
#include <Bpp/Numeric/AbstractParametrizable.h>
#include <Bpp/Numeric/Hmm/HmmTransitionMatrix.h>
#include <Bpp/Phyl/Likelihood/DataFlow/DataFlowCWiseComputing.h>
#include <functional>
#include <unordered_map>
 
#include "Definitions.h"
 
namespace bpp
{
class ConfiguredTransitionMatrix : public Value<const HmmTransitionMatrix*>,
  public AbstractParametrizable
{
  // private:
  //   Context& context_;
 
public:
  using Self = ConfiguredTransitionMatrix;
  using Target = HmmTransitionMatrix;
 
  ConfiguredTransitionMatrix (Context& context, NodeRefVec&& deps, std::unique_ptr<HmmTransitionMatrix>&& hmm);
  ~ConfiguredTransitionMatrix ();
 
  ConfiguredTransitionMatrix* clone() const
  {
    throw bpp::Exception("ConfiguredTransitionMatrix clone should not happen.");
  }
 
  std::string description () const final;
  std::string debugInfo () const final;
 
  std::string color () const final
  {
    return "green";
  }
 
  bool compareAdditionalArguments (const Node_DF& other) const;
 
  std::size_t hashAdditionalArguments () const;
 
  NumericalDerivativeConfiguration config;
 
  NodeRef recreate (Context& c, NodeRefVec&& deps) final;
 
  const ConfiguredParameter& getConfiguredParameter(const std::string& name) const
  {
    return static_cast<const ConfiguredParameter&>(parameter(name));
  }
 
private:
  void compute ()
  {
    hmm_->matchParametersValues(getParameters());
  }
 
  std::unique_ptr<HmmTransitionMatrix> hmm_;
};
 
class EquilibriumFrequenciesFromTransitionMatrix : public Value<Eigen::VectorXd>
{
public:
  using Self = EquilibriumFrequenciesFromTransitionMatrix;
  using Dep = ConfiguredTransitionMatrix;
  using T = Eigen::VectorXd;
 
  EquilibriumFrequenciesFromTransitionMatrix (NodeRefVec&& deps, const Dimension<T>& dim);
 
  std::string debugInfo () const final;
 
  bool compareAdditionalArguments (const Node_DF& other) const;
 
  NodeRef derive (Context& c, const Node_DF& node) final;
  NodeRef recreate (Context& c, NodeRefVec&& deps) final;
 
  std::string color () const final
  {
    return "#ffff66";
  }
 
private:
  void compute () final;
 
  Dimension<T> targetDimension_;
};
 
class TransitionMatrixFromTransitionMatrix : public Value<Eigen::MatrixXd>
{
public:
  using Self = TransitionMatrixFromTransitionMatrix;
  using Dep = ConfiguredTransitionMatrix;
  using T = Eigen::MatrixXd;
 
private:
  Dimension<T> targetDimension_;
 
public:
  TransitionMatrixFromTransitionMatrix (NodeRefVec&& deps, const Dimension<T>& dim);
 
  std::string debugInfo () const final;
 
  bool compareAdditionalArguments (const Node_DF& other) const;
 
  NodeRef derive (Context& c, const Node_DF& node) final;
  NodeRef recreate (Context& c, NodeRefVec&& deps) final;
 
  std::string color () const final
  {
    return "#aaff00";
  }
 
  std::string description () const final
  {
    return "TransitionMatrix";
  }
 
  std::string shape() const
  {
    return "octagon";
  }
 
private:
  void compute () final;
};
} // namespace bpp
#endif // BPP_PHYL_LIKELIHOOD_DATAFLOW_TRANSITIONMATRIX_H