node_t Class Reference

Encodes a genealogical node. More...

#include <node.h>

Inheritance diagram for node_t:

Collaboration diagram for node_t:

Public Member Functions
size_t	bytesize (void) const
	size of binary serialization
void	reuniqify (name_t shift)
	shifts name to avoid overlap
	node_t (name_t u=0, slate_t t=R_NaReal)
	basic constructor for node class
	node_t (const node_t &p)=delete
	copy constructor
	node_t (node_t &&p)=delete
	move constructor
node_t &	operator= (const node_t &p)=delete
	copy assignment operator
node_t &	operator= (node_t &&p)=delete
	move assignment operator
	~node_t (void)
	destructor
ball_t *	green_ball (void) const
	pointer to my green ball
ball_t *&	green_ball (void)
	set green ball
name_t	deme (void) const
	view deme
name_t &	deme (void)
	set deme
name_t	lineage (void) const
	view lineage
name_t	lineage (const ball_t *g) const
	view lineage associated with a green ball
name_t &	lineage (void)
	set lineage
node_t *	parent (void) const
bool	is_root (void) const
bool	dead_root (void) const
int	nchildren (void) const
	number of descendants
void	lineage_incr (int *incr, int *sat, int *etype) const
slate_t	joining_branch_length (const std::unordered_map< name_t, bool > &) const
void	cblv (std::vector< slate_t > &, std::vector< slate_t > &, std::unordered_map< name_t, bool > &, const std::unordered_map< name_t, std::vector< node_t * > > &, slate_t) const
void	insert (ball_t *a)
	insert a ball into the pocket of a node
string_t	yaml (string_t tab="") const
	human/machine-readable info
SEXP	structure (void) const
	R list description.
string_t	newick (const slate_t &tnow, const slate_t &tpar, bool showdeme, bool extended) const
	Newick-format output.
Public Member Functions inherited from pocket_t
size_t	bytesize (void) const
	size of binary serialization
void	repair_owners (const std::unordered_map< name_t, node_t * > &node_name, std::unordered_map< name_t, ball_t * > *ball_name)
	~pocket_t (void)
	destructor
bool	holds (ball_t *b) const
	does this node hold the given ball?
bool	holds (color_t c) const
	does this node hold a ball of this color?
ball_t *	first_ball (void) const
	retrieve the first ball
ball_t *	last_ball (void) const
	retrieve the last ball
ball_t *	ball (const color_t c) const
	retrieve the first ball of the specified color.
string_t	yaml (string_t tab="") const
	human/machine-readable info
SEXP	structure (void) const
	R list description.

Data Fields
name_t	uniq
slate_t	slate

Private Member Functions
void	clean (void)

Private Attributes
ball_t *	_green_ball
name_t	_lineage

Friends
raw_t *	operator>> (const node_t &p, raw_t *o)
	binary serialization of node_t
raw_t *	operator>> (raw_t *o, node_t &p)
	binary deserialization of node_t

Additional Inherited Members
Protected Member Functions inherited from pocket_t
void	repair_holder (node_t *p)

Detailed Description

Encodes a genealogical node.

Each node has:

• a unique name (uniq)
• a pocket containting two or more balls
• a "slate" with the time
• a lineage
• a pointer to its own green ball

Definition at line 23 of file node.h.

Constructor & Destructor Documentation

node_t() [1/3]

node_t::node_t ( name_t u = 0, slate_t t = R_NaReal )

inline

basic constructor for node class

Definition at line 68 of file node.h.

                                              {
    uniq = u;
    slate = t;
    _green_ball = 0;
    _lineage = null_lineage;
  };

Here is the caller graph for this function:

node_t() [2/3]

node_t::node_t ( const node_t & p )

delete

copy constructor

Here is the call graph for this function:

node_t() [3/3]

node_t::node_t ( node_t && p )

delete

move constructor

Here is the call graph for this function:

~node_t()

node_t::~node_t ( void )

inline

destructor

Definition at line 83 of file node.h.

                 {
    clean();
  };

Here is the call graph for this function:

Member Function Documentation

bytesize()

size_t node_t::bytesize ( void ) const

inline

size of binary serialization

Definition at line 40 of file node.h.

                               {
    return 2*sizeof(name_t) + sizeof(slate_t)
      + pocket_t::bytesize();
  };

Here is the call graph for this function:

Here is the caller graph for this function:

cblv()

void node_t::cblv	(	std::vector< slate_t > &	x,
		std::vector< slate_t > &	y,
		std::unordered_map< name_t, bool > &	memo,
		const std::unordered_map< name_t, std::vector< node_t * > > &	children,
		slate_t	t0 ) const

Recursive in-order walk over the subtree rooted at node p.

• at leaf node, push added branch length into x
• at internal node, push height into y

Definition at line 43 of file cblv.cc.

{
  assert(!memo[uniq]);
  const std::vector<node_t*>& ch = children.at(uniq);
  if (ch.empty()) {
    // leaf node: push joining branch length to x
    x.push_back(joining_branch_length(memo));
    memo[uniq] = true;
  } else {
    // first child: recurse
    ch[0]->cblv(x, y, memo, children, t0);
    // subsequent children:
    for (size_t i = 1; i < ch.size(); i++) {
      // push the height of current node into y
      y.push_back(slate - t0);
      memo[uniq] = true;
      ch[i]->cblv(x, y, memo, children, t0);
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

clean()

void node_t::clean ( void )

inlineprivate

Definition at line 30 of file node.h.

{ };

Here is the caller graph for this function:

dead_root()

bool node_t::dead_root ( void ) const

inline

Definition at line 123 of file node.h.

                              {
    return is_root() && size()==1;
  };

Here is the call graph for this function:

Here is the caller graph for this function:

deme() [1/2]

name_t & node_t::deme ( void )

inline

set deme

Definition at line 102 of file node.h.

                      {
    return _green_ball->deme();
  };

deme() [2/2]

name_t node_t::deme ( void ) const

inline

view deme

Definition at line 98 of file node.h.

                           {
    return _green_ball->deme();
  };

Here is the caller graph for this function:

green_ball() [1/2]

ball_t *& node_t::green_ball ( void )

inline

set green ball

Definition at line 94 of file node.h.

                             {
    return _green_ball;
  };

green_ball() [2/2]

ball_t * node_t::green_ball ( void ) const

inline

pointer to my green ball

Definition at line 90 of file node.h.

                                  {
    return _green_ball;
  };

Here is the caller graph for this function:

insert()

void node_t::insert ( ball_t * a )

inline

insert a ball into the pocket of a node

Definition at line 167 of file node.h.

                          {
    a->holder() = this;
    pocket_t::insert(a);
  };

Here is the call graph for this function:

Here is the caller graph for this function:

is_root()

bool node_t::is_root ( void ) const

inline

Definition at line 120 of file node.h.

                            {
    return (_green_ball->holder() == this);
  };

Here is the caller graph for this function:

joining_branch_length()

slate_t node_t::joining_branch_length

(

const std::unordered_map< name_t, bool > &

memo

)

const

distance along the genealogy from given node back to the nearest already-visited ancestor.

Definition at line 35 of file cblv.cc.

{
  const node_t *p = parent();
  while (!p->is_root() && !memo.at(p->uniq)) p = p->parent();
  return slate - p->slate;
}

Here is the call graph for this function:

Here is the caller graph for this function:

lineage() [1/3]

name_t node_t::lineage ( const ball_t * g ) const

inline

view lineage associated with a green ball

Definition at line 110 of file node.h.

                                         {
    return g->owner()->lineage();
  };

Here is the call graph for this function:

lineage() [2/3]

name_t & node_t::lineage ( void )

inline

set lineage

Definition at line 114 of file node.h.

                         {
    return _lineage;
  };

lineage() [3/3]

name_t node_t::lineage ( void ) const

inline

view lineage

Definition at line 106 of file node.h.

                              {
    return _lineage;
  };

Here is the caller graph for this function:

lineage_incr()

void node_t::lineage_incr	(	int *	incr,
		int *	sat,
		int *	etype ) const

lineage count, saturation, and event-type types are:

• 0 = non-event
• -1 = root
• 1 = sample
• 2 = non-sample node

lineage count, saturation, and event-type. types are:

• 0 = non-event
• -1 = root
• 1 = sample
• 2 = non-sample node

Definition at line 13 of file lineages.cc.

{
  const name_t d = deme();
  incr[d]--;
  for (ball_t *b : *this) {
    switch (b->color) {
    case green: case black:
      incr[b->deme()]++;
      sat[b->deme()]++;
      break;
    default:
      break;
    }
  }
  if (is_root()) {
    sat[d]--;
    etype[d] = -1;
  } else if (holds(blue)) {
    etype[d] = 1;
  } else {
    etype[d] = 2;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

nchildren()

int node_t::nchildren ( void ) const

inline

number of descendants

Definition at line 130 of file node.h.

                             {
    int n = 0;
    for (ball_t *b : *this) {
      switch (b->color) {
      case green: case black:
        n++;
        break;
      default:
        break;
      }
    }
    if (is_root()) n--;
    return n;
  };

Here is the call graph for this function:

Here is the caller graph for this function:

newick()

string_t node_t::newick	(	const slate_t &	tnow,
		const slate_t &	tpar,
		bool	showdeme,
		bool	extended ) const

Newick-format output.

Newick format with phylopomp extension Deme and node-type information is returned in a metadata wrapper.

Definition at line 45 of file newick.cc.

{
  string_t o1 = "", o2 = "", o3 = "";
  int n = nchildren();
  if (n > 0) {
    o1 = "("; o3 = ")";
  }
  if (extended) {
    o3 += "[&&PhyloPOMP ";
    if (holds(blue))
      o3 += "type=sample";
    else if (is_root())
      o3 += "type=root";
    else
      o3 += "type=node";
    if (showdeme && deme() != undeme)
      o3 += " deme=" + std::to_string(deme());
    o3 += "]";
  }
  n = 0;
  for (ball_t *b : *this) {
    node_t *p = 0;
    switch (b->color) {
    case green:
      p = b->child();
      if (p != this) {
        if (n++ > 0) o2 += ",";
        o2 += p->newick(tnow,slate,showdeme,extended);
      }
      break;
    case black:
      assert(extended);
      if (n++ > 0) o2 += ",";
      o2 += b->newick(tnow-slate,showdeme);
      break;
    case blue:
      break;
    }
  }
  return o1 + o2 + o3
    + ":" + double2string(slate - tpar);
}

Here is the call graph for this function:

Here is the caller graph for this function:

operator=() [1/2]

node_t & node_t::operator= ( const node_t & p )

delete

copy assignment operator

Here is the call graph for this function:

operator=() [2/2]

node_t & node_t::operator= ( node_t && p )

delete

move assignment operator

Here is the call graph for this function:

parent()

node_t * node_t::parent ( void ) const

inline

Definition at line 117 of file node.h.

                              {
    return _green_ball->holder();
  };

Here is the call graph for this function:

Here is the caller graph for this function:

reuniqify()

void node_t::reuniqify

(

name_t

shift

)

shifts name to avoid overlap

Definition at line 9 of file sum.cc.

{
  this->uniq += shift;
  for (ball_t *b : *this) {
    b->uniq += shift;
  }
}

Here is the caller graph for this function:

structure()

SEXP node_t::structure

(

void

)

const

R list description.

Definition at line 54 of file structure.cc.

{
  SEXP O, On;
  PROTECT(O = NEW_LIST(4));
  PROTECT(On = NEW_CHARACTER(4));
  set_list_elem(O,On,ScalarInteger(int(uniq)),"name",0);
  set_list_elem(O,On,ScalarReal(double(slate)),"time",1);
  set_list_elem(O,On,ScalarInteger(int(deme())),"deme",2);
  set_list_elem(O,On,pocket_t::structure(),"pocket",3);
  SET_NAMES(O,On);
  UNPROTECT(2);
  return O;
}

Here is the call graph for this function:

Here is the caller graph for this function:

yaml()

string_t node_t::yaml

(

string_t

tab = ""

)

const

human/machine-readable info

Definition at line 36 of file yaml.cc.

{
  string_t t = tab + "  ";
  string_t o = "name: " + std::to_string(uniq) + "\n"
    + tab + "time: " + double2string(slate) + "\n"
    + tab + "deme: " + std::to_string(deme()) + "\n";
  if (lineage() != null_lineage) {
    o += tab + "lineage: " + std::to_string(lineage()) + "\n";
  }
  o += tab + "pocket:\n" + pocket_t::yaml(tab);
  return o;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Friends And Related Symbol Documentation

operator>> [1/2]

raw_t * operator>> ( const node_t & p, raw_t * o )

friend

binary serialization of node_t

Definition at line 45 of file node.h.

                                                       {
    name_t buf[2] = {p.uniq, p._lineage};
    memcpy(o,buf,sizeof(buf)); o += sizeof(buf);
    memcpy(o,&p.slate,sizeof(slate_t)); o += sizeof(slate_t);
    return reinterpret_cast<const pocket_t&>(p) >> o;
  };

operator>> [2/2]

raw_t * operator>> ( raw_t * o, node_t & p )

friend

binary deserialization of node_t

Definition at line 52 of file node.h.

                                                 {
    p.clean();
    name_t buf[2];
    memcpy(buf,o,sizeof(buf)); o += sizeof(buf);
    memcpy(&p.slate,o,sizeof(slate_t)); o += sizeof(slate_t);
    p.uniq = buf[0]; p._lineage = buf[1];
    o = (o >> reinterpret_cast<pocket_t&>(p));
    p.repair_holder(&p);
    return o;
  };

Field Documentation

_green_ball

ball_t* node_t::_green_ball

private

Definition at line 27 of file node.h.

_lineage

name_t node_t::_lineage

private

Definition at line 28 of file node.h.

slate

slate_t node_t::slate

Definition at line 35 of file node.h.

uniq

name_t node_t::uniq

Definition at line 34 of file node.h.

---

The documentation for this class was generated from the following files:

• src/node.h
• src/cblv.cc
• src/lineages.cc
• src/newick.cc
• src/structure.cc
• src/sum.cc
• src/yaml.cc