nodeseq_t Class Reference

A sequence of nodes. More...

#include <nodeseq.h>

Inheritance diagram for nodeseq_t:

Collaboration diagram for nodeseq_t:

Public Member Functions
	~nodeseq_t (void)
	destructor
size_t	bytesize (void) const
	size of serialized binary form
nodeseq_t &	operator+= (nodeseq_t &other)
	merge two node sequences
void	sort (void)
	order nodes in order of increasing time
pocket_t *	colored (color_t col) const
	Get all balls of a color.
size_t	ntime (slate_t t) const
	Number of distinct timepoints.
size_t	length (void) const
	Number of nodes in the sequence.
node_t *	position (int n)
	traverse to nth node, retrieve pointer
void	swap (ball_t *a, ball_t *b)
	swap balls a and b, wherever they lie
void	add (node_t *p, ball_t *a)
void	drop (ball_t *a)
void	destroy_node (node_t *p)
	remove a dead root node
void	comb (void)
void	trace_lineages (void)
std::string	describe (void) const
	human-readable info
virtual std::string	yaml (std::string tab="") const
	human- & machine-readable info
SEXP	structure (void) const
	R list description.
std::string	newick (slate_t t) const
	put genealogy at time t into Newick format.

Private Member Functions
void	clean (void)
	clean up: delete all nodes, reset globals
void	repair_owners (std::unordered_map< name_t, ball_t * > &names)
slate_t	dawn (void) const
	Earliest time in the sequence.
slate_t	dusk (void) const
	Latest time in the sequence.
void	trace_lineage (ball_t *b, name_t u)

Static Private Member Functions
static bool	compare (node_t *p, node_t *q)

Friends
raw_t *	operator>> (const nodeseq_t &G, raw_t *o)
	binary serialization
raw_t *	operator>> (raw_t *o, nodeseq_t &G)
	binary deserialization

Detailed Description

A sequence of nodes.

Definition at line 19 of file nodeseq.h.

Constructor & Destructor Documentation

~nodeseq_t()

nodeseq_t::~nodeseq_t ( void )

inline

destructor

Definition at line 32 of file nodeseq.h.

                    {
    clean();
  };

Here is the call graph for this function:

Member Function Documentation

add()

void nodeseq_t::add ( node_t * p, ball_t * a )

inline

add node p; take as parent the node holding ball a. the deme of p is changed to match that of a

Definition at line 176 of file nodeseq.h.

                                  {
    swap(a,p->green_ball());
    p->deme() = a->deme();
    push_back(p);
  };

Here is the call graph for this function:

Here is the caller graph for this function:

bytesize()

size_t nodeseq_t::bytesize ( void ) const

inline

size of serialized binary form

Definition at line 40 of file nodeseq.h.

                               {
    size_t s = sizeof(size_t);
    for (node_t *p : *this)
      s += p->bytesize();
    return s;
  };

Here is the call graph for this function:

Here is the caller graph for this function:

clean()

void nodeseq_t::clean ( void )

inlineprivate

clean up: delete all nodes, reset globals

Definition at line 24 of file nodeseq.h.

                    {
    for (node_t *p : *this) delete p;
    clear();
  };

Here is the caller graph for this function:

colored()

pocket_t * nodeseq_t::colored ( color_t col ) const

inline

Get all balls of a color.

Definition at line 128 of file nodeseq.h.

                                        {
    pocket_t *p = new pocket_t;
    for (node_t *q : *this) {
      for (ball_t *b : *q ) {
        if (b->is(col)) p->insert(b);
      }
    }
    return p;
  };

Here is the caller graph for this function:

comb()

void nodeseq_t::comb ( void )

inline

pass through the sequence, dropping superfluous nodes i.e., those holding just one ball that is green.

Definition at line 207 of file nodeseq.h.

                   {
    for (node_rev_it i = crbegin(); i != crend(); i++) {
      if ((*i)->size() == 1 && (*i)->holds(green)) {
        swap((*i)->last_ball(),(*i)->green_ball());
      }
    }
    node_nit j = begin();
    while (j != end()) {
      if ((*j)->dead_root()) {
        destroy_node(*(j++));
      } else {
        j++;
      }
    }
  };

Here is the call graph for this function:

Here is the caller graph for this function:

compare()

static bool nodeseq_t::compare ( node_t * p, node_t * q )

inlinestaticprivate

Order relation among nodes. Nodes should be ordered by time, then by unique name.

Definition at line 96 of file nodeseq.h.

                                             {
    return (p->slate < q->slate) ||
      ((p->slate == q->slate) && (p->uniq < q->uniq));
  };

Here is the caller graph for this function:

dawn()

slate_t nodeseq_t::dawn ( void ) const

inlineprivate

Earliest time in the sequence.

Definition at line 117 of file nodeseq.h.

                            {
    return (empty()) ? R_NaReal : front()->slate;
  };

Here is the caller graph for this function:

describe()

std::string nodeseq_t::describe ( void ) const

inline

human-readable info

Definition at line 259 of file nodeseq.h.

                                  {
    std::string o = "";
    for (node_t *p : *this) {
      o += p->describe();
    }
    return o;
  };

Here is the call graph for this function:

Here is the caller graph for this function:

destroy_node()

void nodeseq_t::destroy_node ( node_t * p )

inline

remove a dead root node

Definition at line 200 of file nodeseq.h.

                                {
    assert(p->dead_root());
    remove(p);
    delete p;
  };

Here is the call graph for this function:

Here is the caller graph for this function:

drop()

void nodeseq_t::drop ( ball_t * a )

inline

drop the black ball 'a' and the node if either (1) the node becomes thereby a dead root, or (2) the node's pocket becomes thereby empty.

Definition at line 184 of file nodeseq.h.

                        {
    assert(a->is(black));
    node_t *p = a->holder();
    if (p->size() > 1) {
      p->erase(a);
      delete a;
      if (p->dead_root()) {     // remove isolated root
        destroy_node(p);
      }
    } else {
      swap(a,p->green_ball());
      destroy_node(p);
      drop(a);                  // recurse
    }
  };

Here is the call graph for this function:

Here is the caller graph for this function:

dusk()

slate_t nodeseq_t::dusk ( void ) const

inlineprivate

Latest time in the sequence.

Definition at line 121 of file nodeseq.h.

                            {
    return (empty()) ? R_NaReal : back()->slate;
  }

length()

size_t nodeseq_t::length ( void ) const

inline

Number of nodes in the sequence.

Definition at line 149 of file nodeseq.h.

                             {
    return this->size();
  };

Here is the caller graph for this function:

newick()

std::string nodeseq_t::newick ( slate_t t ) const

inline

put genealogy at time t into Newick format.

Definition at line 287 of file nodeseq.h.

                                     {
    slate_t te = dawn();
    std::string o = "";
    for (node_t *p : *this) {
      if (p->is_root()) {
        o += p->newick(t,te) + ";";
      }
    }
    return o;
  };

Here is the call graph for this function:

Here is the caller graph for this function:

ntime()

size_t nodeseq_t::ntime ( slate_t t ) const

inline

Number of distinct timepoints.

Definition at line 138 of file nodeseq.h.

                                 {
    size_t count = 1;
    for (node_t *p : *this) {
      if (t < p->slate) {
        t = p->slate;
        count++;
      }
    }
    return count;
  };

Here is the caller graph for this function:

operator+=()

nodeseq_t & nodeseq_t::operator+= ( nodeseq_t & other )

inline

merge two node sequences

Definition at line 104 of file nodeseq.h.

                                           {
    merge(other,compare);
    return *this;
  };

Here is the call graph for this function:

position()

node_t * nodeseq_t::position ( int n )

inline

traverse to nth node, retrieve pointer

Definition at line 153 of file nodeseq.h.

                           {
    int i = 0;
    node_it k = cbegin();
    while (i < n && k != cend()) {
      i++; k++;
    }
    assert(k != cend());
    return *k;
  };

repair_owners()

void nodeseq_t::repair_owners ( std::unordered_map< name_t, ball_t * > & names )

inlineprivate

Needed in deserialization. This function repairs the links green balls and their names.

Definition at line 82 of file nodeseq.h.

                                                               {
    std::unordered_map<name_t,ball_t*>::const_iterator n;
    for (node_t *p : *this) {
      n = names.find(p->uniq);
      assert(n != names.end());
      ball_t *b = n->second;
      p->green_ball() = b;
    }
  };

Here is the call graph for this function:

Here is the caller graph for this function:

sort()

void nodeseq_t::sort ( void )

inline

order nodes in order of increasing time

Definition at line 110 of file nodeseq.h.

                   {
    std::list<node_t*>::sort(compare);
  };

Here is the call graph for this function:

Here is the caller graph for this function:

structure()

SEXP nodeseq_t::structure ( void ) const

inline

R list description.

Definition at line 276 of file nodeseq.h.

                              {
    SEXP Nodes;
    PROTECT(Nodes = NEW_LIST(size()));
    int k = 0;
    for (node_t *p : *this) {
      SET_ELEMENT(Nodes,k++,p->structure());
    }
    UNPROTECT(1);
    return Nodes;
  };

Here is the call graph for this function:

Here is the caller graph for this function:

swap()

void nodeseq_t::swap ( ball_t * a, ball_t * b )

inline

swap balls a and b, wherever they lie

Definition at line 166 of file nodeseq.h.

                                   {
    node_t *p = a->holder();
    node_t *q = b->holder();
    if (p != q) {
      p->erase(a); q->insert(a); a->holder() = q;
      q->erase(b); p->insert(b); b->holder() = p;
    }
  };

Here is the call graph for this function:

Here is the caller graph for this function:

trace_lineage()

void nodeseq_t::trace_lineage ( ball_t * b, name_t u )

inlineprivate

trace back a single lineage. this results in the deme slot for all green balls along the lineage of 'b' begin replaced by the lineage of 'b'.

Definition at line 228 of file nodeseq.h.

                                           {
    node_t *p = b->holder();
    while (p->lineage() == null_lineage) {
      p->lineage() = u;
      p = p->parent();
    }
  };

Here is the call graph for this function:

Here is the caller graph for this function:

trace_lineages()

void nodeseq_t::trace_lineages ( void )

inline

trace back all sample lineages. this results in the deme slots of all green balls being replaced by the unique names of the lineages they trace.

Definition at line 241 of file nodeseq.h.

                             {
    // we trace each lineage in turn.
    // because we move from early to late,
    // the order is guaranteed to be valid.
    name_t u = 0;
    for (node_t *p : *this ) {
      for (ball_t *b : *p) {
        if (b->color==blue) {
          trace_lineage(b,u);
          u++;
        }
      }
    }
  };

Here is the call graph for this function:

Here is the caller graph for this function:

yaml()

virtual std::string nodeseq_t::yaml ( std::string tab = "" ) const

inlinevirtual

human- & machine-readable info

Reimplemented in genealogy_t.

Definition at line 267 of file nodeseq.h.

                                                    {
    std::string o = "";
    std::string t = tab + "  ";
    for (node_t *p : *this) {
      o += tab + "- " + p->yaml(t);
    }
    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 nodeseq_t & G, raw_t * o )

friend

binary serialization

Definition at line 47 of file nodeseq.h.

                                                          {
    size_t nnode = G.size();
    memcpy(o,&nnode,sizeof(size_t)); o += sizeof(size_t);
    for (node_t *p : G) {
      o = (*p >> o);
    }
    return o;
  };

operator>> [2/2]

raw_t * operator>> ( raw_t * o, nodeseq_t & G )

friend

binary deserialization

Definition at line 56 of file nodeseq.h.

                                                    {
    G.clean();
    std::unordered_map<name_t,node_t*> node_names;
    std::unordered_map<name_t,ball_t*> ball_names;
    size_t nnode = 0;
    memcpy(&nnode,o,sizeof(size_t)); o += sizeof(size_t);
    node_names.reserve(nnode);
    ball_names.reserve(nnode);
    for (size_t i = 0; i < nnode; i++) {
      node_t *p = new node_t();
      o = (o >> *p);
      G.push_back(p);
      node_names.insert({p->uniq,p});
    }
    for (node_t *q : G) {
      q->repair_owners(node_names,&ball_names);
    }
    G.repair_owners(ball_names);
    G.trace_lineages();
    return o;
  };

---

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

• src/nodeseq.h