DiscreteDistribution.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_DISCRETEDISTRIBUTION_H
#define BPP_PHYL_LIKELIHOOD_DATAFLOW_DISCRETEDISTRIBUTION_H
 
#include <Bpp/Exceptions.h>
#include <Bpp/Numeric/AbstractParametrizable.h>
#include <Bpp/Numeric/Prob/DiscreteDistribution.h>
#include <Bpp/Phyl/Likelihood/DataFlow/DataFlow.h>
#include <Bpp/Phyl/Likelihood/DataFlow/Parametrizable.h>
#include <functional>
#include <unordered_map>
 
#include "Definitions.h"
 
namespace bpp
{
/* Likelihood discrete distribution.
 */
 
class ConfiguredDistribution : public Value<const DiscreteDistributionInterface*>,
  public AbstractParametrizable
{
  // private:
  //   Context& context_;
 
public:
  using Self = ConfiguredDistribution;
  using Target = DiscreteDistributionInterface;
 
  ConfiguredDistribution (Context& context, NodeRefVec&& deps, std::unique_ptr<DiscreteDistributionInterface>&& distrib);
  ~ConfiguredDistribution ();
 
  ConfiguredDistribution* clone() const
  {
    throw bpp::Exception("ConfiguredDistribution clone should not happen.");
  }
 
  std::string description () const final;
  std::string debugInfo () const final;
  std::string color() const final
  {
    return "blue";
  }
 
  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)
  {
    return static_cast<const ConfiguredParameter&>(parameter(name));
  }
 
private:
  void compute ()
  {
    distrib_->matchParametersValues(getParameters());
  }
 
  std::unique_ptr<DiscreteDistributionInterface> distrib_;
};
 
class ProbabilitiesFromDiscreteDistribution : public Value<Eigen::RowVectorXd>
{
public:
  using Self = ProbabilitiesFromDiscreteDistribution;
  using Dep = ConfiguredDistribution;
  using T = Eigen::RowVectorXd;
 
  ProbabilitiesFromDiscreteDistribution (NodeRefVec&& deps, const Dimension<T>& dim);
 
  std::string debugInfo () const final;
 
  std::string color() const final
  {
    return "blue";
  }
 
  bool compareAdditionalArguments (const Node_DF& other) const final;
 
  NodeRef derive (Context& c, const Node_DF& node) final;
  NodeRef recreate (Context& c, NodeRefVec&& deps) final;
 
private:
  void compute () final;
 
  Dimension<T> nbClass_;
 
public:
  static std::shared_ptr<Self> create (Context& c, NodeRefVec&& deps);
};
 
class ProbabilityFromDiscreteDistribution : public Value<double>
{
private:
  uint nCat_;
 
public:
  using Self = ProbabilityFromDiscreteDistribution;
  using Dep = ConfiguredDistribution;
  using T = double;
 
  ProbabilityFromDiscreteDistribution (NodeRefVec&& deps, uint nCat_);
 
  std::string debugInfo () const final;
 
  bool compareAdditionalArguments (const Node_DF& other) const final;
 
  NodeRef derive (Context& c, const Node_DF& node) final;
  NodeRef recreate (Context& c, NodeRefVec&& deps) final;
 
  std::string color() const final
  {
    return "blue";
  }
 
private:
  void compute () final;
 
public:
  static std::shared_ptr<Self> create (Context& c, NodeRefVec&& deps, uint nCat);
};
 
class CategoryFromDiscreteDistribution : public Value<double>
{
private:
  uint nCat_;
 
public:
  using Self = CategoryFromDiscreteDistribution;
  using Dep = ConfiguredDistribution;
  using T = double;
 
  CategoryFromDiscreteDistribution (NodeRefVec&& deps, uint nCat_);
 
  std::string debugInfo () const final;
 
  bool compareAdditionalArguments (const Node_DF& other) const final;
 
  NodeRef derive (Context& c, const Node_DF& node) final;
  NodeRef recreate (Context& c, NodeRefVec&& deps) final;
 
  std::string color() const final
  {
    return "blue";
  }
 
private:
  void compute () final;
 
public:
  static std::shared_ptr<Self> create (Context& c, NodeRefVec&& deps, uint nCat);
};
} // namespace bpp
#endif // BPP_PHYL_LIKELIHOOD_DATAFLOW_DISCRETEDISTRIBUTION_H