//! Prefix increment of the iterator. iterator& operator++() { if (!m_valid) return *this; if (m_v == m_cst->root() and m_visited) { m_valid = false; return *this; } value_type w; if (!m_visited) { // go down, if possible if (m_cst->is_leaf(m_v)) { w = m_cst->sibling(m_v); // determine sibling of leaf v if (w == m_cst->root()) { // if there exists no right sibling of the leaf v // w = m_cst->parent(m_v); w = parent(); m_visited = true; // go up } } else { // v is not a leaf => go down the tree w = first_child(); } } else { // w = m_cst->sibling(m_v); if (w == m_cst->root()) { // if there exists no right sibling w = parent(); } else { m_visited = false; } } m_v = w; return *this; }
//! Prefix increment of the iterator. iterator& operator++() { if (!m_valid) return *this; if (m_v == m_cst->root()) { m_valid = false; return *this; } value_type w = m_cst->sibling(m_v); if (w == m_cst->root()) { // if no next right sibling exist m_v = m_cst->parent(m_v); // go to parent } else { // if next right sibling exist m_v = m_cst->leftmost_leaf(w); // go to leaftmost leaf in the subtree of w } return *this; }
void test_cst_child_operation(const Cst& cst, typename Cst::size_type times=5000, uint64_t x=17) { typedef typename Cst::size_type size_type; typedef typename Cst::node_type node_type; std::vector<node_type> nodes; generate_nodes_from_random_leaves(cst, times, nodes, x); // for(size_type i=0; i<20; ++i){ // std::cout<< cst.lb(nodes[i])<<" "<<cst.rb(nodes[i])<<std::endl; // } // choose some chars for the text unsigned char* letters = new unsigned char[nodes.size()+1]; for (size_type i=0; i<nodes.size(); ++i) { letters[i] = cst.csa.bwt[i]; } node_type c; // for child node size_type char_pos=0; size_type cnt=0; write_R_output("cst","child","begin",nodes.size(),cnt); for (size_type i=0; i<nodes.size(); ++i) { // if(i<20){ // std::cout<<"i="<<i<<" vl="<<cst.lb(nodes[i])<<" rb="<<cst.rb(nodes[i])<<std::endl; // std::cout<<cst.csa[cst.lb(nodes[i])]<<" "<<cst.depth(nodes[i])<<std::endl; // } c = cst.child(nodes[i], letters[i], char_pos); if (c==cst.root()) ++cnt; } write_R_output("cst","child","end",nodes.size(),cnt); delete [] letters; }
void test_cst_parent_operation(const Cst& cst, typename Cst::size_type times=100000, uint64_t x=17) { typedef typename Cst::size_type size_type; typedef typename Cst::node_type node_type; srand(x); size_type n = cst.csa.size(); // take \f$ time \f$ random leaves std::vector<node_type> rand_leaf(times); for (size_type i=0; i<rand_leaf.size(); ++i) { rand_leaf[i] = cst.select_leaf(1+ (rand() % n)); } node_type p; size_type cnt=0; write_R_output("cst","parent","begin",times,cnt); for (size_type i=0; i<times; ++i, ++cnt) { p = cst.parent(rand_leaf[i]); while (p != cst.root()) { p = cst.parent(p); ++cnt; } } write_R_output("cst","parent","end",times,cnt); }
//! Constructor cst_dfs_const_forward_iterator(const Cst* cst, const value_type node, bool visited=false, bool valid=true):m_visited(visited), m_valid(valid), m_stack_cache(nullptr) { m_cst = cst; m_v = node; if (m_cst == nullptr) { m_valid = false; } else if (m_v == m_cst->root() and !m_visited and m_valid) { // if the iterator equal cst.begin() m_stack_cache = new node_type[cache_size]; m_stack_size = 0; // std::cerr<<"#creating stack "<<m_cst->lb(m_v)<<" "<<m_cst->rb(m_v)<<std::endl; } }
//! Prefix increment of the iterator. iterator& operator++() { if (!m_valid) return *this; if (m_queue.empty()) { m_valid = false; return *this; } value_type v = m_queue.front(); m_queue.pop(); value_type child = m_cst->select_child(v, 1); while (m_cst->root() != child) { m_queue.push(child); child = m_cst->sibling(child); } return *this; }
void generate_nodes_from_random_leaves(const Cst& cst, typename Cst::size_type times, std::vector<typename Cst::node_type>& nodes, uint64_t x=17) { typedef typename Cst::size_type size_type; typedef typename Cst::node_type node_type; srand(x); size_type n = cst.csa.size(); // generate nodes for (size_type i=0; i<times; ++i) { node_type p = cst.select_leaf(1+ (rand() % n)); nodes.push_back(p); while (p != cst.root()) { p = cst.parent(p); nodes.push_back(p); } } }
void test_cst_1th_child_operation(const Cst& cst, typename Cst::size_type times=1000000, uint64_t x=17) { typedef typename Cst::size_type size_type; typedef typename Cst::node_type node_type; std::vector<node_type> nodes; generate_nodes_from_random_leaves(cst, times, nodes, x); node_type c; // for 1th_child node size_type cnt=0; write_R_output("cst","1th_child","begin",nodes.size(),cnt); for (size_type i=0; i<nodes.size(); ++i) { c = cst.select_child(nodes[i], 1); if (c==cst.root()) ++cnt; } write_R_output("cst","1th_child","end",nodes.size(),cnt); }
void test_cst_sl_operation(const Cst& cst, typename Cst::size_type times=500, uint64_t x=17) { typedef typename Cst::size_type size_type; typedef typename Cst::node_type node_type; size_type n = cst.csa.size(); if (times > n) times = n; std::vector<node_type> nodes(times); srand(x); // take \f$ times \f$ random leaves and calculate each parent for (size_type i=0; i<times; ++i) { nodes[i] = cst.parent(cst.select_leaf(rand()%n + 1)); } size_type cnt=0; times = 0; write_R_output("cst","sl","begin",0,cnt); for (size_type i=0; i<nodes.size(); ++i) { node_type v = nodes[i]; // std::cout<<"v="<<cst.lb(v)<<" "<<cst.rb(v)<<std::endl; // size_type d = cst.depth(v); while (v != cst.root()) { // while v is not the root ++cnt; v = cst.sl(v); // follow suffix link // if( cnt < 30 ){ // std::cout<< cnt << " " << cst.lb(v) << " " << cst.rb(v) << " " << cst.depth(v) << std::endl; // } // size_type d2 = cst.depth(v); // if( d != d2+1 ){ // std::cout<<"error at cnt "<<cnt<<" d="<<d<<" d2="<<d2<<std::endl; // } // d = d2; } } write_R_output("cst","sl","end",cnt,cnt); }
void test_cst_lca_operation(const Cst& cst, typename Cst::size_type times=1000000, uint64_t x=17) { typedef typename Cst::size_type size_type; typedef typename Cst::node_type node_type; // generate \f$2^{19}\f$ random pairs of leafs size_type n = cst.csa.size(); uint64_t mask = (1<<20)-1; std::vector<node_type> nodes(1<<20); srand(x); for (size_type i=0; i < nodes.size(); ++i) { nodes[i] = cst.select_leaf(rand()%n + 1); } size_type cnt=0; write_R_output("cst","lca","begin",times,cnt); for (size_type i=0; i<times; ++i) { node_type v = cst.lca(nodes[(2*i) & mask], nodes[(2*i+1) & mask]); if (v == cst.root()) cnt++; // if(i<30) // std::cout<<"lca("<<cst.lb(nodes[(2*i)&mask])<<","<<cst.lb(nodes[(2*i+1)&mask])<<")=("<<cst.lb(v)<<","<<cst.rb(v)<<")"<<std::endl; } write_R_output("cst","lca","end",times,cnt); }