tree_bones.hpp

#ifndef H_PRUNER
#include <memory>
#include <functional>
#include "typedefs.hpp"
#include "treeiterator_bones.hpp"
#endif

#ifndef H_PRUNER_TREE_BONES
#define H_PRUNER_TREE_BONES 1

#ifndef MAX_TREE_SIZE
#define MAX_TREE_SIZE 50000
#endif

// Arbtrary set of arguments, this is the class that the creator function should
// inherit. Ideally it should have:
// - Model parameters can should be modifiable by a function
// - Additional data such as matrices and what not
// We start by declaring it, the user later on defines it


template <typename Data_Type = bool>
class Tree {
  
protected:
  bool is_dag_(int i = -1, int caller = -1, bool up_search = false);
  void postorder_(uint i);
  void postorder();
  uint get_dist_tip2root_(uint start, uint count);
  TreeIterator<Data_Type> iter;
  

  vv_uint parents;
  vv_uint offspring;
  
  // Auxiliar variables
  v_bool visited;
  v_uint visit_counts;
  
  // Constant
  uint N_NODES;
  uint N_EDGES;
  uint N_TIPS;
  

  v_uint POSTORDER;
  
  v_uint TIPS;
  v_uint DIST_TIPS2ROOT;
  
  friend Data_Type;
  friend class TreeIterator< Data_Type >;
  
public:
  
  Data_Type * args = nullptr;
  

  std::function<void(Data_Type *, TreeIterator<Data_Type>&)> fun;
  
  void eval_fun() {
    
    if (fun)
      fun(this->args, this->iter);
    
    return;
  };
   
  // Creation ------------------------------------------------------------------
  ~Tree() {
    args = nullptr;
    return;
  };
  Tree() {};

  Tree(const v_uint & parents_, const v_uint & offspring_, uint & out);
  
  // Getter --------------------------------------------------------------------
  
  // As pointers
  const vv_uint * get_parents_ptr()   const {return &this->parents;};
  const vv_uint * get_offspring_ptr() const {return &this->offspring;};
  const v_uint * get_postorder_ptr()  const {return &this->POSTORDER;};
  
  // As data
  vv_uint get_parents()   const {return this->parents;};
  vv_uint get_offspring() const {return this->offspring;};
  v_uint get_postorder()  const {return this->POSTORDER;};
  
  v_uint get_preorder()   const;
  
  v_uint get_tips()       const {return this->TIPS;};
  
  v_uint get_dist_tip2root();
  
  uint n_nodes()          const {return this->N_NODES;};
  uint n_edges()          const {return this->N_EDGES;};
  uint n_tips() const;
  
  int n_offspring(uint i) const;
  
  int n_parents(uint i) const;
  
  vv_uint get_edgelist()  const;
  
  void print(bool details = true) const;
  
  // Checker functions ---------------------------------------------------------
  bool is_dag();
  bool is_connected() const {return this->POSTORDER.size() == this->N_NODES;};

  // Setters -------------------------------------------------------------------
  void reset_visited() {
    std::fill(this->visited.begin(), this->visited.end(), false);
    std::fill(this->visit_counts.begin(), this->visit_counts.end(), 0u);
    return ;
  };
  
  uint set_postorder(const v_uint & POSTORDER_, bool check = true);
  
  // Pre-Post/order ------------------------------------------------------------
  

  void prune_postorder();
  

  void prune_postorder(v_uint & seq);
  

  void prune_preorder();

  void prune_preorder(v_uint & seq);

  
};

#endif