DataFlow.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_DATAFLOW_H
#define BPP_PHYL_LIKELIHOOD_DATAFLOW_DATAFLOW_H
 
#include <Bpp/Exceptions.h>
#include <cassert>
#include <cstddef>
#include <iostream>
#include <memory>
#include <sstream>
#include <string>
#include <typeinfo>
#include <unordered_map> // For recreateWithSubstitution
#include <unordered_set>
#include <utility>
#include <vector>
 
 
namespace bpp
{
std::string prettyTypeName (const std::type_info& type_info);
 
template<typename T> void combineHash (std::size_t& seed, const T& t)
{
  std::hash<T> hasher;
  seed ^= hasher (t) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
}
 
class Node_DF;
template<typename T> class Value;
class Context;
 
 
enum class DotOptions
{
  None = 0,
  DetailedNodeInfo = 1 << 0,
  FollowUpwardLinks = 1 << 1,
  ShowDependencyIndex = 1 << 2
};
 
DotOptions operator|(DotOptions a, DotOptions b);
bool operator&(DotOptions a, DotOptions b);
 
void writeGraphToDot (std::ostream& os, const std::vector<const Node_DF*>& nodes, DotOptions opt = DotOptions::None);
 
void writeGraphToDot (const std::string& filename, const std::vector<const Node_DF*>& nodes,
    DotOptions opt  = DotOptions::None);
 
template<typename T>
std::string to_string_with_precision(const T a_value, const int n = 6)
{
  std::ostringstream out;
  out.precision(n);
  out << std::fixed << a_value;
  return out.str();
}
 
 
using NodeRef = std::shared_ptr<Node_DF>;
 
using NodeRefVec = std::vector<NodeRef>;
 
template<typename T> using ValueRef = std::shared_ptr<Value<T>>;
 
enum class NumericalProperty
{
  Constant,         // Is a constant value
  ConstantZero,     // Is a zero value for its type
  ConstantOne,      // Is a one value for its type
  ConstantIdentity, // Is identity (for matrices mostly ; double(1.) is considered identity)
};
 
[[noreturn]] void failureComputeWasCalled (const std::type_info& nodeType);
[[noreturn]] void failureNodeConversion (const std::type_info& handleType, const Node_DF& node);
[[noreturn]] void failureDependencyNumberMismatch (const std::type_info& contextNodeType,
    std::size_t expectedSize, std::size_t givenSize);
[[noreturn]] void failureEmptyDependency (const std::type_info& contextNodeType, std::size_t depIndex);
[[noreturn]] void failureDependencyTypeMismatch (const std::type_info& contextNodeType,
    std::size_t depIndex,
    const std::type_info& expectedType,
    const std::type_info& givenNodeType);
 
class Node_DF : public std::enable_shared_from_this<Node_DF>
{
public:
  Node_DF () = default;
  Node_DF (const Node_DF&) = delete;
  Node_DF (Node_DF&&) = delete;
  Node_DF& operator=(const Node_DF&) = delete;
  Node_DF& operator=(Node_DF&&) = delete;
  virtual ~Node_DF (); // Deregisters from dependencies
 
  // Sets dependencies + register
  Node_DF (const NodeRefVec& dependenciesArg);
  Node_DF (NodeRefVec&& dependenciesArg);
 
  // Accessors
  bool isValid () const noexcept { return isValid_; }
 
  std::size_t nbDependentNodes () const noexcept { return dependentNodes_.size (); }
 
 
  const std::vector<Node_DF*>& dependentNodes () const noexcept { return dependentNodes_; }
 
  std::size_t nbDependencies () const noexcept { return dependencyNodes_.size (); }
 
  const NodeRefVec& dependencies () const noexcept { return dependencyNodes_; }
 
  const NodeRef& dependency (std::size_t i) const noexcept { return dependencyNodes_[i]; }
 
  virtual std::string description () const;
 
  virtual std::string color () const
  {
    return "white";
  }
 
  virtual std::string shape () const
  {
    return "box";
  }
 
  virtual std::string debugInfo () const;
 
  virtual bool hasNumericalProperty (NumericalProperty prop) const;
 
  virtual bool compareAdditionalArguments (const Node_DF& other) const;
  virtual std::size_t hashAdditionalArguments () const;
 
  virtual NodeRef derive (Context& c, const Node_DF& node);
 
  virtual NodeRef recreate (Context& c, NodeRefVec&& deps);
 
  void computeRecursively ();
 
protected:
  virtual void compute () = 0;
 
 
  void invalidateRecursively () noexcept;
 
  void makeInvalid () noexcept { isValid_ = false; }
  void makeValid () noexcept { isValid_ = true; }
 
protected:
  // void setDependencies_(NodeRefVec && dependenciesArg)
  // {
  //   if (dependencyNodes_.size()!=0)
  //     throw bpp::Exception("Node::setDependencies_ possible only for Nodes without dependencies.");
 
  //   dependencyNodes_=std::move(dependenciesArg);
 
  //   for (auto & n : dependencyNodes_)
  //       n->registerNode (this);
 
  //   invalidateRecursively ();
  //   makeInvalid ();
  // }
 
  void resetDependencies_(NodeRefVec&& dependenciesArg)
  {
    for (auto& n : dependencyNodes_)
    {
      if (n)
        n->unregisterNode (this);
    }
 
    dependencyNodes_ = dependenciesArg;
 
    for (auto& n : dependencyNodes_)
    {
      if (n)
        n->registerNode (this);
    }
 
    invalidateRecursively ();
    makeInvalid ();
  }
 
private:
  void registerNode (Node_DF* n);
  void unregisterNode (const Node_DF* n);
 
  NodeRefVec dependencyNodes_{};         // Nodes that we depend on.
  std::vector<Node_DF*> dependentNodes_{}; // Nodes that depend on us.
  bool isValid_{false};
 
  friend class Context;
};
 
template<typename T, typename U> std::shared_ptr<T> convertRef (const std::shared_ptr<U>& from)
{
  auto p = std::dynamic_pointer_cast<T>(from);
  if (!p)
    failureNodeConversion (typeid (T), *from);
  return p;
}
 
bool isTransitivelyDependentOn (const Node_DF& searchedDependency, const Node_DF& node);
 
NodeRef recreateWithSubstitution (Context& c, const NodeRef& node,
    const std::unordered_map<const Node_DF*, NodeRef>& substitutions);
 
 
template<typename T> class Value : public Node_DF
{
public:
  // Init deps
  template<typename ... Args>
  Value(const NodeRefVec& deps, Args&&... args) :
    Node_DF(deps),
    value_(std::forward<Args>(args)...)
  {}
 
  template<typename ... Args>
  Value(NodeRefVec&& deps, Args&&... args) :
    Node_DF(std::move(deps)),
    value_(std::forward<Args>(args)...)
  {}
 
  const T& targetValue()
  {
    this->computeRecursively();
    return accessValueConst();
  }
 
  const T& accessValueConst() const noexcept { return value_; }
 
  ValueRef<T> deriveAsValue(Context& c, const Node_DF& node)
  {
    return convertRef<Value<T>>(this->derive(c, node));
  }
 
  template<typename Callable> void modify(Callable&& modifier, bool makeValid)
  {
    this->invalidateRecursively ();
    std::forward<Callable>(modifier) (this->accessValueMutable ());
    if (makeValid)
      this->makeValid();
  }
 
protected:
  T& accessValueMutable() noexcept { return value_; }
 
private:
  T value_;
};
 
template<typename T> const T& accessValueConstCast(const Node_DF& node)
{
  // assert (dynamic_cast<const Value<T> *> (&node) != nullptr);      // Check type in debug mode
  return static_cast<const Value<T>&>(node).accessValueConst (); // Fast cast access
}
 
void checkDependencyVectorSize (const std::type_info& contextNodeType, const NodeRefVec& deps,
    std::size_t expectedSize);
 
void checkDependencyVectorMinSize (const std::type_info& contextNodeType, const NodeRefVec& deps,
    std::size_t expectedMinSize);
 
void checkDependenciesNotNull (const std::type_info& contextNodeType, const NodeRefVec& deps);
 
void checkNthDependencyNotNull (const std::type_info& contextNodeType, const NodeRefVec& deps, std::size_t index);
 
template<typename T>
void checkNthDependencyIs (const std::type_info& contextNodeType, const NodeRefVec& deps,
    std::size_t index)
{
  const auto& dep = *deps[index];
  if (dynamic_cast<const T*>(&dep) == nullptr)
    failureDependencyTypeMismatch (contextNodeType, index, typeid (T), typeid (dep));
}
 
template<typename T1, typename T2>
void checkNthDependencyIs (const std::type_info& contextNodeType, const NodeRefVec& deps,
    std::size_t index)
{
  const auto& dep = *deps[index];
  if (dynamic_cast<const T1*>(&dep) == nullptr &&
      (dynamic_cast<const T2*>(&dep) == nullptr))
 
    throw Exception (prettyTypeName (contextNodeType) + ": expected class derived from " +
          prettyTypeName (typeid(T1))
          + " or " + prettyTypeName (typeid(T2))
          + " as " + std::to_string (index)
          + "-th dependency, got " + prettyTypeName (typeid (dep)));
}
 
template<typename T>
void checkDependencyRangeIs (const std::type_info& contextNodeType, const NodeRefVec& deps,
    std::size_t start, std::size_t end)
{
  for (std::size_t i = start; i < end; ++i)
  {
    checkNthDependencyIs<T>(contextNodeType, deps, i);
  }
}
 
template<typename T>
void checkNthDependencyIsValue (const std::type_info& contextNodeType, const NodeRefVec& deps,
    std::size_t index)
{
  checkNthDependencyIs<Value<T>>(contextNodeType, deps, index);
}
 
template<typename T>
void checkDependencyRangeIsValue (const std::type_info& contextNodeType, const NodeRefVec& deps,
    std::size_t start, std::size_t end)
{
  for (std::size_t i = start; i < end; ++i)
  {
    checkNthDependencyIsValue<T>(contextNodeType, deps, i);
  }
}
 
class Context
{
public:
  Context ();
 
  NodeRef cached(NodeRef&& newNode);
 
  NodeRef cached(NodeRef& newNode);
 
  size_t size() const
  {
    return nodeCache_.size();
  }
 
  void clear();
 
  bool erase(const NodeRef& r);
 
  /*
   * @brief Get a size_t 0 NodeRef
   *
   */
  NodeRef getZero()
  {
    return zero_;
  }
 
  std::vector<const Node_DF*> getAllNodes() const;
 
private:
  struct CachedNodeRef
  {
    NodeRef ref;
 
    CachedNodeRef(NodeRef && r) : ref(std::move(r)) {}
 
    CachedNodeRef(NodeRef & r) : ref(r) {}
 
    bool operator==(const CachedNodeRef& other) const;
  };
 
  struct CachedNodeRefHash
  {
    std::size_t operator()(const CachedNodeRef& ref) const;
  };
 
  std::unordered_set<CachedNodeRef, CachedNodeRefHash> nodeCache_;
 
  NodeRef zero_;
};
 
template<typename T> std::shared_ptr<T> cachedAs (Context& c, std::shared_ptr<T>&& newNode)
{
  // We can use the faster static_cast due to Context::cached(): node types are conserved.
  return std::static_pointer_cast<T>(c.cached (std::move(newNode)));
}
 
template<typename T> std::shared_ptr<T> cachedAs (Context& c, std::shared_ptr<T>& newNode)
{
  // We can use the faster static_cast due to Context::cached(): node types are conserved.
  return std::static_pointer_cast<T>(c.cached(newNode));
}
} // namespace bpp
#endif // BPP_PHYL_LIKELIHOOD_DATAFLOW_DATAFLOW_H